description: Trace a ray against the world and return touching hits and then first blocking hit Results are sorted, so a blocking hit (if found) will be the last element of the array Only the single closest blocking result will be generated, no tests will be done after that

code: static bool RaycastMulti ( const [UWorld](API\Runtime\Engine\Engine\UWorld) * World, [TArray](API\Runtime\Core\Containers\TArray)< struct [FHitResult](API\Runtime\Engine\Engine\FHitResult) > & OutHits, const FVector & Start, const FVector & End, ECollisionChannel TraceChannel, const [FCollisionQueryParams](API\Runtime\Engine\FCollisionQueryParams) & Params, const [FCollisionResponseParams](API\Runtime\Engine\FCollisionResponseParams) & ResponseParams, const [FCollisionObjectQueryParams](API\Runtime\Engine\FCollisionObjectQueryParams) & ObjectParams )


description: Trace a ray against the world and return the first blocking hit

module: Engine

code: static bool RaycastSingle ( const [UWorld](API\Runtime\Engine\Engine\UWorld) * World, struct [FHitResult](API\Runtime\Engine\Engine\FHitResult) & OutHit, const FVector Start, const FVector End, ECollisionChannel TraceChannel, const [FCollisionQueryParams](API\Runtime\Engine\FCollisionQueryParams) & Params, const [FCollisionResponseParams](API\Runtime\Engine\FCollisionResponseParams) & ResponseParams, const [FCollisionObjectQueryParams](API\Runtime\Engine\FCollisionObjectQueryParams) & ObjectParams )


description: Trace a ray against the world and return if a blocking hit is found

code: static bool RaycastTest ( const [UWorld](API\Runtime\Engine\Engine\UWorld) * World, const FVector Start, const FVector End, ECollisionChannel TraceChannel, const [FCollisionQueryParams](API\Runtime\Engine\FCollisionQueryParams) & Params, const [FCollisionResponseParams](API\Runtime\Engine\FCollisionResponseParams) & ResponseParams, const [FCollisionObjectQueryParams](API\Runtime\Engine\FCollisionObjectQueryParams) & ObjectParams )


className: FGenericPhysicsInterface

code: struct FGenericPhysicsInterface


code: static bool RaycastSingle ( const TAccel & Accel, const [UWorld](API\Runtime\Engine\Engine\UWorld) * World, struct [FHitResult](API\Runtime\Engine\Engine\FHitResult) & OutHit, const FVector Start, const FVector End, ECollisionChannel TraceChannel, const [FCollisionQueryParams](API\Runtime\Engine\FCollisionQueryParams) & Params, const [FCollisionResponseParams](API\Runtime\Engine\FCollisionResponseParams) & ResponseParams, const [FCollisionObjectQueryParams](API\Runtime\Engine\FCollisionObjectQueryParams) & ObjectParams )


code: static bool RaycastMulti ( const TAccel & Accel, const [UWorld](API\Runtime\Engine\Engine\UWorld) * World, [TArray](API\Runtime\Core\Containers\TArray)< struct [FHitResult](API\Runtime\Engine\Engine\FHitResult) > & OutHits, const FVector & Start, const FVector & End, ECollisionChannel TraceChannel, const [FCollisionQueryParams](API\Runtime\Engine\FCollisionQueryParams) & Params, const [FCollisionResponseParams](API\Runtime\Engine\FCollisionResponseParams) & ResponseParams, const [FCollisionObjectQueryParams](API\Runtime\Engine\FCollisionObjectQueryParams) & ObjectParams )


code: static bool RaycastTest ( const TAccel & Accel, const [UWorld](API\Runtime\Engine\Engine\UWorld) * World, const FVector Start, const FVector End, ECollisionChannel TraceChannel, const [FCollisionQueryParams](API\Runtime\Engine\FCollisionQueryParams) & Params, const [FCollisionResponseParams](API\Runtime\Engine\FCollisionResponseParams) & ResponseParams, const [FCollisionObjectQueryParams](API\Runtime\Engine\FCollisionObjectQueryParams) & ObjectParams )


code: template<typename TAccel> struct FGenericRaycastPhysicsInterfaceUsingSpatialAcceleration


className: FGeometryAddParams

code: struct FGeometryAddParams

bDoubleSided

type: bool

ChaosTriMeshes

type: TArrayView<TSh...

CollisionData

type: FBodyCollisionD...

CollisionTraceType

type: ECollisionTrace...

ComplexMaterialMasks

type: TArrayView<FPh...

ComplexMaterials

type: TArrayView<UPh...

Geometry

type: FKAggregateGeom...

LocalTransform

type: FTransform

Scale

type: FVector

SimpleMaterial

type: UPhysicalMateri...


description: Called after any presim callbacks are triggered and after physics data has marshalled over in order to modify the sim callback outputs

code: virtual void ApplyCallbacks_Internal ( int32 PhysicsStep, const [TArray](API\Runtime\Core\Containers\TArray)< [Chaos::ISimCallbackObject](API\Runtime\Chaos\Chaos\ISimCallbackObject) * > & SimCallbackObjects )


description: Rewind API.

code: virtual void InjectInputs_External ( int32 PhysicsStep, int32 NumSteps )


description: Called before any inputs are marshalled over to the physics thread. The physics state has not been applied yet, and cannot be inspected anyway because this is triggered from the external thread (game thread) Gives user the ability to modify inputs or record them - this can help with reducing latency if you want to act on inputs immediately

code: virtual void ProcessInputs_External ( int32 PhysicsStep, const [TArray](API\Runtime\Core\Containers\TArray)< [Chaos::FSimCallbackInputAndObject](API\Runtime\Chaos\Chaos\FSimCallbackInputAndObject) > & SimCallbackInputs )


description: Register a sim callback onto the rewind callback

code: virtual void RegisterRewindableSimCallback_Internal ( [Chaos::ISimCallbackObject](API\Runtime\Chaos\Chaos\ISimCallbackObject) * Callback )


description: Called before any sim callbacks are triggered but after physics data has marshalled over This means brand new physics particles are already created for example, and any pending game thread modifications have happened See ISimCallbackObject for recording inputs to callbacks associated with this PhysicsStep

code: virtual void ProcessInputs_Internal ( int32 PhysicsStep, const [TArray](API\Runtime\Core\Containers\TArray)< [Chaos::FSimCallbackInputAndObject](API\Runtime\Chaos\Chaos\FSimCallbackInputAndObject) > & SimCallbackInputs )


description: Update client player on GT.

code: void UpdateClientPlayer_External ( int32 PhysicsStep )


description: Called after sim step to give the option to rewind. Any pending inputs for the next frame will remain in the queue Return the PhysicsStep to start resimulating from. Resim will run up until latest step passed into RecordInputs (i.e. latest physics sim simulated so far) Return INDEX_NONE to indicate no rewind

code: virtual int32 TriggerRewindIfNeeded_Internal ( int32 LatestStepCompleted )


description: Cache the current netmode for use in PT.

code: void UpdateNetMode()


description: Needs to be called from PT context to access fixed tick handle but also needs to be able to access GT data (actor iterator, actor state)

code: void UpdateReplicationMap_Internal ( int32 PhysicsStep )


description: Update server player on GT.

code: void UpdateServerPlayer_External ( int32 PhysicsStep )


code: FNetworkPhysicsCallback ( [UWorld](API\Runtime\Engine\Engine\UWorld) * InWorld )


className: FNetworkPhysicsCallback

description: Network physics rewind callback to manage all the sim callbacks rewind functionalities

code: struct FNetworkPhysicsCallback : public [Chaos::IRewindCallback](API\Runtime\Chaos\IRewindCallback)

InjectInputsExternal

type: FOnInjectInputs...

description: Bind to this for additional processing on the GT duringInjectInputs_External()

NetMode

type: ENetMode

description: Current NetMode.

PostProcessInputsInternal

type: FOnPostProcessI...

PreProcessInputsInternal

type: FOnPreProcessIn...

description: Delegate on the internal inputs process.

RewindableCallbackObjects

description: List of rewindable sim callback objects.

World

type: UWorld*

description: World owning that callback.


description: Apply the datas from onto the network physics component.

code: virtual void ApplyDatas ( [UActorComponent](API\Runtime\Engine\Components\UActorComponent) * NetworkComponent ) const


description: Build the datas from the network physics component.

code: virtual void BuildDatas ( const [UActorComponent](API\Runtime\Engine\Components\UActorComponent) * NetworkComponent )


description: Serialize the datas into/from the archive.

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


className: FNetworkPhysicsDatas

description: Base network physics datas that will be used by physics

code: struct FNetworkPhysicsDatas

InputFrame

description: Input frame used to generate the network datas.

LocalFrame

description: Local frame at which this datas has been generated.

ServerFrame

description: Server frame at which this datas has been generated.

UNetworkPhysicsComponent

type: friend


className: FPhysicalMaterialMaskParams

code: struct FPhysicalMaterialMaskParams

PhysicalMaterialMap

type: UMaterialInterf...

description: Pointer to material which contains the physical material map

PhysicalMaterialMask

description: Physical materials mask


description: Pure virtual that must be overloaded by the inheriting class. Use this method to serialize any UObjects contained that you wish to keep around.

code: virtual void AddReferencedObjects ( [FReferenceCollector](API\Runtime\CoreUObject\UObject\FReferenceCollector) & Collector )


description:
Lets each mode/tool handle frustum selection in its own way.
true if something was selected/deselected, false otherwise.

code: virtual bool FrustumSelect ( const [FConvexVolume](API\Runtime\Engine\FConvexVolume) & InFrustum, [FEditorViewportClient](API\Editor\UnrealEd\FEditorViewportClient) * InViewportClient, bool InSelect )


code: virtual bool InputAxis ( [FEditorViewportClient](API\Editor\UnrealEd\FEditorViewportClient) * ViewportClient, [FViewport](API\Runtime\Engine\FViewport) * Viewport, int32 ControllerId, [FKey](API\Runtime\InputCore\FKey) Key, float Delta, float DeltaTime )


code: virtual bool InputKey ( [FEditorViewportClient](API\Editor\UnrealEd\FEditorViewportClient) * ViewportClient, [FViewport](API\Runtime\Engine\FViewport) * Viewport, [FKey](API\Runtime\InputCore\FKey) Key, EInputEvent Event )


code: virtual bool InputDelta ( [FEditorViewportClient](API\Editor\UnrealEd\FEditorViewportClient) * ViewportClient, [FViewport](API\Runtime\Engine\FViewport) * Viewport, FVector & Drag, FRotator & Rotation, FVector & Scale )


code: virtual bool IsCompatibleWith ( FEditorModeID OtherModeID ) const


description: Draws translucent polygons on brushes and volumes.

code: virtual void Render ( const [FSceneView](API\Runtime\Engine\FSceneView) * View, [FViewport](API\Runtime\Engine\FViewport) * Viewport, [FPrimitiveDrawInterface](API\Runtime\Engine\FPrimitiveDrawInterface) * PDI )


code: virtual bool ShouldDrawWidget() const


code: virtual void Tick ( [FEditorViewportClient](API\Editor\UnrealEd\FEditorViewportClient) * ViewportClient, float DeltaTime )


