BodyInstance.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Class.h"
#include "Engine/EngineTypes.h"
#include "CollisionQueryParams.h"
#include "EngineDefines.h"
#include "GameFramework/PlayerController.h"
#include "Physics/PhysicsInterfaceCore.h"
#include "Physics/PhysicsInterfaceTypes.h"
#include "PhysicsPublic.h"
#include "BodyInstanceCore.h"
#include "BodyInstance.generated.h"
 
#define UE_API ENGINE_API
 
class UBodySetup;
class UPhysicalMaterial;
class UPhysicalMaterialMask;
class UPrimitiveComponent;
class IPhysicsBodyInstanceOwner;
struct FBodyInstance;
struct FCollisionNotifyInfo;
struct FCollisionShape;
struct FConstraintInstance;
struct FPropertyChangedEvent;
struct FRigidBodyState;
struct FShapeData;
 
struct FShapeData;
 
ENGINE_API FArchive& operator<<(FArchive& Ar, FBodyInstance& BodyInst);
ENGINE_API int32 FillInlineShapeArray_AssumesLocked(PhysicsInterfaceTypes::FInlineShapeArray& Array, const FPhysicsActorHandle& Actor);
 
UENUM(BlueprintType)
namespace EDOFMode
{
    enum Type : int
    {
        /*Inherits the degrees of freedom from the project settings.*/
        Default,
        /*Specifies which axis to freeze rotation and movement along.*/
        SixDOF,
        /*Allows 2D movement along the Y-Z plane.*/
        YZPlane,
        /*Allows 2D movement along the X-Z plane.*/
        XZPlane,
        /*Allows 2D movement along the X-Y plane.*/
        XYPlane,
        /*Allows 2D movement along the plane of a given normal*/
        CustomPlane,
        /*No constraints.*/
        None
    };
}
 
struct FBodyInstance;
 
#ifndef CHAOS_DEBUG_NAME
#define CHAOS_DEBUG_NAME 0
#endif
 
#define USE_BODYINSTANCE_DEBUG_NAMES (!NO_LOGGING && CHAOS_DEBUG_NAME)
 
struct FInitBodySpawnParams
{
    ENGINE_API FInitBodySpawnParams(const UPrimitiveComponent* PrimComp);
    ENGINE_API FInitBodySpawnParams(bool bInStaticPhysics, bool bInPhysicsTypeDeterminesSimulation);
 
    bool bStaticPhysics;
 
    bool bPhysicsTypeDeterminesSimulation;
 
    FPhysicsAggregateHandle Aggregate;
};
 
namespace Chaos
{
    struct FSerializedDataBuffer;
}
 
namespace Chaos::Private
{
    // Private base class necessary to keep friend access to FBodyInstance
    struct FInitBodiesHelperBaseInternal
    {
    protected:
        void SetBodyInstanceExternalCollisionProfileBodySetup(FBodyInstance* BodyInstance, UBodySetup* ExternalCollisionProfileBodySetup);
        void UpdateBodyInstanceSolverAsyncDeltaTime(FBodyInstance* BodyInstance);
    };
}
 
template <typename InAllocatorType = FDefaultAllocator>
struct TInitBodiesHelperBase : public Chaos::Private::FInitBodiesHelperBaseInternal
{
public:
    ENGINE_API TInitBodiesHelperBase(TArray<FBodyInstance*, InAllocatorType>& InBodies, TArray<FTransform, InAllocatorType>& InTransforms,
        class UBodySetup* InBodySetup, class UPrimitiveComponent* InPrimitiveComp, FPhysScene* InRBScene,
        const FInitBodySpawnParams& InSpawnParams, FPhysicsAggregateHandle InAggregate, IPhysicsBodyInstanceOwner* InBodyInstanceOwner = nullptr);
    
    ENGINE_API TInitBodiesHelperBase(TArray<FBodyInstance*, InAllocatorType>& InBodies, TArray<FTransform, InAllocatorType>& InTransforms,
        class UBodySetup* InBodySetup, class UPrimitiveComponent* InComponent, UObject* InSourceObject, FPhysScene* InRBScene,
        const FInitBodySpawnParams& InSpawnParams, FPhysicsAggregateHandle InAggregate, IPhysicsBodyInstanceOwner* InBodyInstanceOwner = nullptr);
 
    TInitBodiesHelperBase(const TInitBodiesHelperBase& InHelper) = delete;
    TInitBodiesHelperBase(TInitBodiesHelperBase&& InHelper) = delete;
    TInitBodiesHelperBase& operator=(const TInitBodiesHelperBase& InHelper) = delete;
    TInitBodiesHelperBase& operator=(TInitBodiesHelperBase&& InHelper) = delete;
 
    bool IsStatic() const { return bStatic; }
 
    //The arguments passed into InitBodies
    TArray<FBodyInstance*, InAllocatorType>& Bodies;
    TArray<FTransform, InAllocatorType>& Transforms;
 
    class UBodySetup* BodySetup;
    class UPrimitiveComponent* PrimitiveComp;
    IPhysicsBodyInstanceOwner* BodyInstanceOwner;
    UObject* SourceObject;
    FPhysScene* PhysScene;
    FPhysicsAggregateHandle Aggregate;
 
#if USE_BODYINSTANCE_DEBUG_NAMES
    TSharedPtr<FString, ESPMode::ThreadSafe> DebugName;
    TSharedPtr<TArray<ANSICHAR>> PhysXName; // Get rid of ANSICHAR in physics
#endif
 
    //The constants shared between PhysX and Box2D
    bool bStatic;
    bool bInstanceSimulatePhysics;
    float InstanceBlendWeight;
 
    const USkeletalMeshComponent* SkelMeshComp;
 
    const FInitBodySpawnParams& SpawnParams;
 
    bool DisableQueryOnlyActors;
 
    // Return to actor ref
    void CreateActor_AssumesLocked(FBodyInstance* Instance, const FTransform& Transform) const;
    bool CreateShapes_AssumesLocked(FBodyInstance* Instance) const;
 
    // Takes actor ref arrays.
    // #PHYS2 this used to return arrays of low-level physics bodies, which would be added to scene in InitBodies. Should it still do that, rather then later iterate over BodyInstances to get phys actor refs?
    bool CreateShapesAndActors();
    void InitBodies();
 
protected:
    void UpdateSimulatingAndBlendWeight();
 
};
 
using FInitBodiesHelperBase = TInitBodiesHelperBase<FDefaultAllocator>;
 
