1. Epic GamesDeveloper
  3. FBodyInstance

FBodyInstance

Container for a physics representation of an object

Unreal Engine C++ API Reference > Runtime > Engine > PhysicsEngine

Inheritance Hierarchy

References

   
Module Engine
Header /Engine/Source/Runtime/Engine/Classes/PhysicsEngine/BodyInstance.h
Include #include "PhysicsEngine/BodyInstance.h"

Syntax

struct FBodyInstance : public FBodyInstanceCore

Remarks

Container for a physics representation of an object

Variables

  Type Name Description
Public variable FPhysicsActorHandle ActorHandle Internal physics representation of our body instance.
Public variable float AngularDamping 'Drag' force added to reduce angular movement
Public variable uint8: 1 bContactModification Enable contact modification.
Public variable uint8: 1 bHACK_DisableCollisionResponse : These are ONLY used when the 'p.EnableDynamicPerBodyFilterHacks' CVar is set (disabled by default).
Public variable uint8: 1 bHACK_DisableSkelComponentFilterOverriding By default, an owning skel mesh component will override the body's collision filter.
Public variable uint8: 1 bIgnoreAnalyticCollisions If true ignore analytic collisions and treat objects as a general implicit surface
Protected variable uint8: 1 bInertiaConditioning Enable automatic inertia conditioning to stabilize constraints.
Protected variable uint8: 1 bInterpolateWhenSubStepping 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.
Public variable uint8: 1 bLockRotation [Physx Only] When a Locked Axis Mode is selected, will lock rotation to the specified axis
Public variable uint8: 1 bLockTranslation [Physx Only] When a Locked Axis Mode is selected, will lock translation on the specified axis
Public variable uint8: 1 bLockXRotation [Physx Only] Lock rotation about the X-axis
Public variable uint8: 1 bLockXTranslation [Physx Only] Lock translation along the X-axis
Public variable uint8: 1 bLockYRotation [Physx Only] Lock rotation about the Y-axis
Public variable uint8: 1 bLockYTranslation [Physx Only] Lock translation along the Y-axis
Public variable uint8: 1 bLockZRotation [Physx Only] Lock rotation about the Z-axis
Public variable uint8: 1 bLockZTranslation [Physx Only] Lock translation along the Z-axis
Public variable uint8: 1 bNotifyRigidBodyCollision Should 'Hit' events fire when this object collides during physics simulation.
Public variable uint8: 1 bOverrideMaxAngularVelocity Override the default max angular velocity
Protected variable uint8: 1 bOverrideMaxDepenetrationVelocity [PhysX Only] Whether this body instance has its own custom MaxDepenetrationVelocity
Protected variable uint8: 1 bOverrideWalkableSlopeOnInstance Whether this instance of the object has its own custom walkable slope override setting.
Protected variable uint8: 1 bPendingCollisionProfileSetup Whether we are pending a collision profile setup
Public variable uint8: 1 bSmoothEdgeCollisions Remove unnecessary edge collisions to allow smooth sliding over surfaces composed of multiple actors/components.
Public variable uint8: 1 bUseCCD If true Continuous Collision Detection (CCD) will be used for this component
Public variable FVector COMNudge User specified offset for the center of mass of this object, from the calculated location
Public variable BodyInstanceSceneState CurrentSceneState Current state of the physics body for tracking deferred addition and removal.
Public variable FVector CustomDOFPlaneNormal Locks physical movement along a custom plane for a given normal.
Public variable float CustomSleepThresholdMultiplier If the SleepFamily is set to custom, multiply the natural sleep threshold by this amount.
Public variable FConstraintInstance * DOFConstraint [Physx Only] Constraint used to allow for easy DOF setup per bodyinstance
Public variable TEnumAsByte< EDOFMode::Type > DOFMode [Physx Only] Locks physical movement along specified axis.
Protected variable TWeakObjectPtr< UBodySetup > ExternalCollisionProfileBodySetup The body setup holding the default body instance and its collision profile.
Public variable FVector InertiaTensorScale Per-instance scaling of inertia (bigger number means it'll be harder to rotate)
Public variable int32 InstanceBodyIndex Index of this BodyInstance within the SkeletalMeshComponent/PhysicsAsset.
Public variable int16 InstanceBoneIndex 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.
Public variable float LinearDamping 'Drag' force added to reduce linear movement
Protected variable float MassInKgOverride Mass of the body in KG.
Public variable float MassScale Per-instance scaling of mass
Public variable float MaxAngularVelocity The maximum angular velocity for this instance [degrees/s]
Protected variable float MaxDepenetrationVelocity [PhysX Only] The maximum velocity used to depenetrate this object
Public variable TWeakObjectPtr< class UPrimitiveComponent > OwnerComponent PrimitiveComponent containing this body.
Public variable float PhysicsBlendWeight 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
Public variable FPhysicsUserData PhysicsUserData #PHYS2 Rename, not just for physx now.
Protected variable TObjectPtr< class UPhysicalMaterial > PhysMaterialOverride Allows you to override the PhysicalMaterial to use for simple collision on this body.
Public variable uint8 PositionSolverIterationCount [PhysX Only] This physics body's solver iteration count for position.
Public variable FVector Scale3D Current scale of physics - used to know when and how physics must be rescaled to match current transform of OwnerComponent.
Public variable ESleepFamily SleepFamily The set of values used in considering when put this body to sleep.
Public variable float StabilizationThresholdMultiplier Stabilization factor for this body if Physics stabilization is enabled.
Public variable uint8 VelocitySolverIterationCount [PhysX Only] This physics body's solver iteration count for velocity.
Protected variable FWalkableSlopeOverride WalkableSlopeOverride Custom walkable slope override setting for this instance.
Public variable FBodyInstance * WeldParent The parent body that we are welded to

Constructors

  Type Name Description
Public function   Constructor

Destructors

  Type Name Description
Public function    

Functions

  Type Name Description
Public function void

AddAngularImpulseInRadians ( const FVector& Impulse,
bool bVelChange,
const FAsyncPhysicsTimestamp TimeStamp,
APlayerController* PlayerController
)

 Add a rotational impulse to this body
Public function void

AddCustomPhysics ( FCalculateCustomPhysics& CalculateCustomPhysics
)

 Add custom forces and torques on the body.
Public function void

AddForce ( const FVector& Force,
bool bAllowSubstepping,
bool bAccelChange,
const FAsyncPhysicsTimestamp TimeStamp,
APlayerController* PlayerController
)

 Add a force to this body
Public function void

AddForceAtPosition ( const FVector& Force,
const FVector& Position,
bool bAllowSubstepping,
bool bIsLocalForce,
const FAsyncPhysicsTimestamp TimeStamp,
APlayerController* PlayerController
)

 Add a force at a particular position (world space when bIsLocalForce = false, body space otherwise)
Public function void

AddImpulse ( const FVector& Impulse,
bool bVelChange,
const FAsyncPhysicsTimestamp TimeStamp,
APlayerController* PlayerController
)

 Add an impulse to this body
Public function void

AddImpulseAtPosition ( const FVector& Impulse,
const FVector& Position,
const FAsyncPhysicsTimestamp TimeStamp,
APlayerController* PlayerController
)

 Add an impulse to this body and a particular world position
Public function void

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

 Add a force to this bodyinstance, originating from the supplied world-space location.
Public function void

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

 Add an impulse to this bodyinstance, radiating out from the specified position.
Public function void

AddTorqueInRadians ( const FVector& Torque,
bool bAllowSubstepping,
bool bAccelChange,
const FAsyncPhysicsTimestamp TimeStamp,
APlayerController* PlayerController
)

 Add a torque to this body
Public function void

AddVelocityChangeImpulseAtLocation ( const FVector& Impulse,
const FVector& Position,
const FAsyncPhysicsTimestamp TimeStamp,
APlayerController* PlayerController
)

 Add a velocity change impulse to this body and a particular world position
Public function void

ApplyAsyncPhysicsCommand ( FAsyncPhysicsTimestamp TimeStamp,
const bool bIsInternal,
APlayerController* PlayerController,
const TFunction< void()>& Command
)

 Apply async physics command onto the body instance
Public function void Applies a deferred collision profile
Public function void Note: This function is not thread safe.
Public function Static void

ApplyMaterialToShape_AssumesLocked ( const FPhysicsShapeHandle& InShape,
UPhysicalMaterial* SimplePhysMat,
const TArrayView< UPhysicalMaterial* >& ComplexPhysMats,
const TArrayView< FPhysicalMaterialMaskParams >* ComplexPhysMatMasks
)

 Apply a material directly to the passed in shape.
Public function void 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
Public function Static void

BuildBodyCollisionFlags ( FBodyCollisionFlags& OutFlags,
ECollisionEnabled::Type UseCollisionEnabled,
bool bUseComplexAsSimple
)

 Build the flags to control which types of collision (sim and query) shapes owned by this BodyInstance should have.
Public function Const void

BuildBodyFilterData ( FBodyCollisionFilterData& OutFilterData,
const int32 ShapeIndex
)

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

ClearForces ( bool bAllowSubstepping
)

 Clear accumulated forces on this body
Public function void

ClearTorques ( bool bAllowSubstepping
)

 Clear accumulated torques on this body
Public function void Utility for copying properties from one BodyInstance to another.
Public function void Utility for copying only the runtime instanced properties from one BodyInstance to another.
Public function void  
Public function Const bool Return true if it uses Collision Profile System. False otherwise
Public function void

DrawCOMPosition ( FPrimitiveDrawInterface* PDI,
float COMRenderSize,
const FColor& COMRenderColor
)

 Draws the center of mass as a wire star
Public function Const void

ExecuteOnCalculateCustomProjection ( FTransform& WorldTM
)

 Executes the OnCalculateCustomProjection delegate if bound.
Public function void

FixupData ( UObject* Loader
)

 UObject notification by OwningComponent
Public function Const const FPhysicsActorHandle &  
Public function Const int32

GetAllShapes_AssumesLocked ( TArray< FPhysicsShapeHandle >& OutShapes
)

 Utility to get all the shapes from a FBodyInstance NOTE: This function is not thread safe.
Public function Const FBox Return bounds of physics representation
Public function Const FString Get the name for this body, for use in debugging
Public function Const FVector Return the body's inertia tensor. This is returned in local mass space
Public function Const FBodyInstanceAsyncPhysicsTickHandle  
Public function Const void

GetBodyInstanceResourceSizeEx ( FResourceSizeEx& CumulativeResourceSize
)

 Returns memory used by resources allocated for this body instance ( ex. physics resources )
Public function Const float Returns the body's mass
Public function Const UBodySetup *  
Public function Const ECollisionEnabled::Type

GetCollisionEnabled ( bool bCheckOwner
)

 Get the current type of collision enabled
Public function Const FName Returns the collision profile name that will be used.
Public function Const const FCollisionResponse &  
Public function Const void Get the complex PhysicalMaterials for this body
Public function Const void

GetComplexPhysicalMaterials ( TArray< UPhysicalMaterial* >& OutPhysMaterials,
TArray< FPhysicalMaterialMaskParams >& OutPhysMaterialMasks
)

 Get the complex PhysicalMaterials and PhysicalMaterialMasks for this body
Public function Static void

GetComplexPhysicalMaterials ( const FBodyInstance* BodyInstance,
TWeakObjectPtr< UPrimitiveComponent > Owner,
TArray< UPhysicalMaterial* >& OutPhysMaterials,
TArray< FPhysicalMaterialMaskParams >* OutPhysMaterialMasks
)

 Find the correct PhysicalMaterial and PhysicalMaterialMasks for complex geometry on a given body and owner.
Public function Const TArray< UPhysicalMaterial * > Get the complex PhysicalMaterials and PhysicalMaterialMasks array for this body
Public function Const TArray< UPhysicalMaterial * > Get the complex PhysicalMaterials array for this body
Public function Const FVector Returns the center of mass of this body (in world space)
Public function Const const TMap< FPhysicsShapeHandle, FWeldInfo > *  
Public function Const float

GetDistanceToBody ( const FVector& Point,
FVector& OutPointOnBody
)

 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
Public function Const FVector [Physx Only]
Public function Const FMaskFilter Return the ignore mask filter.
Public function Const float Returns the mass override. See MassInKgOverride for documentation
Public function Const FTransform Returns the mass coordinate system to local space transform (position is local center of mass, rotation should be identity)
Public function Const FTransform Returns the mass coordinate system to world space transform (position is world center of mass, rotation is world inertia orientation)
Public function Const float Get the maximum angular velocity of this body
Public function Const ECollisionChannel Get the movement channel of this body
Public function Const const FBodyInstance *

GetOriginalBodyInstance ( const FPhysicsShapeHandle& InShape
)

 Returns the original owning body instance. This is needed for welding
Public function Const bool Gets bOverrideWalkableSlopeOnInstance
Public function Const const FPhysicsActorHandle &  
Public function FPhysicsActorHandle &  
Public function Const EPhysicsReplicationMode Get the EPhysicsReplicationMode from the owning actor.
Public function Const const FPhysScene * Get the scene that owns this body.
Public function FPhysScene * Get the scene that owns this body.
Public function Const const FTransform &

GetRelativeBodyTransform ( const FPhysicsShapeHandle& InShape
)

 Returns the relative transform between root body and welded instance owned by the shape.
Public function Const ECollisionResponse

GetResponseToChannel ( ECollisionChannel Channel
)

 Get the collision response of this body to a particular channel
Public function Const const FCollisionResponseContainer & Get Collision ResponseToChannels container for this component
Public function bool  
Public function Const ECollisionEnabled::Type

GetShapeCollisionEnabled ( const int32 ShapeIndex
)

 Get the current type of collision enabled for a particular shape
Public function Const const FCollisionResponseContainer &

GetShapeResponseToChannels ( const int32 ShapeIndex,
const FCollisionResponseContainer& DefaultResponseContainer
)

 Get Collision ResponseToChannels container for a specific shape in this component
Public function Const const FCollisionResponseContainer &

GetShapeResponseToChannels ( const int32 ShapeIndex
)

 Get Collision ResponseToChannels container for a specific shape in this component
Public function Const UPhysicalMaterial * Find the correct PhysicalMaterial for simple geometry on this body
Public function Static UPhysicalMaterial * Find the correct PhysicalMaterial for simple geometry on a given body and owner.
Public function Const float Gets the multiplier to the threshold where the body will go to sleep automatically.
Public function Const bool

GetSquaredDistanceToBody ( const FVector& Point,
float& OutDistanceSquared,
FVector& OutPointOnBody
)

 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
Public function Const FVector Get current angular velocity in world space from physics body.
Public function Const FVector Get current angular velocity in world space from physics body.
Public function Const FTransform

GetUnrealWorldTransform ( bool bWithProjection,
bool bForceGlobalPose
)

 Get current transform in world space from physics body.
Public function Const FTransform

GetUnrealWorldTransform_AssumesLocked ( bool bWithProjection,
bool bForceGlobalPose
)

 Get current transform in world space from physics body.
Public function Const FVector Get current velocity in world space from physics body.
Public function Const FVector Get current velocity in world space from physics body.
Public function Const FVector

GetUnrealWorldVelocityAtPoint ( const FVector& Point
)

 Get current velocity of a point on this physics body, in world space.
Public function Const FVector Get current velocity of a point on this physics body, in world space.
Public function Const const FWalkableSlopeOverride & Returns the slope override struct for this instance.
Public function void

InitBody ( UBodySetup* Setup,
const FTransform& Transform,
UPrimitiveComponent* PrimComp,
FPhysScene* InRBScene,
const FInitBodySpawnParams& SpawnParams
)

 Initialise a single rigid body (this FBodyInstance) for the given body setup
Public function void

InitBody ( UBodySetup* Setup,
const FTransform& Transform,
UPrimitiveComponent* PrimComp,
FPhysScene* InRBScene
)

  
Public function void Initialise dynamic properties for this instance when using physics - this must be done after scene addition.
Public function Static void

InitStaticBodies ( const TArray< FBodyInstance* >& Bodies,
const TArray< FTransform >& Transforms,
UBodySetup* BodySetup,
UPrimitiveComponent* PrimitiveComp,
FPhysScene* InRBScene
)

 Standalone path to batch initialize large amounts of static bodies, which will be deferred till the next scene update for fast scene addition.
Public function Const bool Returns true if the body is not static
Public function bool Whether inertia conditioning is enabled.
Public function Const bool Returns whether this body is awake
Public function Const bool Returns true if this body is simulating, false if it is fixed (kinematic)
Public function Const bool Returns true if the body is non kinematic
Public function Const bool  
Public function Const bool

IsShapeBoundToBody ( const FPhysicsShapeHandle& Shape
)

 Check if the shape is owned by this body instance
Public function Const bool See if this body is valid.
Public function Const bool

LineTrace ( FHitResult& OutHit,
const FVector& Start,
const FVector& End,
bool bTraceComplex,
bool bReturnPhysicalMaterial
)

 Trace a ray against just this bodyinstance
Public function void

LoadProfileData ( bool bVerifyProfile
)

 Update profile data if required
Public function FCalculateCustomProjection & Returns reference to the OnCalculateCustomProjection delegate.
Public function FRecalculatedMassProperties & Returns reference to the OnRecalculatedMassProperties delegate.
Public function Const bool

OverlapMulti ( TArray< struct FOverlapResult >& InOutOverlaps,
const UWorld* World,
const FTransform* pWorldToComponent,
const FVector& Pos,
const FRotator& Rot,
ECollisionChannel TestChannel,
const FComponentQueryParams& Params,
const FCollisionResponseParams& ResponseParams,
const FCollisionObjectQueryParams& ObjectQueryParams
)

 Determines the set of components that this body instance would overlap with at the supplied location/rotation
Public function Const bool

OverlapMulti ( TArray< struct FOverlapResult >& InOutOverlaps,
const UWorld* World,
const FTransform* pWorldToComponent,
const FVector& Pos,
const FQuat& Rot,
ECollisionChannel TestChannel,
const FComponentQueryParams& Params,
const FCollisionResponseParams& ResponseParams,
const FCollisionObjectQueryParams& ObjectQueryParams
)

 Determines the set of components that this body instance would overlap with at the supplied location/rotation
Public function Const bool

OverlapTest ( const FVector& Position,
const FQuat& Rotation,
const FCollisionShape& CollisionShape,
FMTDResult* OutMTD,
bool bTraceComplex
)

 Test if the bodyinstance overlaps with the specified shape at the specified position/rotation
Public function Const bool

OverlapTest_AssumesLocked ( const FVector& Position,
const FQuat& Rotation,
const FCollisionShape& CollisionShape,
FMTDResult* OutMTD,
bool bTraceComplex
)

 Test if the bodyinstance overlaps with the specified shape at the specified position/rotation Note: This function is not thread safe.
Public function Const bool

OverlapTestForBodies ( const FVector& Position,
const FQuat& Rotation,
const TArray< FBodyInstance* >& Bodies,
bool bTraceComplex
)

 Test if the bodyinstance overlaps with the specified body instances
Public function Const bool

OverlapTestForBody ( const FVector& Position,
const FQuat& Rotation,
FBodyInstance* Body,
bool bTraceComplex
)

  
Public function void After adding/removing shapes call this function to update mass distribution etc...
Public function void Force this body to sleep
Public function bool

ReplaceResponseToChannels ( ECollisionResponse OldResponse,
ECollisionResponse NewResponse
)

 Replace the channels on this body matching the old response with the new response
Public function Static EDOFMode::Type  
Public function void

SetAngularVelocityInRadians ( const FVector& NewAngVel,
bool bAddToCurrent,
bool bAutoWake
)

 Set the angular velocity of this body
Public function void

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

 Move the physics body to a new pose.
Public function void

SetCollisionEnabled ( ECollisionEnabled::Type NewType,
bool bUpdatePhysicsFilterData
)

 Controls what kind of collision is enabled for this body and allows optional disable physics rebuild
Public function void

SetCollisionProfileName ( FName InCollisionProfileName
)

 Set Collision Profile Name This function should be called outside of constructors to set profile name.
Public function void

SetCollisionProfileNameDeferred ( FName InCollisionProfileName
)

 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.
Public function void

SetContactModification ( bool bNewContactModification
)

 Enables/disables contact modification
Public function void

SetContactReportForceThreshold ( float Threshold
)

 Set a new contact report force threhold. Threshold < 0 disables this feature.
Public function void

SetDOFLock ( EDOFMode::Type NewDOFMode
)

 [Physx Only] Locks physical movement along axis.
Public function void

SetEnableGravity ( bool bGravityEnabled
)

 Enables/disables whether this body is affected by gravity.
Public function void

SetInertiaConditioningEnabled ( bool bEnabled
)

 Enable or disable inertia conditionin.
Public function void

SetInstanceNotifyRBCollision ( bool bNewNotifyCollision
)

 Set whether we should get a notification about physics collisions
Public function void

SetInstanceSimulatePhysics ( bool bSimulate,
bool bMaintainPhysicsBlending,
bool bPreserveExistingAttachment
)

 Set this body to either simulate or to be fixed/kinematic.
Public function void

SetLinearVelocity ( const FVector& NewVel,
bool bAddToCurrent,
bool bAutoWake
)

 Set the linear velocity of this body
Public function void

SetMaskFilter ( FMaskFilter InMaskFilter
)

 Updates the mask filter.
Public function void

SetMassOverride ( float MassInKG,
bool bNewOverrideMass
)

 Sets the mass override
Public function void

SetMassScale ( float InMassScale
)

 Modify the mass scale of this body
Public function void

SetMassSpaceLocal ( const FTransform& NewMassSpaceLocalTM
)

 TODO: this only works at runtime when the physics state has been created.
Public function void

SetMaxAngularVelocityInRadians ( float NewMaxAngVel,
bool bAddToCurrent,
bool bUpdateOverrideMaxAngularVelocity
)

 Set the maximum angular velocity of this body
Public function void

SetMaxDepenetrationVelocity ( float MaxVelocity
)

 Set the maximum depenetration velocity the physics simulation will introduce
Public function void

SetObjectType ( ECollisionChannel Channel
)

 Set the movement channel of this body to the one supplied
Public function void

SetOneWayInteraction ( bool InOneWayInteraction
)

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

SetPhysicsDisabled ( bool bSetDisabled
)

 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
Public function void Set physical material override for this body
Public function bool

SetResponseToAllChannels ( ECollisionResponse NewResponse
)

 Set the response of this body to all channels
Public function bool

SetResponseToChannel ( ECollisionChannel Channel,
ECollisionResponse NewResponse
)

 Set the collision response of this body to a particular channel
Public function bool Set the response of this body to the supplied settings
Public function void

SetShapeCollisionEnabled ( const int32 ShapeIndex,
ECollisionEnabled::Type NewType,
bool bUpdatePhysicsFilterData
)

 Controls what kind of collision is enabled for a particular shape
Public function bool

SetShapeResponseToChannels ( const int32 ShapeIndex,
const FCollisionResponseContainer& NewResponses
)

 Set the response of a specific shape on this body to the supplied settings
Public function void

SetSmoothEdgeCollisionsEnabled ( bool bNewSmoothEdgeCollisions
)

 Enables/disabled smoothed edge collisions
Public function void

SetUpdateKinematicFromSimulation ( bool bUpdateKinematicFromSimulation
)

 Enables/disables whether this body, when kinematic, is updated from the simulation rather than when setting the kinematic target.
Public function void

SetUseCCD ( bool bInUseCCD
)

 Enable/disable Continuous Collidion Detection feature
Public function void

SetWalkableSlopeOverride ( const FWalkableSlopeOverride& NewOverride,
bool bNewOverideSetting
)

 Sets a custom slope override struct for this instance.
Public function Const bool Whether we should interpolate when substepping.
Public function Const bool

Sweep ( FHitResult& OutHit,
const FVector& Start,
const FVector& End,
const FQuat& ShapeWorldRotation,
const FCollisionShape& Shape,
bool bTraceComplex
)

 Trace a shape against just this bodyinstance
Public function void

TermBody ( bool bNeverDeferRelease
)

 Terminates the body, releasing resources Clean up the physics engine info for this instance.
Public function void

UnWeld ( FBodyInstance* Body
)

 Takes a welded body and unwelds it.
Public function bool

UpdateBodyScale ( const FVector& InScale3D,
bool bForceUpdate
)

 Update Body Scale
Public function void Update instance's linear and angular damping
Public function void Makes sure the current kinematic state matches the simulate flag
Protected function void Update the substepping interpolation flag
Public function void Update instance's mass properties (mass, inertia and center-of-mass offset) based on MassScale, InstanceMassScale and COMNudge.
Public function void Update the instance's material properties (friction, restitution)
Public function void Update the instances collision filtering data
Public function void

UpdateTriMeshVertices ( const TArray< FVector >& NewPositions
)

 Dynamically update the vertices of per-poly collision for this body.
Public function void

UseExternalCollisionProfile ( UBodySetup* InExternalCollisionProfileBodySetup
)

 Use the collision profile found in the given BodySetup's default BodyInstance
Public function Static bool

ValidateTransform ( const FTransform& Transform,
const FString& DebugName,
const UBodySetup* Setup
)

 Validate a body transform, outputting debug info
Public function void Wake this body
Public function bool

Weld ( FBodyInstance* Body,
const FTransform& RelativeTM
)

 Takes two body instances and welds them together to create a single simulated rigid body.

Classes

  Type Name Description
Public struct FWeldInfo    

Deprecated Variables

  Type Name Description
Public variable FCollisionResponseContainer ResponseToChannels_DEPRECATED Types of objects that this physics objects will collide with.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page