className: FPhysicsDebugMode

code: class FPhysicsDebugMode : public [FEdMode](API\Editor\UnrealEd\FEdMode)


code: void ConditionalSetFlags ( EPhysXFilterDataFlags Flag, bool bEnabled )


code: void GetQueryData ( uint32 ActorID, uint32 & OutWord0, uint32 & OutWord1, uint32 & OutWord2, uint32 & OutWord3 ) const


code: void GetCombinedData ( uint32 & OutBlockingBits, uint32 & OutTouchingBits, uint32 & OutObjectTypeAndFlags ) const


code: void GetSimData ( uint32 BodyIndex, uint32 ComponentID, uint32 & OutWord0, uint32 & OutWord1, uint32 & OutWord2, uint32 & OutWord3 ) const


code: FPhysicsFilterBuilder ( [TEnumAsByte](API\Runtime\Core\Containers\TEnumAsByte)< enum ECollisionChannel > InObjectType, FMaskFilter MaskFilter, const struct [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & ResponseToChannels )


className: FPhysicsFilterBuilder

code: struct FPhysicsFilterBuilder


code: void AddForceFunction ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(typename [ImplType::DataType](API\Plugins\OptimusCore\DataType) &, const float, const int32)> ForceFunction )


code: void AddPBDConstraintFunction ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(typename [ImplType::DataType](API\Plugins\OptimusCore\DataType) &, const float)> ConstraintFunction )


code: void SetCreateBodiesFunction ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(typename [ImplType::DataType](API\Plugins\OptimusCore\DataType) &)> CreateBodies )


code: void SetKinematicUpdateFunction ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(typename [ImplType::DataType](API\Plugins\OptimusCore\DataType) &, const float, const float, const int32)> KinematicUpdate )


code: void SetEndFrameFunction ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(const float)> EndFrame )


code: void SetParameterUpdateFunction ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(typename [ImplType::DataType](API\Plugins\OptimusCore\DataType) &, const float, const int32)> ParameterUpdate )


code: void SetStartFrameFunction ( [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void(const float)> StartFrame )


code: void Tick ( float InDeltaSeconds )


code: template<typename ImplType> class FPhysScene_Base


description: Compute sprung masses, stiffnesses, damping, etc.

code: void ComputeSpringParams ( const float TotalMass, const float Gravity )


description: Take full set of parameters. They might be invalid, who cares.

code: void Setup ( const [FSimpleSuspensionParams](API\Runtime\Engine\Physics\FSimpleSuspensionParams) & InSuspensionParams )


description: Copy in a full set of parameters, and then compute the spring params and overwrite whatever we got for that

code: void Setup ( const [FSimpleSuspensionParams](API\Runtime\Engine\Physics\FSimpleSuspensionParams) & InSuspensionParams, const float TotalMass, const float Gravity )


description: Compute suspension compressions, individual spring forces, and the total force that the suspension system wants to apply to the body. Actual application of this force must be done by someone else.

code: void Update ( const FTransform & LocalToWorld, const FVector & LinearVelocity, const FVector & AngularVelocityRad, const FSimpleSuspensionRaycast & RaycastFunction )


code: FSimpleSuspension ( const [FSimpleSuspensionParams](API\Runtime\Engine\Physics\FSimpleSuspensionParams) & SuspensionParams )


className: FSimpleSuspension

code: struct FSimpleSuspension

SuspensionParams

type: FSimpleSuspensi...


description: Calculates the Lambdas in the single axis case

code: static bool ComputeSingleAxisLambda ( const [FVector::FReal](API\Runtime\Core\Math\TVector\FReal) AxisDot, const [FVector::FReal](API\Runtime\Core\Math\TVector\FReal) SumAxis, const uint32 Count, [TArray](API\Runtime\Core\Containers\TArray)< [FVector::FReal](API\Runtime\Core\Math\TVector\FReal), [TFixedAllocator](API\Runtime\Core\Containers\TFixedAllocator)< 2 >> & Lambdas, [FString](API\Runtime\Core\Containers\FString) * ErrMsg )


description: Given a sprung mass and a natural frequency, return the damping coefficient which will critically damp the spring.

code: static float ComputeSpringCriticalDamping ( const float SprungMass, const float NaturalFrequency )


description: Given a sprung mass (not just a sprung mass percent!), a desired natural frequency, and a damping ratio, compute the damping coefficient of the spring.

code: static float ComputeSpringDamping ( const float SprungMass, const float NaturalFrequency, const float DampingRatio )


description: Compute the total force that a spring ought to apply

code: static float ComputeSpringForce ( const float SpringStiffness, const float SpringDamping, const float SpringDisplacement, const float SpringVelocity )


description: Given a sprung mass and a spring stiffness, compute the natural frequency of the spring

code: static void ComputeSpringNaturalFrequencyAndDampingRatio ( const float SprungMass, const float SpringStiffness, const float SpringDamping, float & OutNaturalFrequency, float & OutDampingRatio )


description: Compute an array of FSimpleSupportParams objects, based on data from a SuspensionParams object

code: static void ComputeSpringParams ( const [FSimpleSuspensionParams](API\Runtime\Engine\Physics\FSimpleSuspensionParams) & SuspensionParams, const float TotalMass, const float Gravity, [TArray](API\Runtime\Core\Containers\TArray)< [FSimpleSuspensionSpringParams](API\Runtime\Engine\Physics\FSimpleSuspensionSpringParams) > & OutSpringParams )


description: Compute an array of FSimpleSupportParams objects

code: static void ComputeSpringParams ( const [TArray](API\Runtime\Core\Containers\TArray)< FVector > & LocalSuspensionOrigins, const FVector & LocalCenterOfMass, const float TotalMass, const FVector & LocalSuspensionNormal, const float LocalGroundDistance, const float NaturalFrequency, const float DampingRatio, const float Gravity, [TArray](API\Runtime\Core\Containers\TArray)< [FSimpleSuspensionSpringParams](API\Runtime\Engine\Physics\FSimpleSuspensionSpringParams) > & OutSpringParams )


description: Based on spring stiffness, gravity, and the desired length of the spring at rest under load, compute its uncompressed rest-length

code: static float ComputeSpringRestLength ( const float SpringStiffness, const float SprungMass, const float SuspendedLength, const float Gravity )


description: Same as above, but allows the caller to specify spring locations in a local space which is not necessarily originated at the center of mass.

code: static bool ComputeSprungMasses ( const [TArray](API\Runtime\Core\Containers\TArray)< FVector > & LocalSpringPositions, const FVector & LocalCenterOfMass, const float TotalMass, [TArray](API\Runtime\Core\Containers\TArray)< float > & OutSprungMasses, [FString](API\Runtime\Core\Containers\FString) * ErrMsg )


description: Given a sprung mass (not just a sprung mass percent!), a desired natural frequency, compute the stiffness of the spring.

code: static float ComputeSpringStiffness ( const float SprungMass, const float NaturalFrequency )


description: Returns true if it was able to find a valid mass configuration. If only one or two springs are included, then a valid configuration may not result in a stable suspension system - a bicycle or pogostick, for example, which is not perfectly centered may have a valid sprung mass configuration without being stable.

code: static bool ComputeSprungMasses ( const [TArray](API\Runtime\Core\Containers\TArray)< FVector > & MassSpringPositions, const float TotalMass, [TArray](API\Runtime\Core\Containers\TArray)< float > & OutSprungMasses, [FString](API\Runtime\Core\Containers\FString) * ErrMsg )


code: static void ComputeSuspensionDisplacements ( const [FSimpleSuspensionParams](API\Runtime\Engine\Physics\FSimpleSuspensionParams) & SuspensionParams, const FSimpleSuspensionRaycast & RaycastFunction, [FSimpleSuspensionState](API\Runtime\Engine\Physics\FSimpleSuspensionState) InOutSuspensionState )


description: Perform raycasts to compute spring displacements. This helper doesn't know about "world", so it takes a lambda. Consumers of this class may just want to do this themselves to avoid this

code: static void ComputeSuspensionDisplacements ( const [TArray](API\Runtime\Core\Containers\TArray)< FVector > WorldSuspensionOrigins, const [TArray](API\Runtime\Core\Containers\TArray)< [FSimpleSuspensionSpringParams](API\Runtime\Engine\Physics\FSimpleSuspensionSpringParams) > & SpringParams, const FVector & WorldSuspensionNormal, const FSimpleSuspensionRaycast & RaycastFunction, [TArray](API\Runtime\Core\Containers\TArray)< float > & OutSpringDisplacements )


code: static void ComputeSuspensionForces ( const FVector & LinearVelocity, const FVector & AngularVelocityRad, const [FSimpleSuspensionState](API\Runtime\Engine\Physics\FSimpleSuspensionState) & SuspensionState, const [TArray](API\Runtime\Core\Containers\TArray)< [FSimpleSuspensionSpringParams](API\Runtime\Engine\Physics\FSimpleSuspensionSpringParams) > & SpringParams, [FSimpleSuspensionState](API\Runtime\Engine\Physics\FSimpleSuspensionState) & OutSuspensionState )


description: Based on the current state of the system, compute the total force and torque that the suspension system wants to apply to the suspended body, as well as the spring force magnitudes of each support.

code: static void ComputeSuspensionForces ( const FVector & LinearVelocity, const FVector & AngularVelocityRad, const FVector & WorldCenterOfMass, const FVector & WorldSuspensionNormal, const [TArray](API\Runtime\Core\Containers\TArray)< FVector > WorldSuspensionOrigins, const [TArray](API\Runtime\Core\Containers\TArray)< [FSimpleSuspensionSpringParams](API\Runtime\Engine\Physics\FSimpleSuspensionSpringParams) > & SpringParams, const [TArray](API\Runtime\Core\Containers\TArray)< float > & SpringDisplacements, FVector & OutTotalForce, FVector & OutTotalTorque, [TArray](API\Runtime\Core\Containers\TArray)< float > & OutSpringForces )


code: static void ComputeWorldSuspensionCoordinates ( const [FSimpleSuspensionParams](API\Runtime\Engine\Physics\FSimpleSuspensionParams) & SuspensionParams, const FTransform & LocalToWorld, [FSimpleSuspensionState](API\Runtime\Engine\Physics\FSimpleSuspensionState) & OutSuspensionState )


description: Dynamics functions

code: static void ComputeWorldSuspensionCoordinates ( const FVector & LocalCenterOfMass, const FVector & LocalSuspensionNormal, const [TArray](API\Runtime\Core\Containers\TArray)< FVector > & LocalSuspensionOrigins, const FTransform & LocalToWorld, FVector & OutWorldCenterOfMass, FVector & OutWorldSuspensionNormal, [TArray](API\Runtime\Core\Containers\TArray)< FVector > & OutWorldSuspensionOrigins )


description: Integrate a single spring.

code: static void IntegrateSpring ( const float DeltaTime, const float SpringDisplacement, const float SpringVelocity, const [FSimpleSuspensionSpringParams](API\Runtime\Engine\Physics\FSimpleSuspensionSpringParams) & SpringParams, const float SprungMass, float & OutNewSpringDisplacement, float & OutNewSpringVelocity )


description: Performs a fully implicit damped spring integration to compute next positions and velocities.

code: static void IntegrateSprings ( const float DeltaTime, const [TArray](API\Runtime\Core\Containers\TArray)< float > & SpringDisplacements, const [TArray](API\Runtime\Core\Containers\TArray)< float > & SpringVelocities, const [TArray](API\Runtime\Core\Containers\TArray)< [FSimpleSuspensionSpringParams](API\Runtime\Engine\Physics\FSimpleSuspensionSpringParams) > & SuspensionParams, const [TArray](API\Runtime\Core\Containers\TArray)< float > & SprungMasses, [TArray](API\Runtime\Core\Containers\TArray)< float > & OutNewSpringDisplacements, [TArray](API\Runtime\Core\Containers\TArray)< float > & OutNewSpringVelocities )


className: FSimpleSuspensionHelpers

code: struct FSimpleSuspensionHelpers


className: FSimpleSuspensionParams

code: struct FSimpleSuspensionParams

DampingRatio

type: float

LocalSpringOrigins

type: TArray< FVector...

SpringParams

type: TArray<FSimple...


className: FSimpleSuspensionSpringParams

code: struct FSimpleSuspensionSpringParams


className: FSimpleSuspensionState

code: struct FSimpleSuspensionState

SpringContacts

type: TArray< bool >

SpringDisplacements

type: TArray< float >


description: Buffers used as scratch space for PhysX to avoid allocations during simulation

code: struct FSimulationScratchBuffer2

Buffer

type: uint8 *

description: The scratch buffer.

BufferSize

description: Allocated size of the buffer.


className: IImediatePhysicsModule

description: ImediatePhysics Edit mode module interface

code: class IImediatePhysicsModule : public [IModuleInterface](API\Runtime\Core\Modules\IModuleInterface)


code: void AddRadialForce ( const FVector & Origin, [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) Strength, [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) Radius, ERadialImpulseFalloff Falloff, [EForceType](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsShared\ImmediatePhysics-_1) ForceType )


code: void AddForce ( const FVector & Force )


code: void AddImpulseAtLocation ( FVector Impulse, FVector Location )


code: void AddTorque ( const FVector & Torque )


description: Get the angular damping


description: Get the angular velocity

code: FVector GetAngularVelocity() const


description: Get the inverse inertia. Mass-space inverse inertia diagonal vector

code: FVector GetInverseInertia() const


description: Get the inverse mass.


description: Is the actor kinematic

code: bool GetIsKinematic() const


description: Gets the kinematic target (next transform) for the actor if one is set (checkHasKinematicTarget()to see if a target is available)

code: const [FKinematicTarget](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FKinematicTarget) & GetKinematicTarget() const


description: Get the linear damping


description: Get the linear velocity

code: FVector GetLinearVelocity() const


description: Get the actor-space centre of mass offset

code: FTransform GetLocalCoMTransform() const


description: Get the max contact impulse


description: Get the max angular velocity squared


description: Get the max depenetration velocity


code: const [FName](API\Runtime\Core\UObject\FName) & GetName() const


description: Get the max linear velocity squared


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


description: Get the world transform

code: FTransform GetWorldTransform() const


description: Does this actor have a kinematic target (next kinematic transform to be applied)

code: bool HasKinematicTarget() const


description: Sets the world transform, zeroes velocity, etc.

code: void InitWorldTransform ( const FTransform & WorldTM )


description: Returns true if the world gravity applies to this actor

code: bool IsGravityEnabled() const


description: Whether the body is simulating

code: bool IsSimulated() const


description: Whether the body is static

code: bool IsStatic() const


description: Set the angular damping

code: void SetAngularDamping ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) NewAngularDamping )