template <bool bCompileStatic, typename InAllocatorType = FDefaultAllocator>
struct FInitBodiesHelper : public TInitBodiesHelperBase<InAllocatorType>
{
    FInitBodiesHelper(TArray<FBodyInstance*, InAllocatorType>& InBodies, TArray<FTransform, InAllocatorType>& InTransforms, class UBodySetup* InBodySetup,
        class UPrimitiveComponent* InPrimitiveComp, FPhysScene* InRBScene,
        const FInitBodySpawnParams& InSpawnParams, FPhysicsAggregateHandle InAggregate, IPhysicsBodyInstanceOwner* InBodyInstanceOwner = nullptr);
 
    FInitBodiesHelper(TArray<FBodyInstance*, InAllocatorType>& InBodies, TArray<FTransform, InAllocatorType>& InTransforms, class UBodySetup* InBodySetup,
        class UPrimitiveComponent* InComponent, class UObject* InSourceObject, FPhysScene* InRBScene,
        const FInitBodySpawnParams& InSpawnParams, FPhysicsAggregateHandle InAggregate, IPhysicsBodyInstanceOwner* InBodyInstanceOwner = nullptr)
        : TInitBodiesHelperBase<InAllocatorType>(InBodies, InTransforms, InBodySetup, InComponent, InSourceObject, InRBScene, InSpawnParams, InAggregate, InBodyInstanceOwner)
    {
        //Compute all the needed constants
        this->bStatic = bCompileStatic || this->SpawnParams.bStaticPhysics;
        this->SkelMeshComp = bCompileStatic ? nullptr : Cast<USkeletalMeshComponent>(this->PrimitiveComp);
        if (this->SpawnParams.bPhysicsTypeDeterminesSimulation)
        {
            this->UpdateSimulatingAndBlendWeight();
        }
    }
};
 
template <bool bCompileStatic>
struct FInitBodiesHelperWithData : public FInitBodiesHelperBase
{
    FInitBodiesHelperWithData() { check(false); }
    FInitBodiesHelperWithData(TArray<FBodyInstance*>&& InBodies, TArray<FTransform>&& InTransforms, class UBodySetup* InBodySetup, class UPrimitiveComponent* InPrimitiveComp, FPhysScene* InRBScene, const FInitBodySpawnParams& InSpawnParams, FPhysicsAggregateHandle InAggregate, IPhysicsBodyInstanceOwner* InBodyInstanceOwner = nullptr)
    : FInitBodiesHelperBase(OwnedBodies, OwnedTransforms, InBodySetup, InPrimitiveComp, InRBScene, InSpawnParams, InAggregate, InBodyInstanceOwner), OwnedBodies(MoveTemp(InBodies)), OwnedTransforms(MoveTemp(InTransforms)) //-V1050
    {
        //Compute all the needed constants
        bStatic = bCompileStatic || SpawnParams.bStaticPhysics;
        SkelMeshComp = bCompileStatic ? nullptr : Cast<USkeletalMeshComponent>(PrimitiveComp);
        if(SpawnParams.bPhysicsTypeDeterminesSimulation)
        {
            this->UpdateSimulatingAndBlendWeight();
        }
    }
 
    FInitBodiesHelperWithData(const FInitBodiesHelperWithData& InHelper)
    : FInitBodiesHelperBase(OwnedBodies, OwnedTransforms, InHelper.BodySetup, InHelper.PrimitiveComp, InHelper.PhysScene, InHelper.SpawnParams, InHelper.Aggregate), OwnedBodies(InHelper.OwnedBodies), OwnedTransforms(InHelper.OwnedTransforms, InHelper.BodyInstanceOwner) //-V1050
    {
        ensure(false);
    }
 
    FInitBodiesHelperWithData(FInitBodiesHelperWithData&& InHelper)
    : FInitBodiesHelperBase(OwnedBodies, OwnedTransforms, InHelper.BodySetup, InHelper.PrimitiveComp, InHelper.PhysScene, InHelper.SpawnParams, InHelper.Aggregate), OwnedBodies(MoveTemp(InHelper.OwnedBodies)), OwnedTransforms(MoveTemp(InHelper.OwnedTransforms)) //-V1050
    {
        //Compute all the needed constants
        bStatic = bCompileStatic || SpawnParams.bStaticPhysics;
        SkelMeshComp = bCompileStatic ? nullptr : Cast<USkeletalMeshComponent>(PrimitiveComp);
        if (SpawnParams.bPhysicsTypeDeterminesSimulation)
        {
            this->UpdateSimulatingAndBlendWeight();
        }
    }
 
    FInitBodiesHelperWithData& operator=(const FInitBodiesHelperWithData& InHelper) = delete;
    FInitBodiesHelperWithData& operator=(FInitBodiesHelperWithData&& InHelper) = delete;
 
    TArray<FBodyInstance*> OwnedBodies;
    TArray<FTransform> OwnedTransforms;
};
 
USTRUCT()
struct FCollisionResponse
{
    GENERATED_USTRUCT_BODY()
 
    ENGINE_API FCollisionResponse();
    ENGINE_API FCollisionResponse(ECollisionResponse DefaultResponse);
 
    ENGINE_API bool SetResponse(ECollisionChannel Channel, ECollisionResponse NewResponse);
 
    ENGINE_API bool SetAllChannels(ECollisionResponse NewResponse);
 
    ENGINE_API bool ReplaceChannels(ECollisionResponse OldResponse, ECollisionResponse NewResponse);
 
    ECollisionResponse GetResponse(ECollisionChannel Channel) const { return ResponseToChannels.GetResponse(Channel); }
    const FCollisionResponseContainer& GetResponseContainer() const { return ResponseToChannels; }
 
    ENGINE_API bool SetCollisionResponseContainer(const FCollisionResponseContainer& InResponseToChannels);
    ENGINE_API void SetResponsesArray(const TArray<FResponseChannel>& InChannelResponses);
    ENGINE_API void UpdateResponseContainerFromArray();
 
    ENGINE_API bool operator==(const FCollisionResponse& Other) const;
    bool operator!=(const FCollisionResponse& Other) const
    {
        return !(*this == Other);
    }
 
private:
 
#if 1// @hack until PostLoad is disabled for CDO of BP - WITH_EDITOR
    ENGINE_API bool RemoveReponseFromArray(ECollisionChannel Channel);
    ENGINE_API bool AddReponseToArray(ECollisionChannel Channel, ECollisionResponse Response);
    ENGINE_API void UpdateArrayFromResponseContainer();
#endif
 
    // we have to still load them until resave
    UPROPERTY(transient)
    FCollisionResponseContainer ResponseToChannels;
 
    UPROPERTY(EditAnywhere, Category = Custom)
    TArray<FResponseChannel> ResponseArray;
 
    friend struct FBodyInstance;
};
 
template<>
struct TStructOpsTypeTraits<FCollisionResponse> : public TStructOpsTypeTraitsBase2<FCollisionResponse>
{
    enum
    {
        WithIdenticalViaEquality = true
    };
};
 
enum class BodyInstanceSceneState : uint8
{
    NotAdded,
    AwaitingAdd,
    Added,
    AwaitingRemove,
    Removed
};
 
namespace Chaos
{
    class FRigidBodyHandle_Internal;
}
 
USTRUCT(BlueprintType)
struct FBodyInstanceAsyncPhysicsTickHandle
{
    GENERATED_BODY()
    FPhysicsActorHandle Proxy = nullptr;
 
    ENGINE_API Chaos::FRigidBodyHandle_Internal* operator->();
 
    ENGINE_API bool IsValid() const;
    operator bool() const { return IsValid(); }
};
 
USTRUCT(BlueprintType)
struct FBodyInstance : public FBodyInstanceCore
{
    GENERATED_USTRUCT_BODY()
 
    
    int32 InstanceBodyIndex;
 
    int16 InstanceBoneIndex;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Physics, meta = (editcondition = "bOverrideIterationCounts", InlineEditConditionToggle, ClampMin = "0", UIMin = "0"))
    uint8 PositionSolverIterationCount;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Physics, meta = (editcondition = "bOverrideIterationCounts", InlineEditConditionToggle, ClampMin = "0", UIMin = "0"))
    uint8 VelocitySolverIterationCount;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Physics, meta = (editcondition = "bOverrideIterationCounts", InlineEditConditionToggle, ClampMin = "0", UIMin = "0"))
    uint8 ProjectionSolverIterationCount;
 
private:
    UPROPERTY(EditAnywhere, Category=Custom)
    TEnumAsByte<enum ECollisionChannel> ObjectType;
 
 
    FMaskFilter MaskFilter;
 
    UPROPERTY(EditAnywhere, Category=Custom)
    TEnumAsByte<ECollisionEnabled::Type> CollisionEnabled;
 
    TArray<TEnumAsByte<ECollisionEnabled::Type>> ShapeCollisionEnabled;
 
    TArray<TPair<int32, FCollisionResponse>> ShapeCollisionResponses;
 
public:
    // Current state of the physics body for tracking deferred addition and removal.
    BodyInstanceSceneState CurrentSceneState;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Physics)
    ESleepFamily SleepFamily;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (DisplayName = "Mode"))
    TEnumAsByte<EDOFMode::Type> DOFMode;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Collision)
    uint8 bUseCCD : 1;
 
private:
 
    uint8 bShapeCollisionEnabledIsSet : 1;
    uint8 bShapeCollisionResponsesIsSet : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Collision)
    uint8 bUseMACD : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Physics)
    uint8 bAllowPartialIslandSleep : 1;
 
public:
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Collision)
    uint8 bIgnoreAnalyticCollisions : 1;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Collision, meta = (DisplayName = "Simulation Generates Hit Events"))
    uint8 bNotifyRigidBodyCollision : 1;
 
    uint8 bContactModification : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Collision)
    uint8 bSmoothEdgeCollisions : 1;
 
    // SIM SETTINGS
 
    UPROPERTY(EditAnywhere, Category = Physics, meta=(DisplayName = "Lock Axis Translation"))
    uint8 bLockTranslation : 1;
    
    UPROPERTY(EditAnywhere, Category = Physics, meta=(DisplayName = "Lock Axis Rotation"))
    uint8 bLockRotation : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (DisplayName = "X"))
    uint8 bLockXTranslation : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (DisplayName = "Y"))
    uint8 bLockYTranslation : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (DisplayName = "Z"))
    uint8 bLockZTranslation : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (DisplayName = "X"))
    uint8 bLockXRotation : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (DisplayName = "Y"))
    uint8 bLockYRotation : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (DisplayName = "Z"))
    uint8 bLockZRotation : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (editcondition = "bSimulatePhysics", InlineEditConditionToggle))
    uint8 bOverrideMaxAngularVelocity : 1;
 
 
    uint8 bHACK_DisableCollisionResponse : 1;
    /* By default, an owning skel mesh component will override the body's collision filter. This will disable that behavior. */
    uint8 bHACK_DisableSkelComponentFilterOverriding : 1;
 
protected:
 
    UPROPERTY(EditAnywhere, Category = Physics, meta=(InlineEditConditionToggle))
    uint8 bOverrideMaxDepenetrationVelocity : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (InlineEditConditionToggle))
    uint8 bOverrideWalkableSlopeOnInstance : 1;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (InlineEditConditionToggle))
    uint8 bOverrideIterationCounts : 1;
 
    UPROPERTY()
    uint8 bInterpolateWhenSubStepping : 1;
 
    uint8 bPendingCollisionProfileSetup : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Physics)
    uint8 bInertiaConditioning : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Physics)
    uint8 bOneWayInteraction : 1;
 
public:
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Physics)
    uint8 bOverrideSolverAsyncDeltaTime : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Physics, meta = (editcondition = "bOverrideSolverAsyncDeltaTime"))
    float SolverAsyncDeltaTime;
 
    float GetSolverAsyncDeltaTime() const { return SolverAsyncDeltaTime; }
    bool IsSolverAsyncDeltaTimeSet() const { return bOverrideSolverAsyncDeltaTime && SolverAsyncDeltaTime > 0.0; }
 
    void SetSolverAsyncDeltaTime(const float NewSolverAsyncDeltaTime);
 
private:
    void UpdateSolverAsyncDeltaTime();
 
    UPROPERTY(EditAnywhere, Category=Custom)
    FName CollisionProfileName;
 
public:
    FVector Scale3D;
 
    // COLLISION SETTINGS
 
#if WITH_EDITORONLY_DATA
    UPROPERTY() 
    struct FCollisionResponseContainer ResponseToChannels_DEPRECATED;
#endif // WITH_EDITORONLY_DATA
 
private:
    UPROPERTY(EditAnywhere, Category = Custom)
    struct FCollisionResponse CollisionResponses;
 
protected:
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Physics, meta = (editcondition = "bOverrideMaxDepenetrationVelocity", ClampMin = "0.0", UIMin = "0.0"))
    float MaxDepenetrationVelocity;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category = Physics, meta = (editcondition = "bOverrideMass", ClampMin = "0.001", UIMin = "0.001", DisplayName = "Mass (kg)"))
    float MassInKgOverride;
 
    TWeakObjectPtr<UBodySetup> ExternalCollisionProfileBodySetup;
 
    ENGINE_API void UpdateInterpolateWhenSubStepping();
 