description: Set the angular velocity

code: void SetAngularVelocity ( const FVector & NewAngularVelocity )


description: Sets whether world gravity should apply to this actor, assuming it is dynamic

code: void SetGravityEnabled ( bool bEnable )


description: Set the inverse inertia. Mass-space inverse inertia diagonal vector

code: void SetInverseInertia ( const FVector & NewInverseInertia )


description: Set the inverse mass. 0 indicates kinematic object

code: void SetInverseMass ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) NewInverseMass )


description: Sets the kinematic target. This will affect velocities as expected

code: void SetKinematicTarget ( const FTransform & WorldTM )


description: Normally used to modify a EParticleType::Rigid between kinematic and dynamic. Returns true if that was possible (even if nothing changed). Returns false if it fails - e.g. because there was no current ParticleHandle, or if the particle type was not EParticleType::Rigid (unless the current type was EParticleType::Kinematic and bKinematic was true)

code: bool SetIsKinematic ( bool bKinematic )


description: Set the linear damping

code: void SetLinearDamping ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) NewLinearDamping )


description: Set the linear velocity

code: void SetLinearVelocity ( const FVector & NewLinearVelocity )


description: Set the max angular velocity squared

code: void SetMaxAngularVelocitySquared ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) NewMaxAngularVelocitySquared )


description: Set the max contact impulse

code: void SetMaxContactImpulse ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) NewMaxContactImpulse )


description: Set the max depenetration velocity

code: void SetMaxDepenetrationVelocity ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) NewMaxDepenetrationVelocity )


code: void SetName ( const [FName](API\Runtime\Core\UObject\FName) & InName )


description: Set the max linear velocity squared

code: void SetMaxLinearVelocitySquared ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) NewMaxLinearVelocitySquared )


description: Sets the world transform, maintains velocity etc.

code: void SetWorldTransform ( const FTransform & WorldTM )


className: FActorHandle

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

code: struct FActorHandle