public:
 
    bool ShouldInterpolateWhenSubStepping() const { return bInterpolateWhenSubStepping; }
 
    float GetMassOverride() const { return MassInKgOverride; }
 
    bool IsUsingMACD() const { return bUseMACD; }
 
    bool IsPartialIslandSleepAllowed() const { return bAllowPartialIslandSleep; }
 
    ENGINE_API void SetMassOverride(float MassInKG, bool bNewOverrideMass = true);
 
    ENGINE_API bool GetRigidBodyState(FRigidBodyState& OutState);
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Physics)
    float LinearDamping;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = Physics)
    float AngularDamping;
 
    UPROPERTY(EditAnywhere, Category = Physics, meta = (DisplayName = "Plane Normal"))
    FVector CustomDOFPlaneNormal;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Physics, meta = (DisplayName = "Center Of Mass Offset"))
    FVector COMNudge;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Physics, meta = (ClampMin = "0.001", UIMin = "0.001"))
    float MassScale;
 
    UPROPERTY(EditAnywhere,BlueprintReadOnly,Category = Physics, meta = (ClampMin = "0", UIMin = "0", UIMax = "7"))
    uint8 GravityGroupIndex;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadWrite, Category = Physics)
    FVector InertiaTensorScale;
 
public:
    ENGINE_API void UseExternalCollisionProfile(UBodySetup* InExternalCollisionProfileBodySetup);
 
    ENGINE_API void ClearExternalCollisionProfile();
 
    ENGINE_API void SetDOFLock(EDOFMode::Type NewDOFMode);
 
    ENGINE_API FVector GetLockedAxis() const;
    ENGINE_API void CreateDOFLock();
 
    static ENGINE_API EDOFMode::Type ResolveDOFMode(EDOFMode::Type DOFMode);
 
    FConstraintInstance* DOFConstraint;
 
    FBodyInstance* WeldParent;
 
protected:
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Physics, meta = (editcondition = "bOverrideWalkableSlopeOnInstance"))
    struct FWalkableSlopeOverride WalkableSlopeOverride;
 
    UPROPERTY(EditAnywhere, BlueprintReadOnly, Category=Collision)
    TObjectPtr<class UPhysicalMaterial> PhysMaterialOverride;
 
public:
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Physics, meta = (editcondition = "bOverrideMaxAngularVelocity"))
    float MaxAngularVelocity;
 
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category = Physics)
    float CustomSleepThresholdMultiplier;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, BlueprintReadOnly, Category=Physics)
    float StabilizationThresholdMultiplier;
 
    UPROPERTY()
    float PhysicsBlendWeight;
 
public:
 
    ENGINE_API UBodySetup* GetBodySetup() const;
 
    ENGINE_API FPhysicsActorHandle GetPhysicsActor() const;
    ENGINE_API FPhysicsActorHandle GetPhysicsActorWeldRoot() const;
    ENGINE_API void SetPhysicsActor(FPhysicsActorHandle InHandle);
    ENGINE_API void ReleasePhysicsActor();
 
    // TODO_CHAOSAPI: Deprecate ActorHandle Ref API
    ENGINE_API FPhysicsActorHandle& GetPhysicsActorHandle();
    ENGINE_API const FPhysicsActorHandle& GetPhysicsActorHandle() const;
    ENGINE_API const FPhysicsActorHandle& GetActorReferenceWithWelding() const;
    inline void SetPhysicsActorHandle(FPhysicsActorHandle InHandle) { SetPhysicsActor(InHandle); }
 
    // TODO_CHAOSAPI: Deprecate public ActorHandle
    // Internal physics representation of our body instance
    FPhysicsActorHandle ActorHandle;
 
public:
    FBodyInstanceAsyncPhysicsTickHandle GetBodyInstanceAsyncPhysicsTickHandle() const { return FBodyInstanceAsyncPhysicsTickHandle{ ActorHandle }; }
 
#if USE_BODYINSTANCE_DEBUG_NAMES
    TSharedPtr<TArray<ANSICHAR>> CharDebugName;
#endif
 
    TWeakObjectPtr<class UPrimitiveComponent> OwnerComponent;
 
    IPhysicsBodyInstanceOwner* BodyInstanceOwner;
 
    TWeakObjectPtr<UObject> SourceObject;
 
    ENGINE_API FBodyInstance();
    ENGINE_API ~FBodyInstance();
 
    ENGINE_API void LoadProfileData(bool bVerifyProfile);
 
    void InitBody(UBodySetup* Setup, const FTransform& Transform, UPrimitiveComponent* PrimComp, FPhysScene* InRBScene)
    {
        InitBody(Setup, Transform, PrimComp, InRBScene, FInitBodySpawnParams(PrimComp));
    }
 
 
    ENGINE_API void InitBody(UBodySetup* Setup, const FTransform& Transform, UPrimitiveComponent* PrimComp, FPhysScene* InRBScene, const FInitBodySpawnParams& SpawnParams, IPhysicsBodyInstanceOwner* BodyInstanceOwner = nullptr);
 
    ENGINE_API void InitBody(UBodySetup* Setup, const FTransform& Transform, 
        UPrimitiveComponent* PrimComp, UObject* SourceObject, 
        FPhysScene* InRBScene, const FInitBodySpawnParams& SpawnParams, 
        IPhysicsBodyInstanceOwner* BodyInstanceOwner = nullptr);
 
    static ENGINE_API bool ValidateTransform(const FTransform &Transform, const FString& DebugName, const UBodySetup* Setup);
 
    static ENGINE_API void InitStaticBodies(const TArray<FBodyInstance*>& Bodies, const TArray<FTransform>& Transforms, UBodySetup* BodySetup, class UPrimitiveComponent* PrimitiveComp, FPhysScene* InRBScene);
    
    static ENGINE_API void InitStaticBodies(TArray<FBodyInstance*>&& Bodies, TArray<FTransform>&& Transforms, UBodySetup* BodySetup, class UPrimitiveComponent* PrimitiveComp, FPhysScene* InRBScene, IPhysicsBodyInstanceOwner* BodyInstanceOwner = nullptr);
 
    ENGINE_API FPhysScene* GetPhysicsScene();
    ENGINE_API const FPhysScene* GetPhysicsScene() const;
 
    ENGINE_API void InitDynamicProperties_AssumesLocked();
 
    ENGINE_API void BuildBodyFilterData(FBodyCollisionFilterData& OutFilterData, const int32 ShapeIndex = INDEX_NONE) const;
 
    static ENGINE_API void BuildBodyCollisionFlags(FBodyCollisionFlags& OutFlags, ECollisionEnabled::Type UseCollisionEnabled, bool bUseComplexAsSimple);
 
    ENGINE_API int32 GetAllShapes_AssumesLocked(TArray<FPhysicsShapeHandle>& OutShapes) const;
 
    ENGINE_API void TermBody(bool bNeverDeferRelease = false);
 
    // Contains the payload necessary for FBodyInstance::AsyncTermBody to release the body's resources asynchronously (outside of game thread).
    struct FAsyncTermBodyPayload
    {
        UE_API FAsyncTermBodyPayload();
        FPhysicsActorHandle GetPhysicsActor() const { return ActorHandle; }
 
    private:
        FPhysicsActorHandle ActorHandle;
        TWeakObjectPtr<class UPrimitiveComponent> OwnerComponent;
        bool bNotifyRigidBodyCollision;
 
        friend struct FBodyInstance;
    };
 
    ENGINE_API FAsyncTermBodyPayload StartAsyncTermBody_GameThread();
 
    static ENGINE_API void AsyncTermBody(FAsyncTermBodyPayload& Payload);
 
    ENGINE_API bool Weld(FBodyInstance* Body, const FTransform& RelativeTM);
 
    ENGINE_API void UnWeld(FBodyInstance* Body);
 
    ENGINE_API void ApplyWeldOnChildren();
 
    ENGINE_API void PostShapeChange();
 
    ENGINE_API bool UpdateBodyScale(const FVector& InScale3D, bool bForceUpdate = false);
 
    ENGINE_API void UpdateTriMeshVertices(const TArray<FVector> & NewPositions);
 
    FVector GetCOMPosition() const
    {
        return GetMassSpaceToWorldSpace().GetLocation();
    }
 
    ENGINE_API FTransform GetMassSpaceToWorldSpace() const;
 
    ENGINE_API FTransform GetMassSpaceLocal() const;
 
    ENGINE_API void SetMassSpaceLocal(const FTransform& NewMassSpaceLocalTM);
 
    ENGINE_API void DrawCOMPosition(class FPrimitiveDrawInterface* PDI, float COMRenderSize, const FColor& COMRenderColor);
 
    ENGINE_API void CopyBodyInstancePropertiesFrom(const FBodyInstance* FromInst);
 
    ENGINE_API void CopyRuntimeBodyInstancePropertiesFrom(const FBodyInstance* FromInst);
 
    ENGINE_API UPhysicalMaterial* GetSimplePhysicalMaterial() const;
 
    static ENGINE_API UPhysicalMaterial* GetSimplePhysicalMaterial(const FBodyInstance* BodyInstance, TWeakObjectPtr<UPrimitiveComponent> Owner, TWeakObjectPtr<UBodySetup> BodySetupPtr, IPhysicsBodyInstanceOwner* BodyInstanceOwner = nullptr);
 
    ENGINE_API TArray<UPhysicalMaterial*> GetComplexPhysicalMaterials() const;
 
    ENGINE_API TArray<UPhysicalMaterial*> GetComplexPhysicalMaterials(TArray<FPhysicalMaterialMaskParams>& OutPhysMaterialMasks) const;
 
    ENGINE_API void GetComplexPhysicalMaterials(TArray<UPhysicalMaterial*> &OutPhysMaterials) const;
 
    ENGINE_API void GetComplexPhysicalMaterials(TArray<UPhysicalMaterial*> &OutPhysMaterials, TArray<FPhysicalMaterialMaskParams>& OutPhysMaterialMasks) const;
 
    static ENGINE_API void GetComplexPhysicalMaterials(const FBodyInstance* BodyInstance, TWeakObjectPtr<UPrimitiveComponent> Owner, TArray<UPhysicalMaterial*>& OutPhysMaterials, TArray<FPhysicalMaterialMaskParams>* OutPhysMaterialMasks = nullptr, IPhysicsBodyInstanceOwner* InBodyInstanceOwner = nullptr);
 
    ENGINE_API const struct FWalkableSlopeOverride& GetWalkableSlopeOverride() const;
 
    ENGINE_API void SetWalkableSlopeOverride(const FWalkableSlopeOverride& NewOverride, bool bNewOverideSetting = true);
 
    ENGINE_API bool GetOverrideWalkableSlopeOnInstance() const;
 
    ENGINE_API bool IsDynamic() const;
 
    ENGINE_API bool IsNonKinematic() const;
 
    ENGINE_API float GetBodyMass() const;
    ENGINE_API FBox GetBodyBounds() const;
    ENGINE_API FBox GetBodyBoundsLocal() const;
    ENGINE_API FVector GetBodyInertiaTensor() const;
 
    bool IsInertiaConditioningEnabled() const { return bInertiaConditioning; }
 
    ENGINE_API void SetInertiaConditioningEnabled(bool bEnabled);
 
    ENGINE_API void ApplyAsyncPhysicsCommand(FAsyncPhysicsTimestamp TimeStamp, const bool bIsInternal, APlayerController* PlayerController, const TFunction<void()>& Command);
 
    ENGINE_API void SetInstanceSimulatePhysics(bool bSimulate, bool bMaintainPhysicsBlending=false, bool bPreserveExistingAttachment = false);
    ENGINE_API void UpdateInstanceSimulatePhysics();
    bool IsInstanceSimulatingPhysics() const;
    ENGINE_API bool IsInstanceAwake() const;
    ENGINE_API void WakeInstance();
    ENGINE_API void PutInstanceToSleep();
    ENGINE_API float GetSleepThresholdMultiplier() const;
    ENGINE_API void AddCustomPhysics(FCalculateCustomPhysics& CalculateCustomPhysics);
    ENGINE_API void AddForce(const FVector& Force, bool bAllowSubstepping = true, bool bAccelChange = false, const FAsyncPhysicsTimestamp TimeStamp = FAsyncPhysicsTimestamp(), APlayerController* PlayerController = nullptr);
    ENGINE_API void AddForceAtPosition(const FVector& Force, const FVector& Position, bool bAllowSubstepping = true, bool bIsLocalForce = false, const FAsyncPhysicsTimestamp TimeStamp = FAsyncPhysicsTimestamp(), APlayerController* PlayerController = nullptr);
    ENGINE_API void ClearForces(bool bAllowSubstepping = true);
 
    ENGINE_API void SetOneWayInteraction(bool InOneWayInteraction = true);
 
    ENGINE_API void AddTorqueInRadians(const FVector& Torque, bool bAllowSubstepping = true, bool bAccelChange = false, const FAsyncPhysicsTimestamp TimeStamp = FAsyncPhysicsTimestamp(), APlayerController* PlayerController = nullptr);
    ENGINE_API void ClearTorques(bool bAllowSubstepping = true);
 
    ENGINE_API void AddAngularImpulseInRadians(const FVector& Impulse, bool bVelChange, const FAsyncPhysicsTimestamp TimeStamp = FAsyncPhysicsTimestamp(), APlayerController* PlayerController = nullptr);
 
    ENGINE_API void AddImpulse(const FVector& Impulse, bool bVelChange, const FAsyncPhysicsTimestamp TimeStamp = FAsyncPhysicsTimestamp(), APlayerController* PlayerController = nullptr);
    
    ENGINE_API void AddImpulseAtPosition(const FVector& Impulse, const FVector& Position, const FAsyncPhysicsTimestamp TimeStamp = FAsyncPhysicsTimestamp(), APlayerController* PlayerController = nullptr);
 
    ENGINE_API void AddVelocityChangeImpulseAtLocation(const FVector& Impulse, const FVector& Position, const FAsyncPhysicsTimestamp TimeStamp = FAsyncPhysicsTimestamp(), APlayerController* PlayerController = nullptr);
 
    ENGINE_API void SetLinearVelocity(const FVector& NewVel, bool bAddToCurrent, bool bAutoWake = true);
 
    ENGINE_API void SetAngularVelocityInRadians(const FVector& NewAngVel, bool bAddToCurrent, bool bAutoWake = true);
 
    ENGINE_API void SetMaxAngularVelocityInRadians(float NewMaxAngVel, bool bAddToCurrent, bool bUpdateOverrideMaxAngularVelocity = true);
 
    ENGINE_API float GetMaxAngularVelocityInRadians() const;
 
    bool GetOverrideMaxDepenetrationVelocity() const { return bOverrideMaxDepenetrationVelocity; }
 
    ENGINE_API void SetOverrideMaxDepenetrationVelocity(bool bInEnabled);
 
    ENGINE_API void SetMaxDepenetrationVelocity(float MaxVelocity);
 
    float GetMaxDepenetrationVelocity() const { return MaxDepenetrationVelocity; }
 
    ENGINE_API void SetInstanceNotifyRBCollision(bool bNewNotifyCollision);
    ENGINE_API void SetEnableGravity(bool bGravityEnabled);
    ENGINE_API void SetGravityGroupIndex(int32 NewGravityGroupIndex);
    ENGINE_API void SetUpdateKinematicFromSimulation(bool bUpdateKinematicFromSimulation);
    ENGINE_API void SetGyroscopicTorqueEnabled(bool bInGyroscopicTorqueEnabled);
    ENGINE_API void SetContactModification(bool bNewContactModification);
    ENGINE_API void SetSmoothEdgeCollisionsEnabled(bool bNewSmoothEdgeCollisions);
 
    ENGINE_API void SetUseCCD(bool bInUseCCD);
 
    ENGINE_API void SetUseMACD(bool bInUseMACD);
 
    ENGINE_API void SetAllowPartialIslandSleep(bool bInAllowPartialIslandSleep);
 
    // Set the per-body position iterations (only used if bOverrideIterationCounts is true)
    ENGINE_API void SetPositionSolverIterationCount(uint8 PositionSolverIterationCountIn);
 
    // Set the per-body velocity iterations (only used if bOverrideIterationCounts is true)
    ENGINE_API void SetVelocitySolverIterationCount(uint8 VelocitySolverIterationCountIn);
 
    // Set the per-body projection iterations (only used if bOverrideIterationCounts is true)
    ENGINE_API void SetProjectionSolverIterationCount(uint8 ProjectionSolverIterationCountIn);
 
    // Enable or disable the use of iteration count overrides
    ENGINE_API void SetOverrideIterationCounts(bool bOverride);
 
    // Get the per-body position iterations (or -1 if bOverrideIterationCounts is false)
    int32 GetPositionSolverIterationCount() const { return (!!bOverrideIterationCounts) ? PositionSolverIterationCount : -1; }
 
    // Get the per-body velocity iterations (or -1 if bOverrideIterationCounts is false)
    int32 GetVelocitySolverIterationCount() const { return (!!bOverrideIterationCounts) ? VelocitySolverIterationCount : -1; }
 
    // Get the per-body projection iterations (or -1 if bOverrideIterationCounts is false)
    int32 GetProjectionSolverIterationCount() const { return (!!bOverrideIterationCounts) ? ProjectionSolverIterationCount : -1; }
 
    bool GetUseMACD() const { return bUseMACD != 0; }
 
    bool GetAllowPartialIslandSleep() const { return bAllowPartialIslandSleep != 0; }
 
    ENGINE_API void SetPhysicsDisabled(bool bSetDisabled);
 
    ENGINE_API bool IsPhysicsDisabled() const;
 
    ENGINE_API EPhysicsReplicationMode GetPhysicsReplicationMode() const;
 