code: const [Chaos::TVec2](API\Runtime\ChaosCore\Chaos\TVec2)< [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * > & GetActorHandles()


code: const [Chaos::TVec2](API\Runtime\ChaosCore\Chaos\TVec2)< const [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * > & GetActorHandles() const


code: const [FChaosConstraintHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FJointHandle\FChaosConstraint-_1) * GetConstraint() const


code: FJointHandle ( [FChaosConstraintContainer](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FJointHandle\FChaosConstraint-) * InConstraints, [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) * ConstraintInstance, [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * InActor1, [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * InActor2 )


code: void SetSoftLinearSettings ( bool bLinearSoft, [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) LinearStiffness, [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) LinearDamping )


code: FJointHandle ( [FChaosConstraintContainer](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FJointHandle\FChaosConstraint-) * InConstraints, const [FPBDJointSettings](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FJointHandle\FPBDJointSetting-) & ConstraintSettings, [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * InActor1, [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * InActor2 )


className: FJointHandle

description: Handle associated with a physics joint. This is the proper way to read/write to the physics simulation

code: struct FJointHandle


description: Set up potential collisions between the actor and all other dynamic actors

code: void AddToCollidingPairs ( [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * ActorHandle )


code: [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * CreateActor ( [EActorType](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsShared\ImmediatePhysics-) ActorType, [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * BodyInstance, const FTransform & Transform )


description: Create a dynamic body and add it to the simulation

code: [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * CreateDynamicActor ( [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * BodyInstance, const FTransform & Transform )


description: Create a physical joint and add it to the simulation

code: [FJointHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FJointHandle) * CreateJoint ( [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) * ConstraintInstance, [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * Body1, [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * Body2 )


code: [FJointHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FJointHandle) * CreateJoint ( const [Chaos::FPBDJointSettings](API\Runtime\Chaos\Chaos\FPBDJointSettings) & ConstraintSettings, [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) *const Body1, [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) *const Body2 )


description: Create a kinematic body and add it to the simulation

code: [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * CreateKinematicActor ( [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * BodyInstance, const FTransform & Transform )


description: Create a static body and add it to the simulation

code: [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * CreateStaticActor ( [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * BodyInstance )


description: Explicit debug draw path if the use case needs it to happen at a point outside of the simulation

code: void DebugDraw()


code: void DestroyActor ( [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * ActorHandle )


code: void DestroyActorCollisions ( [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * ActorHandle )


code: void DestroyJoint ( [FJointHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FJointHandle) * JointHandle )


className: FIgnorePair

description: An array of actors to ignore.

code: struct FIgnorePair

A

type: FActorHandle&#...


className: FImplementation

code: struct FImplementation

ActorHandles

type: TArray<FActorH...

description: Mapping from entity index to handle

bActorsDirty

type: bool

IgnoreCollisionParticlePairTable

type: TMap< constCha...

description: Slow to access.

JointHandles

type: TArray<FJointH...

description: Mapping from constraint index to handle

UniqueIndices

type: FSimpleParticle...


code: [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * GetActorHandle ( int32 ActorHandleIndex )


code: const [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * GetActorHandle ( int32 ActorHandleIndex ) const


code: void InitSimulationSpace ( const FTransform & Transform )


description: Set bodies that require no collision

code: void SetIgnoreCollisionActors ( const [TArray](API\Runtime\Core\Containers\TArray)< [FActorHandle](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FActorHandle) * > & InIgnoreCollisionActors )


description: Set pair of bodies to ignore collision for

code: void SetIgnoreCollisionPairTable ( const [TArray](API\Runtime\Core\Containers\TArray)< [FIgnorePair](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FSimulation\FIgnorePair) > & InIgnoreCollisionPairTable )


code: void SetSimulationSpaceSettings ( const [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) Alpha, const FVector & ExternalLinearEtherDrag )


description: Sets the number of active bodies. This number is reset any time a new simulated body is created

code: void SetNumActiveBodies ( int32 NumActiveBodies, [TArray](API\Runtime\Core\Containers\TArray)< int32 > ActiveBodyIndices )


description: Advance the simulation by DeltaTime

code: void Simulate ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) DeltaTime, [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) MaxStepTime, int32 MaxSubSteps, const FVector & InGravity )


description: Set settings. Invalid (negative) values with leave that value unchanged from defaults

code: void SetSolverSettings ( const [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) FixedDt, const [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) CullDistance, const [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) MaxDepenetrationVelocity, const int32 UseLinearJointSolver, const int32 PositionIts, const int32 VelocityIts, const int32 ProjectionIts )


code: void Simulate_AssumesLocked ( [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) DeltaTime, [FReal](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\FReal) MaxStepTime, int32 MaxSubSteps, const FVector & InGravity )


code: void UpdateSimulationSpace ( const FTransform & Transform, const FVector & LinearVel, const FVector & AngularVel, const FVector & LinearAcc, const FVector & AngularAcc )


className: FSimulation

description: Owns all the data associated with the simulation. Can be considered a single scene or world

code: struct FSimulation


description: Clear the kinematic target

code: void Clear()


code: template<typename TOther> void CopyFrom ( const TOther & Other )


description: Get the kinematic target mode


description: Get the target transform (asserts if not in Position mode)

code: [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, d > GetTarget() const


description: Get the target position (asserts if not in Position mode)

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


description: Get the target rotation (asserts if not in Position mode)

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


code: bool IsEqual ( const [TKinematicTarget](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\TKinematicTarget) & other ) const


code: template<typename TOther> bool IsEqual ( const TOther & other ) const


description: Whether this kinematic target has been set (either velocity or position mode)

code: bool IsSet() const


code: static [TKinematicTarget](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\TKinematicTarget)< T, d > MakePositionTarget ( const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, d > & InTransform )


code: static [TKinematicTarget](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\TKinematicTarget)< T, d > MakePositionTarget ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & InPosition, const [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, d > & InRotation )


description: For internal use only.

code: void SetMode ( [EKinematicTargetMode](API\Runtime\Chaos\Chaos\Chaos__EKinematicTargetMode) InMode )


description: Use transform target mode and set the transform target

code: void SetTargetMode ( const [TRigidTransform](API\Runtime\Chaos\Chaos\TRigidTransform)< T, d > & InTarget )


code: void SetTargetMode ( const [TVector](API\Runtime\Chaos\Chaos\TVector)< T, d > & X, const [TRotation](API\Runtime\Chaos\Chaos\TRotation)< T, d > & R )


description: Use velocity target mode

code: void SetVelocityMode()


code: TKinematicTarget &40; const TRigidTransform< T, d > & InTransform &41;


code: bool operator== ( const [TKinematicTarget](API\Runtime\Engine\Physics\ImmediatePhysics\ImmediatePhysicsChaos\TKinematicTarget) & other ) const


code: TKinematicTarget &40; const TVector< T, d > & InPosition, const TRotation< T, d > & InRotation &41;


className: TKinematicTarget

description: Data used to integrate kinematic bodies

code: template<class T, int d> class TKinematicTarget


className: TPBDConstraintIslandRule

code: template<typename T> class TPBDConstraintIslandRule


className: TSimpleConstraintRule

code: template<typename T> class TSimpleConstraintRule


code: namespace ImmediatePhysics_Shared { enum EActorType { StaticActor, KinematicActor, DynamicActor, } }


code: namespace ImmediatePhysics_Shared { enum EForceType { AddForce, AddAcceleration, AddImpulse, AddVelocity, } }


description: Deprecated* Use CreatePhysicsReplication (which gives a replication interface) instead

code: virtual [FPhysicsReplication](API\Runtime\Engine\FPhysicsReplication) * Create ( FPhysScene * OwningPhysScene )


description: NOTE: Once the old Create/Destroy methods are deprecated, remove the default implementation!

code: virtual [TUniquePtr](API\Runtime\Core\Templates\TUniquePtr)< [IPhysicsReplication](API\Runtime\Engine\IPhysicsReplication) > CreatePhysicsReplication ( FPhysScene * OwningPhysScene )


description: Deprecated* No longer used - PhysScene owns the physics replication ptr once it is created. If you need a custom deleter, override CreatePhysicsReplication and specify the deleter inTUniquePtr.

code: virtual void Destroy ( [FPhysicsReplication](API\Runtime\Engine\FPhysicsReplication) * PhysicsReplication )


className: FPhysicsTestHelpers

code: struct FPhysicsTestHelpers


className: IPhysicsReplicationFactory

description: Interface for the creation of customized physics replication.

code: class IPhysicsReplicationFactory


code: static [UWorld](API\Runtime\Engine\Engine\UWorld) * GetWorld()


description: Debug the datas from the archive

code: virtual void DebugDatas ( const [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ArchiveDatas, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & LocalFrames, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & ServerFrames, [TArray](API\Runtime\Core\Containers\TArray)< int32 > & InputFrames )


description: Deserialize the datas from the archive

code: virtual void DeserializeDatas ( const [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ArchiveDatas, const int32 FrameOffset )


description: Serialize the datas to the archive

code: virtual void SerializeDatas ( const uint32 StartFrame, const uint32 EndFrame, [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ArchiveDatas, const int32 FrameOffset ) const


className: Super

code: typedef [Chaos::TDatasRewindHistory](API\Runtime\Chaos\TDatasRewindHistory)< DatasType > Super


description: Set the package map for serialization

code: virtual void SetPackageMap ( class [UPackageMap](API\Runtime\CoreUObject\UObject\UPackageMap) * InPackageMap )


code: TNetRewindHistory ( const int32 FrameCount, const bool bIsHistoryLocal, [UPackageMap](API\Runtime\CoreUObject\UObject\UPackageMap) * InPackageMap )


className: TNetRewindHistory

description: Templated datas history holding a datas buffer

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


className: UAsyncPhysicsData

description: The base class for async physics data. Inherit from this to create custom data for async physics tick. When no data is available (say due to massive latency or packet loss) we fall back on the default constructed data. This means you should set the default values to something equivalent to no input (for example bPlayerWantsToJump should probably default to false)

code: class UAsyncPhysicsData : public [UObject](API\Runtime\CoreUObject\UObject\UObject)

ReplicationRedundancy

description: Determines how many times we redundantly send data to server. The higher this number the less packet loss, but more bandwidth is used.


description: Override this function to implement custom logic to be executed every physics step. Only executes if the component is registered, and also bAsyncPhysicsTick must be set to true.

code: virtual void AsyncPhysicsTickComponent ( float DeltaTime, float SimTime )


description: Get the async physics data to execute logic off of. This data should not be modified and will NOT make its way back. Should be called from async tick

code: const [UAsyncPhysicsData](API\Runtime\Engine\Physics\UAsyncPhysicsData) * GetDataToConsume() const


description: Get the async physics data to write to. This data will make its way to the async physics tick on client and server. Should not be called from async tick

code: [UAsyncPhysicsData](API\Runtime\Engine\Physics\UAsyncPhysicsData) * GetDataToWrite() const


code: void OnDispatchPhysicsTick ( int32 PhysicsStep, int32 NumSteps, int32 ServerFrame )


code: void ServerRPCBufferInput ( [UAsyncPhysicsData](API\Runtime\Engine\Physics\UAsyncPhysicsData) * AsyncPhysicsData )


description: Sets the data class used. Can only call this once after the component has been created

code: void SetDataClass ( [TSubclassOf](API\Runtime\CoreUObject\Templates\TSubclassOf)< [UAsyncPhysicsData](API\Runtime\Engine\Physics\UAsyncPhysicsData) > InDataClass )


className: UAsyncPhysicsInputComponent

code: class UAsyncPhysicsInputComponent : public [UActorComponent](API\Runtime\Engine\Components\UActorComponent)


description: Add states/inputs history to rewind datas.

code: void AddDatasHistory()


description: Async physics tick component function per frame from the solver.


description: Used to create any physics engine information for this component.

code: virtual void BeginPlay()


description: Register and create the states/inputs history.

code: template<typename PhysicsTraits> void CreateDatasHistory ( [UActorComponent](API\Runtime\Engine\Components\UActorComponent) * HistoryComponent )


description: Correct the player controller Server to local offset based on the received replicated states.

code: void CorrectServerToLocalOffset ( const int32 LocalToServerOffset )


description: Get the datas factory that will be used for net serialization.

code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [Chaos::FBaseRewindHistory](API\Runtime\Chaos\FBaseRewindHistory) > & GetInputsHistory()


description: Function to init the replicated properties.

code: virtual void GetLifetimeReplicatedProps ( [TArray](API\Runtime\Core\Containers\TArray)< [FLifetimeProperty](API\Runtime\CoreUObject\UObject\FLifetimeProperty) > & OutLifeTimeProps ) const


code: [TSharedPtr](API\Runtime\Core\Templates\TSharedPtr)< [Chaos::FBaseRewindHistory](API\Runtime\Chaos\FBaseRewindHistory) > & GetStatesHistory()


description: Get the player controller on which the component is attached.

code: virtual [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * GetPlayerController() const


description: Check if the player controller exists and is local.

code: bool HasLocalController() const


description: Check if the world is on server.

code: bool HasServerWorld() const


description: Register the component into the network manager.

code: virtual void InitializeComponent()


description: Init the network physics component.

code: void InitPhysics()


description: Delegate linked to the physics rewind callback to send record local inputs/states.

code: void OnPostProcessInputsInternal ( const int32 PhysicsStep )


code: void OnPreProcessInputsInternal ( const int32 PhysicsStep )


description: Repnotify for the inputs on the client

code: void OnRep_SetReplicatedInputs()


description: Repnotify for the states on the client

code: void OnRep_SetReplicatedStates()


description: Remove states/inputs history from rewind datas.

code: void RemoveDatasHistory()


description: Send the inputs replicated datas.

code: void SendLocalInputsDatas()


description: Send the states replicated datas.

code: void SendLocalStatesDatas()


description: Server RPC to receive inputs from client.

code: void ServerReceiveInputsDatas ( const [TArray](API\Runtime\Core\Containers\TArray)< uint8 > & ClientInputs )


description: Unregister the component from the network manager.

code: virtual void UninitializeComponent()


description: Update the histories packagemap for serialization.

code: void UpdatePackageMap()


code: UNetworkPhysicsComponent ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: UNetworkPhysicsComponent

description: Network physics component that will be attached to any player controller

code: class UNetworkPhysicsComponent : public [UActorComponent](API\Runtime\Engine\Components\UActorComponent)

FrameCounter

description: Frame counter to compute the local to server offset.

LocalInputs

type: TArray< uint8 >

description: List of inputs that are processed locally.

LocalStates

description: List of states that are processed locally.

ReplicatedInputs

description: Replicated physics inputs

ReplicatedStates

description: Replicated physics states


description: Implement this for deinitialization of instances of the system

code: virtual void Deinitialize()


description: Subsystem Init/Deinit.

code: virtual void Initialize ( [FSubsystemCollectionBase](API\Runtime\Engine\Subsystems\FSubsystemCollectionBase) & Collection )


description: Delegate at world init.

code: void OnWorldPostInit ( [UWorld](API\Runtime\Engine\Engine\UWorld) * World, const [UWorld::InitializationValues](API\Runtime\Engine\Engine\UWorld\InitializationValues) )


description: Register a component to be used by the callback.

code: void RegisterNetworkComponent ( class [UNetworkPhysicsComponent](API\Runtime\Engine\Physics\UNetworkPhysicsComponent) * NetworkComponent )


description: Remove a network component from registered list.

code: void UnregisterNetworkComponent ( class [UNetworkPhysicsComponent](API\Runtime\Engine\Physics\UNetworkPhysicsComponent) * NetworkComponent )


className: UNetworkPhysicsSystem

description: Network physics manager to initialize datas required for rewind/resim

code: class UNetworkPhysicsSystem : public [UWorldSubsystem](API\Runtime\Engine\Subsystems\UWorldSubsystem)


code: [UClusterUnionComponent](API\Runtime\Engine\PhysicsEngine\UClusterUnionComponent) * GetClusterUnionComponent() const


code: AClusterUnionActor ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: AClusterUnionActor

description: A lightweight actor that can be used to own a cluster union component.

code: class AClusterUnionActor : public [AActor](API\Runtime\Engine\GameFramework\AActor)

ClusterUnion

type: TObjectPtr<UCl...

description: The pivot used while building.


description: Returns ConstraintComp subobject

code: [UPhysicsConstraintComponent](API\Runtime\Engine\PhysicsEngine\UPhysicsConstraintComponent) * GetConstraintComp() const


description: Called when the object was loaded from another class via active class redirects.

code: virtual void LoadedFromAnotherClass ( const [FName](API\Runtime\Core\UObject\FName) & OldClassName )


description: Do any object-specific cleanup required immediately after loading an object. This is not called for newly-created objects, and by default will always execute on the game thread.

code: virtual void PostLoad()


code: APhysicsConstraintActor ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: APhysicsConstraintActor

description: The Basic constraint actor class.

code: class APhysicsConstraintActor : public [ARigidBodyBase](API\Runtime\Engine\PhysicsEngine\ARigidBodyBase)


description: Returns ThrusterComponent subobject

code: [UPhysicsThrusterComponent](API\Runtime\Engine\PhysicsEngine\UPhysicsThrusterComponent) * GetThrusterComponent() const


description: Returns ArrowComponent subobject

code: [UArrowComponent](API\Runtime\Engine\Components\UArrowComponent) * GetArrowComponent() const


code: APhysicsThruster ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: APhysicsThruster

description: Attach one of these on an object using physics simulation and it will apply a force down the negative-X direction ie. point X in the direction you want the thrust in.

code: class APhysicsThruster : public [ARigidBodyBase](API\Runtime\Engine\PhysicsEngine\ARigidBodyBase)


description: Called by ApplyDeltaToActor to perform an actor class-specific operation based on widget manipulation. The default implementation is simply to modify the actor's draw scale.

code: virtual void EditorApplyScale ( const FVector & DeltaScale, const FVector * PivotLocation, bool bAltDown, bool bShiftDown, bool bCtrlDown )


description: BEGIN DEPRECATED (use component functions now in level script)

code: virtual void FireImpulse()


description: Returns ForceComponent subobject

code: [URadialForceComponent](API\Runtime\Engine\PhysicsEngine\URadialForceComponent) * GetForceComponent() const


description: Returns SpriteComponent subobject

code: [UBillboardComponent](API\Runtime\Engine\Components\UBillboardComponent) * GetSpriteComponent() const


code: ARadialForceActor ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: ARadialForceActor

code: class ARadialForceActor : public [ARigidBodyBase](API\Runtime\Engine\PhysicsEngine\ARigidBodyBase)


code: ARigidBodyBase ( const [FObjectInitializer](API\Runtime\CoreUObject\UObject\FObjectInitializer) & ObjectInitializer )


className: ARigidBodyBase

description: RigidBodyBase: The base class of all rigid bodies.

code: class ARigidBodyBase : public [AActor](API\Runtime\Engine\GameFramework\AActor)


code: namespace ConstraintUtils { void ConstraintUtils::ConfigureAsBallAndSocket ( [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) & ConstraintInstance, bool bOverwriteLimits ) }


code: namespace ConstraintUtils { void ConstraintUtils::ConfigureAsHinge ( [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) & ConstraintInstance, bool bOverwriteLimits ) }


code: namespace ConstraintUtils { void ConstraintUtils::ConfigureAsPrismatic ( [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) & ConstraintInstance, bool bOverwriteLimits ) }


code: namespace ConstraintUtils { void ConstraintUtils::ConfigureAsSkelJoint ( [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) & ConstraintInstance, bool bOverwriteLimits ) }


code: namespace ConstraintUtils { bool ConstraintUtils::IsBallAndSocket ( const [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) & ConstraintInstance ) }


code: namespace ConstraintUtils { bool ConstraintUtils::IsHinge ( const [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) & ConstraintInstance ) }


code: namespace ConstraintUtils { bool ConstraintUtils::IsPrismatic ( const [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) & ConstraintInstance ) }


code: namespace ConstraintUtils { bool ConstraintUtils::IsSkelJoint ( const [FConstraintInstance](API\Runtime\Engine\PhysicsEngine\FConstraintInstance) & ConstraintInstance ) }


code: namespace EAggCollisionShape { enum Type { Sphere, Box, Sphyl, Convex, TaperedCapsule, LevelSet, SkinnedLevelSet, Unknown, } }


code: namespace EAngularDriveMode { enum Type { SLERP, TwistAndSwing, } }


code: namespace EDOFMode { enum Type { Default, SixDOF, YZPlane, XZPlane, XYPlane, CustomPlane, None, } }


code: namespace ESettingsDOF { enum Type { Full3D, YZPlane, XZPlane, XYPlane, } }


code: namespace ESettingsLockedAxis { enum Type { None, X, Y, Z, Invalid, } }


code: bool IsVelocityDriveEnabled() const


code: bool IsOrientationDriveEnabled() const


description: Add a force to this body

code: void AddForce ( const FVector & Force, bool bAllowSubstepping, bool bAccelChange, const [FAsyncPhysicsTimestamp](API\Runtime\Engine\GameFramework\FAsyncPhysicsTimestamp) TimeStamp, [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * PlayerController )


description: Add a force at a particular position (world space when bIsLocalForce = false, body space otherwise)

code: void AddForceAtPosition ( const FVector & Force, const FVector & Position, bool bAllowSubstepping, bool bIsLocalForce, const [FAsyncPhysicsTimestamp](API\Runtime\Engine\GameFramework\FAsyncPhysicsTimestamp) TimeStamp, [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * PlayerController )


description: Add custom forces and torques on the body. The callback will be called more than once, if substepping enabled, for every substep.

code: void AddCustomPhysics ( FCalculateCustomPhysics & CalculateCustomPhysics )


className: FAngularDriveConstraint

description: Angular Drive

code: struct FAngularDriveConstraint

AngularDriveMode

type: TEnumAsByte< en...

description: Whether motors use SLERP (spherical lerp) or decompose into a Swing motor (cone constraints) and Twist motor (roll constraints).

AngularVelocityTarget

type: FVector

description: Target angular velocity relative to the body reference frame in revolutions per second.

OrientationTarget

type: FRotator

description: Target orientation relative to the the body reference frame.

SlerpDrive

type: FConstraintDriv...

description: Controls the SLERP (spherical lerp) drive between current orientation/velocity and target orientation/velocity.

SwingDrive

description: Controls the cone constraint drive between current orientation/velocity and target orientation/velocity.

TwistDrive

description: Controls the twist (roll) constraint drive between current orientation/velocity and target orientation/velocity.


description: Add a rotational impulse to this body

code: void AddAngularImpulseInRadians ( const FVector & Impulse, bool bVelChange, const [FAsyncPhysicsTimestamp](API\Runtime\Engine\GameFramework\FAsyncPhysicsTimestamp) TimeStamp, [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * PlayerController )


description: Add an impulse to this body

code: void AddImpulse ( const FVector & Impulse, bool bVelChange, const [FAsyncPhysicsTimestamp](API\Runtime\Engine\GameFramework\FAsyncPhysicsTimestamp) TimeStamp, [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * PlayerController )


description: Add a force to this bodyinstance, originating from the supplied world-space location.

code: void AddRadialForceToBody ( const FVector & Origin, float Radius, float Strength, uint8 Falloff, bool bAccelChange, bool bAllowSubstepping )


description: Add an impulse to this bodyinstance, radiating out from the specified position.

code: void AddRadialImpulseToBody ( const FVector & Origin, float Radius, float Strength, uint8 Falloff, bool bVelChange )


description: Add a torque to this body

code: void AddTorqueInRadians ( const FVector & Torque, bool bAllowSubstepping, bool bAccelChange, const [FAsyncPhysicsTimestamp](API\Runtime\Engine\GameFramework\FAsyncPhysicsTimestamp) TimeStamp, [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * PlayerController )


description: Add an impulse to this body and a particular world position

code: void AddImpulseAtPosition ( const FVector & Impulse, const FVector & Position, const [FAsyncPhysicsTimestamp](API\Runtime\Engine\GameFramework\FAsyncPhysicsTimestamp) TimeStamp, [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * PlayerController )


description: Add a velocity change impulse to this body and a particular world position

code: void AddVelocityChangeImpulseAtLocation ( const FVector & Impulse, const FVector & Position, const [FAsyncPhysicsTimestamp](API\Runtime\Engine\GameFramework\FAsyncPhysicsTimestamp) TimeStamp, [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * PlayerController )


description: Applies a deferred collision profile


description: Apply async physics command onto the body instance

code: void ApplyAsyncPhysicsCommand ( [FAsyncPhysicsTimestamp](API\Runtime\Engine\GameFramework\FAsyncPhysicsTimestamp) TimeStamp, const bool bIsInternal, [APlayerController](API\Runtime\Engine\GameFramework\APlayerController) * PlayerController, const [TFunction](API\Runtime\Core\GenericPlatform\TFunction)< void()> & Command )


description: Note: This function is not thread safe. Make sure you obtain the appropriate physics scene lock before calling it

code: void ApplyMaterialToInstanceShapes_AssumesLocked ( [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * SimplePhysMat, [TArray](API\Runtime\Core\Containers\TArray)< [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * > & ComplexPhysMats, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [FPhysicalMaterialMaskParams](API\Runtime\Engine\Physics\FPhysicalMaterialMaskParams) > & ComplexPhysMatMasks )


description: Apply a material directly to the passed in shape. Note this function is very advanced and requires knowledge of shape sharing as well as threading. Note: assumes the appropriate locks have been obtained

code: static void ApplyMaterialToShape_AssumesLocked ( const FPhysicsShapeHandle & InShape, [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * SimplePhysMat, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * > & ComplexPhysMats, const [TArrayView](API\Runtime\Core\Containers\TArrayView)< [FPhysicalMaterialMaskParams](API\Runtime\Engine\Physics\FPhysicalMaterialMaskParams) > * ComplexPhysMatMasks )


description: Finds all children that are technically welded to us (for example kinematics are welded but not as far as physx is concerned) and apply the actual physics engine weld on them

code: void ApplyWeldOnChildren()


description: Build the flags to control which types of collision (sim and query) shapes owned by this BodyInstance should have.

code: static void BuildBodyCollisionFlags ( [FBodyCollisionFlags](API\Runtime\PhysicsCore\FBodyCollisionFlags) & OutFlags, [ECollisionEnabled::Type](API\Runtime\Engine\Engine\ECollisionEnabled__Type) UseCollisionEnabled, bool bUseComplexAsSimple )


description: Build the sim and query filter data (for simple and complex shapes) based on the settings of this BodyInstance (and its associated BodySetup)

code: void BuildBodyFilterData ( [FBodyCollisionFilterData](API\Runtime\PhysicsCore\FBodyCollisionFilterData) & OutFilterData, const int32 ShapeIndex ) const


description: Clear accumulated forces on this body

code: void ClearForces ( bool bAllowSubstepping )


description: Clear accumulated torques on this body

code: void ClearTorques ( bool bAllowSubstepping )


description: Utility for copying properties from one BodyInstance to another.

code: void CopyBodyInstancePropertiesFrom ( const [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * FromInst )


description: Utility for copying only the runtime instanced properties from one BodyInstance to another.

code: void CopyRuntimeBodyInstancePropertiesFrom ( const [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * FromInst )


code: void ClearExternalCollisionProfile()


description: Return true if it uses Collision Profile System. False otherwise

code: bool DoesUseCollisionProfile() const


description: Draws the center of mass as a wire star

code: void DrawCOMPosition ( class [FPrimitiveDrawInterface](API\Runtime\Engine\FPrimitiveDrawInterface) * PDI, float COMRenderSize, const [FColor](API\Runtime\Core\Math\FColor) & COMRenderColor )


description: Executes the OnCalculateCustomProjection delegate if bound.

code: void ExecuteOnCalculateCustomProjection ( FTransform & WorldTM ) const


description: UObjectnotification by OwningComponent

code: void FixupData ( class [UObject](API\Runtime\CoreUObject\UObject\UObject) * Loader )


code: FWeldInfo &40; FBodyInstance &42; InChildBI, const FTransform & InRelativeTM &41;


className: FWeldInfo

code: struct FWeldInfo

ChildBI

type: FBodyInstance&...

RelativeTM

type: FTransform


code: const FPhysicsActorHandle & GetActorReferenceWithWelding() const


description: Utility to get all the shapes from aFBodyInstanceNOTE: This function is not thread safe. You must hold the physics scene lock while calling it and reading/writing from the shapes

code: int32 GetAllShapes_AssumesLocked ( [TArray](API\Runtime\Core\Containers\TArray)< FPhysicsShapeHandle > & OutShapes ) const


description: Return bounds of physics representation

code: FBox GetBodyBounds() const


description: Get the name for this body, for use in debugging


description: Return the body's inertia tensor. This is returned in local mass space

code: FVector GetBodyInertiaTensor() const


description: Returns memory used by resources allocated for this body instance ( ex. physics resources )

code: void GetBodyInstanceResourceSizeEx ( [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & CumulativeResourceSize ) const


description: Returns the body's mass

code: float GetBodyMass() const


code: [UBodySetup](API\Runtime\Engine\PhysicsEngine\UBodySetup) * GetBodySetup() const


description: Get the current type of collision enabled

code: [ECollisionEnabled::Type](API\Runtime\Engine\Engine\ECollisionEnabled__Type) GetCollisionEnabled ( bool bCheckOwner ) const


description: Returns the collision profile name that will be used.


code: const [FCollisionResponse](API\Runtime\Engine\PhysicsEngine\FCollisionResponse) & GetCollisionResponse() const


description: Get the complex PhysicalMaterials array for this body

code: [TArray](API\Runtime\Core\Containers\TArray)< [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * > GetComplexPhysicalMaterials() const


description: Get the complex PhysicalMaterials and PhysicalMaterialMasks array for this body

code: [TArray](API\Runtime\Core\Containers\TArray)< [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * > GetComplexPhysicalMaterials ( [TArray](API\Runtime\Core\Containers\TArray)< [FPhysicalMaterialMaskParams](API\Runtime\Engine\Physics\FPhysicalMaterialMaskParams) > & OutPhysMaterialMasks ) const


description: Get the complex PhysicalMaterials for this body

code: void GetComplexPhysicalMaterials ( [TArray](API\Runtime\Core\Containers\TArray)< [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * > & OutPhysMaterials ) const


description: Get the complex PhysicalMaterials and PhysicalMaterialMasks for this body

code: void GetComplexPhysicalMaterials ( [TArray](API\Runtime\Core\Containers\TArray)< [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * > & OutPhysMaterials, [TArray](API\Runtime\Core\Containers\TArray)< [FPhysicalMaterialMaskParams](API\Runtime\Engine\Physics\FPhysicalMaterialMaskParams) > & OutPhysMaterialMasks ) const


description: Find the correct PhysicalMaterial and PhysicalMaterialMasks for complex geometry on a given body and owner. This is really for internal use during serialization

code: static void GetComplexPhysicalMaterials ( const [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * BodyInstance, [TWeakObjectPtr](API\Runtime\Core\UObject\TWeakObjectPtr)< [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) > Owner, [TArray](API\Runtime\Core\Containers\TArray)< [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * > & OutPhysMaterials, [TArray](API\Runtime\Core\Containers\TArray)< [FPhysicalMaterialMaskParams](API\Runtime\Engine\Physics\FPhysicalMaterialMaskParams) > * OutPhysMaterialMasks )


description: Returns the center of mass of this body (in world space)

code: FVector GetCOMPosition() const


code: const [TMap](API\Runtime\Core\Containers\TMap)< FPhysicsShapeHandle, [FWeldInfo](API\Runtime\Engine\PhysicsEngine\FBodyInstance\FWeldInfo) > * GetCurrentWeldInfo() const


description: Get the square of the distance to the body surface if available It is only valid if BodyShape is convex If point is inside or shape is not convex, it will return 0.f

code: float GetDistanceToBody ( const FVector & Point, FVector & OutPointOnBody ) const


description: [Physx Only]

code: FVector GetLockedAxis() const


description: Return the ignore mask filter.

code: FMaskFilter GetMaskFilter() const


description: Returns the mass override. See MassInKgOverride for documentation

code: float GetMassOverride() const


description: Returns the mass coordinate system to local space transform (position is local center of mass, rotation should be identity)

code: FTransform GetMassSpaceLocal() const


description: Get the maximum angular velocity of this body


description: Returns the mass coordinate system to world space transform (position is world center of mass, rotation is world inertia orientation)


description: Returns the original owning body instance. This is needed for welding

code: const [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * GetOriginalBodyInstance ( const FPhysicsShapeHandle & InShape ) const


description: Get the movement channel of this body

code: ECollisionChannel GetObjectType() const


code: const FPhysicsActorHandle & GetPhysicsActorHandle() const


description: Gets bOverrideWalkableSlopeOnInstance


description: Get the EPhysicsReplicationMode from the owning actor. It's recommended to get the parameter directly from the Actor if possible.


description: Get the scene that owns this body.

code: FPhysScene * GetPhysicsScene()


description: Get the scene that owns this body.

code: const FPhysScene * GetPhysicsScene() const


description: Get the collision response of this body to a particular channel

code: ECollisionResponse GetResponseToChannel ( ECollisionChannel Channel ) const


description: Returns the relative transform between root body and welded instance owned by the shape.

code: const FTransform & GetRelativeBodyTransform ( const FPhysicsShapeHandle & InShape ) const


description: Get Collision ResponseToChannels container for this component

code: const [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & GetResponseToChannels() const


code: bool GetRigidBodyState ( [FRigidBodyState](API\Runtime\Engine\Engine\FRigidBodyState) & OutState )


description: Get the current type of collision enabled for a particular shape

code: [ECollisionEnabled::Type](API\Runtime\Engine\Engine\ECollisionEnabled__Type) GetShapeCollisionEnabled ( const int32 ShapeIndex ) const


description: Get Collision ResponseToChannels container for a specific shape in this component

code: const [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & GetShapeResponseToChannels ( const int32 ShapeIndex ) const


code: const [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & GetShapeResponseToChannels ( const int32 ShapeIndex, const [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & DefaultResponseContainer ) const


description: Find the correct PhysicalMaterial for simple geometry on this body

code: [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * GetSimplePhysicalMaterial() const


description: Find the correct PhysicalMaterial for simple geometry on a given body and owner. This is really for internal use during serialization

code: static [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * GetSimplePhysicalMaterial ( const [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * BodyInstance, [TWeakObjectPtr](API\Runtime\Core\UObject\TWeakObjectPtr)< [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) > Owner, [TWeakObjectPtr](API\Runtime\Core\UObject\TWeakObjectPtr)< [UBodySetup](API\Runtime\Engine\PhysicsEngine\UBodySetup) > BodySetupPtr )


description: Gets the multiplier to the threshold where the body will go to sleep automatically.


description:
Get distance to the body surface if available It is only valid if BodyShape is convex If point is inside distance it will be 0 Returns false if geometry is not supported
true if a distance to the body was found and OutDistanceSquared has been populated

code: bool GetSquaredDistanceToBody ( const FVector & Point, float & OutDistanceSquared, FVector & OutPointOnBody ) const


description: Note: returns angular velocity in radians per second.


description: Get current transform in world space from physics body.

code: FTransform GetUnrealWorldTransform_AssumesLocked ( bool bWithProjection, bool bForceGlobalPose ) const


code: FTransform GetUnrealWorldTransform ( bool bWithProjection, bool bForceGlobalPose ) const


description: Get current velocity in world space from physics body.


description: Get current velocity of a point on this physics body, in world space. Point is specified in world space.

code: FVector GetUnrealWorldVelocityAtPoint_AssumesLocked ( const FVector & Point ) const


code: FVector GetUnrealWorldVelocity() const


code: FVector GetUnrealWorldVelocityAtPoint ( const FVector & Point ) const


code: void InitBody ( [UBodySetup](API\Runtime\Engine\PhysicsEngine\UBodySetup) * Setup, const FTransform & Transform, [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) * PrimComp, FPhysScene * InRBScene )


description: Returns the slope override struct for this instance. If we don't have our own custom setting, it will return the setting from the body setup.

code: const [FWalkableSlopeOverride](API\Runtime\Engine\Engine\FWalkableSlopeOverride) & GetWalkableSlopeOverride() const


description: Initialise a single rigid body (thisFBodyInstance) for the given body setup

code: void InitBody ( [UBodySetup](API\Runtime\Engine\PhysicsEngine\UBodySetup) * Setup, const FTransform & Transform, [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) * PrimComp, FPhysScene * InRBScene, const [FInitBodySpawnParams](API\Runtime\Engine\PhysicsEngine\FInitBodySpawnParams) & SpawnParams )


description: Initialise dynamic properties for this instance when using physics - this must be done after scene addition. Note: This function is not thread safe. Make sure to obtain the appropriate physics scene locks before calling this function


description: Standalone path to batch initialize large amounts of static bodies, which will be deferred till the next scene update for fast scene addition.

code: static void InitStaticBodies ( const [TArray](API\Runtime\Core\Containers\TArray)< [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * > & Bodies, const [TArray](API\Runtime\Core\Containers\TArray)< FTransform > & Transforms, [UBodySetup](API\Runtime\Engine\PhysicsEngine\UBodySetup) * BodySetup, class [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) * PrimitiveComp, FPhysScene * InRBScene )


description: Returns true if the body is not static

code: bool IsDynamic() const


description: Returns whether this body is awake

code: bool IsInstanceAwake() const


description: Returns true if this body is simulating, false if it is fixed (kinematic)


description: bInertiaConditioning

code: bool IsInertiaConditioningEnabled()


description: Returns true if the body is non kinematic

code: bool IsNonKinematic() const


description: Check if the shape is owned by this body instance

code: bool IsShapeBoundToBody ( const FPhysicsShapeHandle & Shape ) const


description: See if this body is valid.

code: bool IsValidBodyInstance() const


description:
Trace a ray against just this bodyinstance
true if a hit is found

code: bool LineTrace ( struct [FHitResult](API\Runtime\Engine\Engine\FHitResult) & OutHit, const FVector & Start, const FVector & End, bool bTraceComplex, bool bReturnPhysicalMaterial ) const


description: Returns reference to the OnCalculateCustomProjection delegate. Will allocate delegate struct if not already created.


description: Returns reference to the OnRecalculatedMassProperties delegate. Will allocate delegate struct if not already created.


description:
The overload taking rotation as an FQuat is slightly faster than the version using FRotator (which will be converted to an FQuat)..
TRUE if OutOverlaps contains any blocking results

code: bool OverlapMulti ( [TArray](API\Runtime\Core\Containers\TArray)< struct [FOverlapResult](API\Runtime\Engine\Engine\FOverlapResult) > & InOutOverlaps, const class [UWorld](API\Runtime\Engine\Engine\UWorld) * World, const FTransform * pWorldToComponent, const FVector & Pos, const FQuat & Rot, ECollisionChannel TestChannel, const struct [FComponentQueryParams](API\Runtime\Engine\FComponentQueryParams) & Params, const struct [FCollisionResponseParams](API\Runtime\Engine\FCollisionResponseParams) & ResponseParams, const [FCollisionObjectQueryParams](API\Runtime\Engine\FCollisionObjectQueryParams) & ObjectQueryParams ) const


code: bool OverlapMulti ( [TArray](API\Runtime\Core\Containers\TArray)< struct [FOverlapResult](API\Runtime\Engine\Engine\FOverlapResult) > & InOutOverlaps, const class [UWorld](API\Runtime\Engine\Engine\UWorld) * World, const FTransform * pWorldToComponent, const FVector & Pos, const FRotator & Rot, ECollisionChannel TestChannel, const struct [FComponentQueryParams](API\Runtime\Engine\FComponentQueryParams) & Params, const struct [FCollisionResponseParams](API\Runtime\Engine\FCollisionResponseParams) & ResponseParams, const [FCollisionObjectQueryParams](API\Runtime\Engine\FCollisionObjectQueryParams) & ObjectQueryParams ) const


description:
Test if the bodyinstance overlaps with the specified shape at the specified position/rotation
true if the geometry associated with this body instance overlaps the query shape at the specified location/rotation

code: bool OverlapTest ( const FVector & Position, const FQuat & Rotation, const struct [FCollisionShape](API\Runtime\PhysicsCore\FCollisionShape) & CollisionShape, [FMTDResult](API\Runtime\Engine\Engine\FMTDResult) * OutMTD, bool bTraceComplex ) const


description:
Test if the bodyinstance overlaps with the specified body instances
true if any of the bodies passed in overlap with this

code: bool OverlapTestForBodies ( const FVector & Position, const FQuat & Rotation, const [TArray](API\Runtime\Core\Containers\TArray)< [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * > & Bodies, bool bTraceComplex ) const


code: bool OverlapTestForBody ( const FVector & Position, const FQuat & Rotation, [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * Body, bool bTraceComplex ) const


description:
Test if the bodyinstance overlaps with the specified shape at the specified position/rotation Note: This function is not thread safe. Make sure you obtain the physics scene read lock before calling it
true if the geometry associated with this body instance overlaps the query shape at the specified location/rotation

code: bool OverlapTest_AssumesLocked ( const FVector & Position, const FQuat & Rotation, const struct [FCollisionShape](API\Runtime\PhysicsCore\FCollisionShape) & CollisionShape, [FMTDResult](API\Runtime\Engine\Engine\FMTDResult) * OutMTD, bool bTraceComplex ) const


description: Force this body to sleep

code: void PutInstanceToSleep()


description: After adding/removing shapes call this function to update mass distribution etc...

code: void PostShapeChange()


code: static [EDOFMode::Type](API\Runtime\Engine\PhysicsEngine\EDOFMode__Type) ResolveDOFMode ( [EDOFMode::Type](API\Runtime\Engine\PhysicsEngine\EDOFMode__Type) DOFMode )


description: Update profile data if required

code: void LoadProfileData ( bool bVerifyProfile )


description: Replace the channels on this body matching the old response with the new response

code: bool ReplaceResponseToChannels ( ECollisionResponse OldResponse, ECollisionResponse NewResponse )


description: Set the angular velocity of this body

code: void SetAngularVelocityInRadians ( const FVector & NewAngVel, bool bAddToCurrent, bool bAutoWake )


description: Move the physics body to a new pose.

code: void SetBodyTransform ( const FTransform & NewTransform, ETeleportType Teleport, bool bAutoWake )


description: Controls what kind of collision is enabled for this body and allows optional disable physics rebuild

code: void SetCollisionEnabled ( [ECollisionEnabled::Type](API\Runtime\Engine\Engine\ECollisionEnabled__Type) NewType, bool bUpdatePhysicsFilterData )


description: Set Collision Profile Name This function should be called outside of constructors to set profile name. This will change current CollisionProfileName to be this, and overwrite Collision Setting

code: void SetCollisionProfileName ( [FName](API\Runtime\Core\UObject\FName) InCollisionProfileName )


description: Enables/disables contact modification

code: void SetContactModification ( bool bNewContactModification )


description: Set Collision Profile Name (deferred) This function is called by constructors when they set ProfileName This will change current CollisionProfileName, but collision data will not be set up until the physics state is created or the collision profile is accessed.

code: void SetCollisionProfileNameDeferred ( [FName](API\Runtime\Core\UObject\FName) InCollisionProfileName )


description: Set a new contact report force threhold. Threshold < 0 disables this feature.

code: void SetContactReportForceThreshold ( float Threshold )


description: [Physx Only] Locks physical movement along axis.

code: void SetDOFLock ( [EDOFMode::Type](API\Runtime\Engine\PhysicsEngine\EDOFMode__Type) NewDOFMode )


description: Enables/disables whether this body is affected by gravity.

code: void SetEnableGravity ( bool bGravityEnabled )


description: bInertiaConditioning

code: void SetInertiaConditioningEnabled ( bool bEnabled )


description: Set this body to either simulate or to be fixed/kinematic.

code: void SetInstanceSimulatePhysics ( bool bSimulate, bool bMaintainPhysicsBlending, bool bPreserveExistingAttachment )


description: Set whether we should get a notification about physics collisions

code: void SetInstanceNotifyRBCollision ( bool bNewNotifyCollision )


description: Updates the mask filter.

code: void SetMaskFilter ( FMaskFilter InMaskFilter )


description: Set the linear velocity of this body

code: void SetLinearVelocity ( const FVector & NewVel, bool bAddToCurrent, bool bAutoWake )


description: Sets the mass override

code: void SetMassOverride ( float MassInKG, bool bNewOverrideMass )


description: Modify the mass scale of this body

code: void SetMassScale ( float InMassScale )


description: TODO: this only works at runtime when the physics state has been created. Any changes that result in recomputing mass properties will not properly remember this

code: void SetMassSpaceLocal ( const FTransform & NewMassSpaceLocalTM )


description: Set the maximum angular velocity of this body

code: void SetMaxAngularVelocityInRadians ( float NewMaxAngVel, bool bAddToCurrent, bool bUpdateOverrideMaxAngularVelocity )


description: Set the maximum depenetration velocity the physics simulation will introduce

code: void SetMaxDepenetrationVelocity ( float MaxVelocity )


description: Set the movement channel of this body to the one supplied

code: void SetObjectType ( ECollisionChannel Channel )


description: If set to true, this body will treat bodies that do not have the flag set as having infinite mass

code: void SetOneWayInteraction ( bool InOneWayInteraction )


description: Disable/Re-Enable this body in the solver, when disable, the body won't be part of the simulation ( regardless if it's dynamic or kinematic ) and no collision will occur this can be used for performance control situation for example

code: void SetPhysicsDisabled ( bool bSetDisabled )


description: Changes the current PhysMaterialOverride for this body. Note that if physics is already running on this component, this willnotalter its mass/inertia etc, it will only change its surface properties like friction and the damping.

code: void SetPhysMaterialOverride ( class [UPhysicalMaterial](API\Runtime\PhysicsCore\PhysicalMaterials\UPhysicalMaterial) * NewPhysMaterial )


description: Set the response of this body to all channels

code: bool SetResponseToAllChannels ( ECollisionResponse NewResponse )


description: Set the collision response of this body to a particular channel

code: bool SetResponseToChannel ( ECollisionChannel Channel, ECollisionResponse NewResponse )


description: Set the response of this body to the supplied settings

code: bool SetResponseToChannels ( const [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & NewResponses )


description: Set the response of a specific shape on this body to the supplied settings

code: bool SetShapeResponseToChannels ( const int32 ShapeIndex, const [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & NewResponses )


description: Controls what kind of collision is enabled for a particular shape

code: void SetShapeCollisionEnabled ( const int32 ShapeIndex, [ECollisionEnabled::Type](API\Runtime\Engine\Engine\ECollisionEnabled__Type) NewType, bool bUpdatePhysicsFilterData )


description: Enables/disabled smoothed edge collisions

code: void SetSmoothEdgeCollisionsEnabled ( bool bNewSmoothEdgeCollisions )


description: Enables/disables whether this body, when kinematic, is updated from the simulation rather than when setting the kinematic target.

code: void SetUpdateKinematicFromSimulation ( bool bUpdateKinematicFromSimulation )


description: Enable/disable Continuous Collidion Detection feature

code: void SetUseCCD ( bool bInUseCCD )


description: Sets a custom slope override struct for this instance. Implicitly sets bOverrideWalkableSlopeOnInstance to true.

code: void SetWalkableSlopeOverride ( const [FWalkableSlopeOverride](API\Runtime\Engine\Engine\FWalkableSlopeOverride) & NewOverride, bool bNewOverideSetting )


description: bInterpolateWhenSubStepping


description:
Trace a shape against just this bodyinstance
true if a hit is found

code: bool Sweep ( struct [FHitResult](API\Runtime\Engine\Engine\FHitResult) & OutHit, const FVector & Start, const FVector & End, const FQuat & ShapeWorldRotation, const [FCollisionShape](API\Runtime\PhysicsCore\FCollisionShape) & Shape, bool bTraceComplex ) const


description: Takes a welded body and unwelds it. This function does not create the new body, it only removes the old one

code: void UnWeld ( [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * Body )


description:
Update Body Scale
true if succeed

code: bool UpdateBodyScale ( const FVector & InScale3D, bool bForceUpdate )


description:
Terminates the body, releasing resources
Clean up the physics engine info for this instance.

code: void TermBody ( bool bNeverDeferRelease )


description: Update instance's linear and angular damping

code: void UpdateDampingProperties()


description: Makes sure the current kinematic state matches the simulate flag

code: void UpdateInstanceSimulatePhysics()


description: Update the substepping interpolation flag

code: void UpdateInterpolateWhenSubStepping()


description: Update the instance's material properties (friction, restitution)

code: void UpdatePhysicalMaterials()


description: Update instance's mass properties (mass, inertia and center-of-mass offset) based on MassScale, InstanceMassScale and COMNudge.

code: void UpdateMassProperties()


description: Validate a body transform, outputting debug info

code: static bool ValidateTransform ( const FTransform & Transform, const [FString](API\Runtime\Core\Containers\FString) & DebugName, const [UBodySetup](API\Runtime\Engine\PhysicsEngine\UBodySetup) * Setup )


description: Update the filter data on the physics shapes, based on the owning component flags.

code: void UpdatePhysicsFilterData()


description: Dynamically update the vertices of per-poly collision for this body.

code: void UpdateTriMeshVertices ( const [TArray](API\Runtime\Core\Containers\TArray)< FVector > & NewPositions )


description: Use the collision profile found in the given BodySetup's default BodyInstance

code: void UseExternalCollisionProfile ( [UBodySetup](API\Runtime\Engine\PhysicsEngine\UBodySetup) * InExternalCollisionProfileBodySetup )


description: Takes two body instances and welds them together to create a single simulated rigid body. Returns true if success.

code: bool Weld ( [FBodyInstance](API\Runtime\Engine\PhysicsEngine\FBodyInstance) * Body, const FTransform & RelativeTM )


description: Wake this body

code: void WakeInstance()


description: Constructor

code: FBodyInstance()


className: FBodyInstance

description: Container for a physics representation of an object

code: struct FBodyInstance : public [FBodyInstanceCore](API\Runtime\PhysicsCore\FBodyInstanceCore)

ActorHandle

type: FPhysicsActorHa...

description: Internal physics representation of our body instance.

AngularDamping

type: float

description: 'Drag' force added to reduce angular movement

bContactModification

type: uint8:  1

description: Enable contact modification.

description: : These are ONLY used when the 'p.EnableDynamicPerBodyFilterHacks' CVar is set (disabled by default).

description: Bydefault, an owning skel mesh component will override the body's collision filter.

bIgnoreAnalyticCollisions

description: If true ignore analytic collisions and treat objects as a general implicit surface

bInertiaConditioning

description: Enable automatic inertia conditioning to stabilize constraints.

bInterpolateWhenSubStepping

description: Internal flag to allow us to quickly check whether we should interpolate when substepping e.g. kinematic bodies that are QueryOnly do not need to interpolate as we will not be querying them at a sub-position.

bLockRotation

description: [Physx Only] When a Locked Axis Mode is selected, will lock rotation to the specified axis

bLockTranslation

description: [Physx Only] When a Locked Axis Mode is selected, will lock translation on the specified axis

bLockXRotation

description: [Physx Only] Lock rotation about the X-axis

bLockXTranslation

description: [Physx Only] Lock translation along the X-axis

bLockYRotation

description: [Physx Only] Lock rotation about the Y-axis

bLockYTranslation

description: [Physx Only] Lock translation along the Y-axis

bLockZRotation

description: [Physx Only] Lock rotation about the Z-axis

bLockZTranslation

description: [Physx Only] Lock translation along the Z-axis

bNotifyRigidBodyCollision

description: Should 'Hit' events fire when this object collides during physics simulation.

bOverrideMaxAngularVelocity

description: Override the default max angular velocity

bOverrideMaxDepenetrationVelocity

description: [PhysX Only] Whether this body instance has its own custom MaxDepenetrationVelocity

bOverrideWalkableSlopeOnInstance

description: Whether this instance of the object has its own custom walkable slope override setting.

bPendingCollisionProfileSetup

description: Whether we are pending a collision profile setup

bSmoothEdgeCollisions

description: Remove unnecessary edge collisions to allow smooth sliding over surfaces composed of multiple actors/components.

bUseCCD

description: If true Continuous Collision Detection (CCD) will be used for this component

COMNudge

description: User specified offset for the center of mass of this object, from the calculated location

CurrentSceneState

type: BodyInstanceSce...

description: Current state of the physics body for tracking deferred addition and removal.

CustomDOFPlaneNormal

description: Locks physical movement along a custom plane for a given normal.

CustomSleepThresholdMultiplier

description: If the SleepFamily is set to custom, multiply the natural sleep threshold by this amount.

DOFConstraint

type: FConstraintInst...

description: [Physx Only] Constraint used to allow for easy DOF setup per bodyinstance

DOFMode

type: TEnumAsByte<ED...

description: [Physx Only] Locks physical movement along specified axis.

ExternalCollisionProfileBodySetup

type: TWeakObjectPtr<...

description: The body setup holding the default body instance and its collision profile.

InertiaTensorScale

description: Per-instance scaling of inertia (bigger number means it'll be harder to rotate)

InstanceBodyIndex

description: Indexof this BodyInstance within the SkeletalMeshComponent/PhysicsAsset.

InstanceBoneIndex

description: When we are a body within a SkeletalMeshComponent, we cache the index of the bone we represent, to speed up sync'ing physics to anim.

LinearDamping

description: 'Drag' force added to reduce linear movement

MassInKgOverride

description: Mass of the body in KG.

MassScale

description: Per-instance scaling of mass

MaxAngularVelocity

description: The maximum angular velocity for this instance [degrees/s]

MaxDepenetrationVelocity

description: [PhysX Only] The maximum velocity used to depenetrate this object

OwnerComponent

description: PrimitiveComponent containing this body.

PhysicsBlendWeight

description: Influence of rigid body physics (blending) on the mesh's pose (0.0 == use only animation, 1.0 == use only physics) Provide appropriate interface for doing this instead of allowing BlueprintReadWrite

PhysicsUserData

type: FPhysicsUserDat...

description: #PHYS2 Rename, not just for physx now.

PhysMaterialOverride

type: TObjectPtr< cla...

description: Allows you to override the PhysicalMaterial to use for simple collision on this body.

PositionSolverIterationCount

description: [PhysX Only] This physics body's solver iteration count for position.

description: Current scale of physics - used to know when and how physics must be rescaled to match current transform of OwnerComponent.

SleepFamily

type: ESleepFamily

description: The set of values used in considering when put this body to sleep.

StabilizationThresholdMultiplier

description: Stabilization factor for this body if Physics stabilization is enabled.

VelocitySolverIterationCount

description: [PhysX Only] This physics body's solver iteration count for velocity.

WalkableSlopeOverride

type: FWalkableSlopeO...

description: Custom walkable slope override setting for this instance.

WeldParent

description: The parent body that we are welded to


className: FBodyInstanceAsyncPhysicsTickHandle


code: static void EnsureConsistentMobilitySimulationSettingsOnPostEditChange ( [UPrimitiveComponent](API\Runtime\Engine\Components\UPrimitiveComponent) * Component, [FPropertyChangedEvent](API\Runtime\CoreUObject\UObject\FPropertyChangedEvent) & PropertyChangedEvent )


className: FBodyInstanceEditorHelpers

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

code: struct FBodyInstanceEditorHelpers


description: Return true if the an object of type ObjectClass is allowed to be created; If false is returned, the object and subobjects will be ignored.

code: virtual bool CanCreateClass ( [UClass](API\Runtime\CoreUObject\UObject\UClass) * ObjectClass, bool & bOmitSubObjs ) const


code: void FillFromTriMesh ( const [FTriMeshCollisionData](API\Runtime\PhysicsCore\FTriMeshCollisionData) & TriMeshCollisionData )


description: This is called on each created object after PreEditChange and the property text is imported, but before PostEditChange

code: virtual void ProcessConstructedObject ( [UObject](API\Runtime\CoreUObject\UObject\UObject) * CreatedObject )


className: FBodySetupObjectTextFactory

code: class FBodySetupObjectTextFactory : public [FCustomizableTextObjectFactory](API\Editor\UnrealEd\FCustomizableTextObjectFactory)

NewBodySetups

type: TArray<UBodySe...


className: FBodySetupUVInfo

description: UV information for BodySetup, only created ifUPhysicsSettings::bSupportUVFromHitResults

code: struct FBodySetupUVInfo

IndexBuffer

type: TArray< int32 >

description: Indexbuffer, required to go from face index to UVs

VertPositions

type: TArray< FVector...

description: Vertex positions, used to determine barycentric co-ords

VertUVs

type: TArray<TArray<...

description: UV channels for each vertex


description: Get resource size of UV info

code: void GetResourceSizeEx ( [FResourceSizeEx](API\Runtime\Core\ProfilingDebugging\FResourceSizeEx) & CumulativeResourceSize ) const


description: Only valid use is to explicitly read chaos bulk data.

code: FChaosDerivedDataReader ( [FBulkData](API\Runtime\CoreUObject\Serialization\FBulkData) * InBulkData )


code: FChaosDerivedDataReader &40; const FChaosDerivedDataReader & Other &41;


code: FChaosDerivedDataReader &40; FChaosDerivedDataReader && Other &41;


className: FChaosDerivedDataReader

code: template<typename T, int d> class FChaosDerivedDataReader

ConvexImplicitObjects

type: TArray<TShared...

UVInfo

type: FBodySetupUVInf...


className: FChaosPhysicsSettings

description: Settings container for Chaos physics engine settings, accessed in Chaos through a setting provider interface. See:IChaosSettingsProvider

code: struct FChaosPhysicsSettings

DedicatedThreadBufferMode

type: EChaosBufferMod...

description: The buffering mode to use when running with a dedicated thread

DedicatedThreadTickMode

type: EChaosSolverTic...

description: The framerate/timestep ticking mode when running with a dedicated thread

DefaultThreadingModel

type: EChaosThreading...

description: Default threading model to use on module initialisation.


className: FClusteredActorData

code: struct FClusteredActorData

bWasReplicatingMovement

type: bool

Components

type: TSet<TWeakObje...


className: FClusteredComponentData

code: struct FClusteredComponentData

AllPhysicsObjects

description: Every physics object associated with this particular component.

BoneIds

type: TSet< int32 >

description: Set of bone Ids that we actually added into the cluster union.

CachedAccelerationPayloads

type: TSet<FExternal...

description: Cached acceleration structure handles - needed to properly cleanup the component from the accel structure.

PhysicsObjects

description: Set of physics objects that we actually added into the cluster union.

ReplicatedProxyComponent

description: Using aTWeakObjectPtrhere because theUClusterUnionReplicatedProxyComponentwill have a pointer back and we don't want to get into a situation where a circular reference occurs.


className: FClusterUnionParticleCandidateData

description: For every possible particle that could ever possibly be added into the cluster union, keep track of its component and its bone id.

Component

type: TWeakObjectPtr<...


className: FClusterUnionPendingAddData

code: struct FClusterUnionPendingAddData

AccelerationPayloads

type: TArray<FExtern...


className: FClusterUnionReplicatedData

code: struct FClusterUnionReplicatedData


description: Returns the response set on the specified channel

code: ECollisionResponse GetResponse ( ECollisionChannel Channel ) const


code: const [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & GetResponseContainer() const


code: bool operator== ( const [FCollisionResponse](API\Runtime\Engine\PhysicsEngine\FCollisionResponse) & Other ) const


code: bool operator!= ( const [FCollisionResponse](API\Runtime\Engine\PhysicsEngine\FCollisionResponse) & Other ) const


description: Replace the channels matching the old response with the new response

code: bool ReplaceChannels ( ECollisionResponse OldResponse, ECollisionResponse NewResponse )


description: Set all channels to the specified response

code: bool SetAllChannels ( ECollisionResponse NewResponse )


description: Set the response of a particular channel in the structure.

code: bool SetResponse ( ECollisionChannel Channel, ECollisionResponse NewResponse )


description: Set all channels from ChannelResponse Array

code: bool SetCollisionResponseContainer ( const [FCollisionResponseContainer](API\Runtime\Engine\Engine\FCollisionResponseContainer) & InResponseToChannels )