private:
 
    struct FBodyInstanceDelegates
    {
        FCalculateCustomProjection OnCalculateCustomProjection;
 
        FRecalculatedMassProperties OnRecalculatedMassProperties;
    };
 
    struct FBodyInstanceDelegatesPtr : public TUniquePtr<FBodyInstanceDelegates>
    {
        FBodyInstanceDelegatesPtr() = default;
        FBodyInstanceDelegatesPtr(const FBodyInstanceDelegatesPtr& Other)
        {
            if (Other.IsValid())
            {
                Reset(new FBodyInstanceDelegates);
                *Get() = *Other;
            }
        }
 
        FBodyInstanceDelegatesPtr& operator=(const FBodyInstanceDelegatesPtr& Other)
        {
            if (Other.IsValid())
            {
                if (!IsValid())
                {
                    Reset(new FBodyInstanceDelegates);
                }
                *Get() = *Other;
            }
            else
            {
                Reset();
            }
 
            return *this;
        }
    };
 
    FBodyInstanceDelegatesPtr BodyInstanceDelegates;
 
public:
    ENGINE_API void ExecuteOnCalculateCustomProjection(FTransform& WorldTM) const;
 
    ENGINE_API FCalculateCustomProjection& OnCalculateCustomProjection();
 
    ENGINE_API FRecalculatedMassProperties& OnRecalculatedMassProperties();
 
    ENGINE_API bool IsValidBodyInstance() const;
 
    ENGINE_API FTransform GetUnrealWorldTransform(bool bWithProjection = true, bool bForceGlobalPose = false) const;
 
    ENGINE_API FTransform GetUnrealWorldTransform_AssumesLocked(bool bWithProjection = true, bool bForceGlobalPose = false) const;
 
    ENGINE_API FTransform GetKinematicTarget() const;
 
    ENGINE_API FTransform GetKinematicTarget_AssumesLocked() const;
 
    ENGINE_API void SetBodyTransform(const FTransform& NewTransform, ETeleportType Teleport, bool bAutoWake = true);
 
    ENGINE_API FVector GetUnrealWorldVelocity() const;
 
    ENGINE_API FVector GetUnrealWorldVelocity_AssumesLocked() const;
 
    ENGINE_API FVector GetUnrealWorldAngularVelocityInRadians() const;
 
    ENGINE_API FVector GetUnrealWorldAngularVelocityInRadians_AssumesLocked() const;
 
    ENGINE_API FVector GetUnrealWorldVelocityAtPoint(const FVector& Point) const;
 
    ENGINE_API FVector GetUnrealWorldVelocityAtPoint_AssumesLocked(const FVector& Point) const;
 
    UPhysicalMaterial* GetPhysMaterialOverride() const { return PhysMaterialOverride; }
 
    ENGINE_API void SetPhysMaterialOverride(class UPhysicalMaterial* NewPhysMaterial);
 
    ENGINE_API void SetContactReportForceThreshold(float Threshold);
 
    ENGINE_API bool SetResponseToChannel(ECollisionChannel Channel, ECollisionResponse NewResponse);
 
    inline ECollisionResponse GetResponseToChannel(ECollisionChannel Channel) const { return CollisionResponses.GetResponse(Channel); }
 
    ENGINE_API bool SetResponseToAllChannels(ECollisionResponse NewResponse);
 
    ENGINE_API bool ReplaceResponseToChannels(ECollisionResponse OldResponse, ECollisionResponse NewResponse);
 
    ENGINE_API bool SetResponseToChannels(const FCollisionResponseContainer& NewResponses);
 
    ENGINE_API bool SetShapeResponseToChannels(const int32 ShapeIndex, const FCollisionResponseContainer& NewResponses);
 
    inline const FCollisionResponseContainer& GetResponseToChannels() const { return CollisionResponses.GetResponseContainer(); }
 
    ENGINE_API const FCollisionResponseContainer& GetShapeResponseToChannels(const int32 ShapeIndex) const;
    ENGINE_API const FCollisionResponseContainer& GetShapeResponseToChannels(const int32 ShapeIndex, const FCollisionResponseContainer& DefaultResponseContainer) const;
 
    ENGINE_API void SetObjectType(ECollisionChannel Channel);
 
    inline ECollisionChannel GetObjectType() const { return ObjectType; }
 
    ENGINE_API void SetCollisionEnabled(ECollisionEnabled::Type NewType, bool bUpdatePhysicsFilterData = true);
 
    ENGINE_API void SetShapeCollisionEnabled(const int32 ShapeIndex, ECollisionEnabled::Type NewType, bool bUpdatePhysicsFilterData = true);
 
private:
 
    ENGINE_API ECollisionEnabled::Type GetCollisionEnabled_CheckOwner() const;
 
public:
    inline ECollisionEnabled::Type GetCollisionEnabled(bool bCheckOwner = true) const
    {
        return (bCheckOwner ? GetCollisionEnabled_CheckOwner() : CollisionEnabled.GetValue());
    }
 
    ENGINE_API ECollisionEnabled::Type GetShapeCollisionEnabled(const int32 ShapeIndex) const;
 
    ENGINE_API void SetCollisionProfileNameDeferred(FName InCollisionProfileName);
 
    ENGINE_API void SetCollisionProfileName(FName InCollisionProfileName);
 
    ENGINE_API void SetMaskFilter(FMaskFilter InMaskFilter);
 
    inline FMaskFilter GetMaskFilter() const { return MaskFilter; }
    ENGINE_API FName GetCollisionProfileName() const;
 
    ENGINE_API bool DoesUseCollisionProfile() const;
 
    ENGINE_API void SetMassScale(float InMassScale=1.f);
 
    ENGINE_API void UpdateMassProperties();
 
    ENGINE_API void UpdateDampingProperties();
 
    ENGINE_API void UpdatePhysicalMaterials();
 
    static ENGINE_API void ApplyMaterialToShape_AssumesLocked(const FPhysicsShapeHandle& InShape, UPhysicalMaterial* SimplePhysMat, const TArrayView<UPhysicalMaterial*>& ComplexPhysMats, const TArrayView<FPhysicalMaterialMaskParams>* ComplexPhysMatMasks = nullptr);
 
    ENGINE_API void ApplyMaterialToInstanceShapes_AssumesLocked(UPhysicalMaterial* SimplePhysMat, TArray<UPhysicalMaterial*>& ComplexPhysMats, const TArrayView<FPhysicalMaterialMaskParams>& ComplexPhysMatMasks);
 
    ENGINE_API void UpdatePhysicsFilterData();
 
    friend ENGINE_API FArchive& operator<<(FArchive& Ar,FBodyInstance& BodyInst);
 
    ENGINE_API FString GetBodyDebugName() const;
 
    ENGINE_API bool LineTrace(struct FHitResult& OutHit, const FVector& Start, const FVector& End, bool bTraceComplex, bool bReturnPhysicalMaterial = false) const;
 
    ENGINE_API bool Sweep(struct FHitResult& OutHit, const FVector& Start, const FVector& End, const FQuat& ShapeWorldRotation, const FCollisionShape& Shape, bool bTraceComplex) const;
 
    ENGINE_API bool OverlapTest(const FVector& Position, const FQuat& Rotation, const struct FCollisionShape& CollisionShape, FMTDResult* OutMTD = nullptr, bool bTraceComplex = false) const;
 
    ENGINE_API bool OverlapTest_AssumesLocked(const FVector& Position, const FQuat& Rotation, const struct FCollisionShape& CollisionShape, FMTDResult* OutMTD = nullptr, bool bTraceComplex = false) const;
 
    bool OverlapTestForBodies(const FVector& Position, const FQuat& Rotation, const TArray<FBodyInstance*>& Bodies, bool bTraceComplex = false) const;
    bool OverlapTestForBody(const FVector& Position, const FQuat& Rotation, FBodyInstance* Body, bool bTraceComplex = false) const;
 
    ENGINE_API bool OverlapMulti(TArray<struct FOverlapResult>& InOutOverlaps, const class UWorld* World, const FTransform* pWorldToComponent, const FVector& Pos, const FQuat& Rot,    ECollisionChannel TestChannel, const struct FComponentQueryParams& Params, const struct FCollisionResponseParams& ResponseParams, const FCollisionObjectQueryParams& ObjectQueryParams = FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
    bool OverlapMulti(TArray<struct FOverlapResult>& InOutOverlaps, const class UWorld* World, const FTransform* pWorldToComponent, const FVector& Pos, const FRotator& Rot, ECollisionChannel TestChannel, const struct FComponentQueryParams& Params, const struct FCollisionResponseParams& ResponseParams, const FCollisionObjectQueryParams& ObjectQueryParams = FCollisionObjectQueryParams::DefaultObjectQueryParam) const;
 
    ENGINE_API void AddRadialImpulseToBody(const FVector& Origin, float Radius, float Strength, uint8 Falloff, bool bVelChange = false);
 
    ENGINE_API void AddRadialForceToBody(const FVector& Origin, float Radius, float Strength, uint8 Falloff, bool bAccelChange = false, bool bAllowSubstepping = true);
 
    ENGINE_API bool GetSquaredDistanceToBody(const FVector& Point, float& OutDistanceSquared, FVector& OutPointOnBody) const;
 
    ENGINE_API float GetDistanceToBody(const FVector& Point, FVector& OutPointOnBody) const;
 
    ENGINE_API void GetBodyInstanceResourceSizeEx(FResourceSizeEx& CumulativeResourceSize) const;
 
    ENGINE_API void FixupData(class UObject* Loader);
 
    const FCollisionResponse& GetCollisionResponse() const { return CollisionResponses; }
 
    ENGINE_API void ApplyDeferredCollisionProfileName();
 
    ENGINE_API const FBodyInstance* GetOriginalBodyInstance(const FPhysicsShapeHandle& InShape) const;
 
    ENGINE_API const FTransform& GetRelativeBodyTransform(const FPhysicsShapeHandle& InShape) const;
 
    ENGINE_API bool IsShapeBoundToBody(const FPhysicsShapeHandle& Shape) const;
 
public:
    // #PHYS2 Rename, not just for physx now.
    FPhysicsUserData PhysicsUserData;
 
    struct FWeldInfo
    {
        FWeldInfo(FBodyInstance* InChildBI, const FTransform& InRelativeTM)
            : ChildBI(InChildBI)
            , RelativeTM(InRelativeTM)
        {}
 
        FBodyInstance* ChildBI;
        FTransform RelativeTM;
    };
 
    ENGINE_API const TMap<FPhysicsShapeHandle, FWeldInfo>* GetCurrentWeldInfo() const;
 
private:
 
    ENGINE_API void UpdateOneWayInteraction();
    ENGINE_API void UpdateMaxDepenetrationVelocity();
 
    ENGINE_API void InvalidateCollisionProfileName();
 
    ENGINE_API void SetWeldedBodyTransform(FBodyInstance* TheirBody, const FTransform& NewTransform);
        
    static ENGINE_API bool IsValidCollisionProfileName(FName InCollisionProfileName);
 
    template<typename AllocatorType>
    ENGINE_API bool OverlapTestForBodiesImpl(const FVector& Position, const FQuat& Rotation, const TArray<FBodyInstance*, AllocatorType>& Bodies, bool bTraceComplex = false) const;
 
    friend class UPhysicsAsset;
    friend class UCollisionProfile;
    friend class FBodyInstanceCustomization;
    friend struct FUpdateCollisionResponseHelper;
    friend class FBodySetupDetails;
    
    friend struct Chaos::Private::FInitBodiesHelperBaseInternal;
    friend class FBodyInstanceCustomizationHelper;
    friend class FFoliageTypeCustomizationHelpers;
 
public:
 
    UE_INTERNAL ENGINE_API void SerializeState(Chaos::FSerializedDataBuffer& OutSerializedState, Chaos::ESerializedDataContext DataContext);
 
    UE_INTERNAL ENGINE_API void ApplySerializedState(Chaos::FSerializedDataBufferPtr&& InSerializedState, Chaos::ESerializedDataContext DataContext);
 
private:
 
    ENGINE_API void UpdateDebugRendering();
 
    TSharedPtr<TMap<FPhysicsShapeHandle, FWeldInfo>> ShapeToBodiesMap;
 
};
 
template<>
struct TStructOpsTypeTraits<FBodyInstance> : public TStructOpsTypeTraitsBase2<FBodyInstance>
{
    enum
    {
        WithCopy = false
    };
};
 
 
#if WITH_EDITOR
 
// Helper methods for classes with body instances
struct FBodyInstanceEditorHelpers
{
    ENGINE_API static void EnsureConsistentMobilitySimulationSettingsOnPostEditChange(UPrimitiveComponent* Component, FPropertyChangedEvent& PropertyChangedEvent);
 
private:
    FBodyInstanceEditorHelpers() {}
};
#endif
 
// BodyInstance inlines
 
 
inline bool FBodyInstance::OverlapMulti(TArray<struct FOverlapResult>& InOutOverlaps, const class UWorld* World, const FTransform* pWorldToComponent, const FVector& Pos, const FRotator& Rot, ECollisionChannel TestChannel, const FComponentQueryParams& Params, const FCollisionResponseParams& ResponseParams, const FCollisionObjectQueryParams& ObjectQueryParams) const
{
    // Pass on to FQuat version
    return OverlapMulti(InOutOverlaps, World, pWorldToComponent, Pos, Rot.Quaternion(), TestChannel, Params, ResponseParams, ObjectQueryParams);
}
 
 
inline bool FBodyInstance::OverlapTestForBodies(const FVector& Position, const FQuat& Rotation, const TArray<FBodyInstance*>& Bodies, bool bTraceComplex) const
{
    return OverlapTestForBodiesImpl(Position, Rotation, Bodies, bTraceComplex);
}
 
inline bool FBodyInstance::OverlapTestForBody(const FVector& Position, const FQuat& Rotation, FBodyInstance* Body, bool bTraceComplex) const
{
    TArray<FBodyInstance*, TInlineAllocator<1>> InlineArray;
    InlineArray.Add(Body);
    return OverlapTestForBodiesImpl(Position, Rotation, InlineArray, bTraceComplex);
}
 
inline bool FBodyInstance::IsInstanceSimulatingPhysics() const
{
    return ShouldInstanceSimulatingPhysics() && IsValidBodyInstance();
}
 
#undef UE_API