ConstraintInstance.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreMinimal.h"
#include "Misc/EnumClassFlags.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Class.h"
#include "Chaos/PhysicsObject.h"
#include "EngineDefines.h"
#include "PhysicsEngine/ConstraintTypes.h"
#include "PhysicsEngine/ConstraintDrives.h"
#include "Physics/PhysicsInterfaceCore.h"
#include "ConstraintInstance.generated.h"
 
class FMaterialRenderProxy;
class FMeshElementCollector;
class FPrimitiveDrawInterface;
class UMaterialInterface;
struct FBodyInstance;
 
class FMaterialRenderProxy;
class FPrimitiveDrawInterface;
class FMaterialRenderProxy;
class UPhysicsAsset;
struct FReferenceSkeleton;
 
namespace Chaos
{
    struct FSerializedDataBuffer;
}
 
UENUM()
enum class EConstraintTransformComponentFlags : uint8
{
    None = 0,
 
    ChildPosition = 1 << 0,
    ChildRotation = 1 << 1,
    ParentPosition = 1 << 2,
    ParentRotation = 1 << 3,
 
    AllChild = ChildPosition | ChildRotation,
    AllParent = ParentPosition | ParentRotation,
    AllPosition = ChildPosition | ParentPosition,
    AllRotation = ChildRotation | ParentRotation,
    All = AllChild | AllParent
};
 
ENUM_CLASS_FLAGS(EConstraintTransformComponentFlags);
 
ENGINE_API FTransform CalculateRelativeBoneTransform(const FName ToBoneName, const FName FromBoneName, const FReferenceSkeleton& ReferenceSkeleton);
 
USTRUCT()
struct FConstraintProfileProperties
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(EditAnywhere, Category = Projection, meta = (ClampMin = "0.0"))
    float ProjectionLinearTolerance;
 
    UPROPERTY(EditAnywhere, Category = Projection, meta = (ClampMin = "0.0"))
    float ProjectionAngularTolerance;
 
    UPROPERTY(EditAnywhere, Category = Projection, meta = (ClampMin = "0.0", ClampMax = "1.0"))
    float ProjectionLinearAlpha;
 
    UPROPERTY(EditAnywhere, Category = Projection, meta = (ClampMin = "0.0", ClampMax = "1.0"))
    float ProjectionAngularAlpha;
 
    UPROPERTY(EditAnywhere, Category = Projection, meta = (ClampMin = "0.0", ClampMax = "1.0"))
    float ShockPropagationAlpha;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Linear, meta = (editcondition = "bLinearBreakable", ClampMin = "0.0"))
    float LinearBreakThreshold;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Linear, meta = (editcondition = "bLinearPlasticity", ClampMin = "0.0"))
    float LinearPlasticityThreshold;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Angular, meta = (editcondition = "bAngularBreakable", ClampMin = "0.0"))
    float AngularBreakThreshold;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Angular, meta = (editcondition = "bAngularPlasticity", ClampMin = "0.0"))
    float AngularPlasticityThreshold;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Linear, meta = (ClampMin = "0.0"))
    float ContactTransferScale;
 
    UPROPERTY(EditAnywhere, Category = Linear)
    FLinearConstraint LinearLimit;
 
    UPROPERTY(EditAnywhere, Category = Angular)
    FConeConstraint ConeLimit;
 
    UPROPERTY(EditAnywhere, Category = Angular)
    FTwistConstraint TwistLimit;
 
    // Disable collision between bodies joined by this constraint.
    UPROPERTY(EditAnywhere, Category = Constraint)
    uint8 bDisableCollision : 1;
 
    // When set, the parent body in a constraint will not be affected by the motion of the child
    UPROPERTY(EditAnywhere, Category = Constraint)
    uint8 bParentDominates : 1;
 
    UPROPERTY(EditAnywhere, Category = Projection)
    uint8 bEnableShockPropagation : 1;
 
    UPROPERTY(EditAnywhere, Category = Projection)
    uint8 bEnableProjection : 1;
 
    UPROPERTY(EditAnywhere, Category = Projection)
    uint8 bEnableMassConditioning : 1;
 
    UPROPERTY(EditAnywhere, Category = Projection)
    uint8 bUseLinearJointSolver : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Angular)
    uint8 bAngularBreakable : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Angular)
    uint8 bAngularPlasticity : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Linear)
    uint8 bLinearBreakable : 1;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Linear)
    uint8 bLinearPlasticity : 1;
 
    UPROPERTY(EditAnywhere, Category = Linear)
    FLinearDriveConstraint LinearDrive;
 
    UPROPERTY(EditAnywhere, Category = Angular)
    FAngularDriveConstraint AngularDrive;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Linear)
    TEnumAsByte<enum EConstraintPlasticityType> LinearPlasticityType;
 
    ENGINE_API FConstraintProfileProperties();
 
    ENGINE_API void Update_AssumesLocked(const FPhysicsConstraintHandle& InConstraintRef, float AverageMass, float UseScale, bool InInitialize = false) const;
 
    ENGINE_API void UpdateBreakable_AssumesLocked(const FPhysicsConstraintHandle& InConstraintRef) const;
 
    ENGINE_API void UpdatePlasticity_AssumesLocked(const FPhysicsConstraintHandle& InConstraintRef) const;
 
    ENGINE_API void UpdateContactTransferScale_AssumesLocked(const FPhysicsConstraintHandle& InConstraintRef) const;
 
    ENGINE_API void UpdateConstraintFlags_AssumesLocked(const FPhysicsConstraintHandle& InConstraintRef) const;
 
#if WITH_EDITOR
    ENGINE_API void SyncChangedConstraintProperties(struct FPropertyChangedChainEvent& PropertyChangedEvent);
#endif
};
 
USTRUCT()
struct FConstraintInstanceBase
{
    GENERATED_USTRUCT_BODY()
 
    
    ENGINE_API FConstraintInstanceBase();
    ENGINE_API void Reset();
 
 
    int32 ConstraintIndex;
 
    // Internal physics constraint representation
    FPhysicsConstraintHandle ConstraintHandle;
 
    // Scene thats using the constraint
    FPhysScene* PhysScene;
 
    FPhysScene* GetPhysicsScene() { return PhysScene; }
    const FPhysScene* GetPhysicsScene() const { return PhysScene; }
 
    ENGINE_API void SetConstraintBrokenDelegate(FOnConstraintBroken InConstraintBrokenDelegate);
 
    ENGINE_API void SetConstraintViolatedDelegate(FOnConstraintViolated InConstraintViolatedDelegate);
 
    ENGINE_API void SetPlasticDeformationDelegate(FOnPlasticDeformation InPlasticDeformationDelegate);
 
    protected:
 
        FOnConstraintBroken OnConstraintBrokenDelegate;
        FOnConstraintViolated OnConstraintViolatedDelegate;
        FOnPlasticDeformation OnPlasticDeformationDelegate;
 
        friend struct FConstraintBrokenDelegateData;
        friend struct FConstraintBrokenDelegateWrapper;
        friend struct FConstraintViolatedDelegateWrapper;
        friend struct FPlasticDeformationDelegateWrapper;
 
};
 
USTRUCT()
struct FConstraintInstance : public FConstraintInstanceBase
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY(VisibleAnywhere, Category=Constraint)
    FName JointName;
 
    
    UPROPERTY(EditAnywhere, Category=Constraint)
    FName ConstraintBone1;
 
    UPROPERTY(EditAnywhere, Category=Constraint)
    FName ConstraintBone2;
 
private:
    float LastKnownScale;
 
public:
 
    
    UPROPERTY(EditAnywhere, Category = Constraint)
    FVector Pos1;
 
    UPROPERTY(EditAnywhere, Category = Constraint)
    FVector PriAxis1;
 
    UPROPERTY(EditAnywhere, Category = Constraint)
    FVector SecAxis1;
 
    
    UPROPERTY(EditAnywhere, Category= Constraint)
    FVector Pos2;
 
    UPROPERTY(EditAnywhere, Category = Constraint)
    FVector PriAxis2;
 
    UPROPERTY(EditAnywhere, Category = Constraint)
    FVector SecAxis2;
 
    UPROPERTY(EditAnywhere, Category = Angular)
    FRotator AngularRotationOffset;
 
    UPROPERTY(EditAnywhere, Category = Linear)
    uint32 bScaleLinearLimits : 1;
 
    float AverageMass;
 
    //Constraint Data (properties easily swapped at runtime based on different constraint profiles)
    UPROPERTY(EditAnywhere, Category = Constraint)
    FConstraintProfileProperties ProfileInstance;
 
public:
    ENGINE_API void CopyProfilePropertiesFrom(const FConstraintProfileProperties& FromProperties);
 
    ENGINE_API const FPhysicsConstraintHandle& GetPhysicsConstraintRef() const;
 
    UE_INTERNAL void SerializeState(Chaos::FSerializedDataBuffer& OutSerializedState, Chaos::ESerializedDataContext DataContext);
 
    UE_INTERNAL void ApplySerializedState(Chaos::FSerializedDataBufferPtr&& InSerializedState, Chaos::ESerializedDataContext DataContext);
 
    FChaosUserData UserData;
 
    ENGINE_API FConstraintInstance();
 
    const FName& GetChildBoneName() const { return ConstraintBone1; }
 
    const FName& GetParentBoneName() const { return ConstraintBone2; }
 
    float GetLinearLimit() const
    {
        return ProfileInstance.LinearLimit.Limit;
    }
 
    void SetLinearLimits(ELinearConstraintMotion XConstraintType, ELinearConstraintMotion YConstraintType, ELinearConstraintMotion ZConstraintType, float InLinearLimitSize)
    {
        ProfileInstance.LinearLimit.XMotion = XConstraintType;
        ProfileInstance.LinearLimit.YMotion = YConstraintType;
        ProfileInstance.LinearLimit.ZMotion = ZConstraintType;
        ProfileInstance.LinearLimit.Limit = InLinearLimitSize;
        UpdateLinearLimit();
    }
 
    ELinearConstraintMotion GetLinearXMotion() const
    {
        return ProfileInstance.LinearLimit.XMotion;
    }
 
    void SetLinearXMotion(ELinearConstraintMotion XConstraintType)
    {
        const FLinearConstraint& prevLimits = ProfileInstance.LinearLimit;
        SetLinearLimits(XConstraintType, prevLimits.YMotion, prevLimits.ZMotion, prevLimits.Limit);
    }
 
    void SetLinearXLimit(ELinearConstraintMotion XConstraintType, float InLinearLimitSize)
    {
        const FLinearConstraint& prevLimits = ProfileInstance.LinearLimit;
        SetLinearLimits(XConstraintType, prevLimits.YMotion, prevLimits.ZMotion, InLinearLimitSize);
    }
 
    ELinearConstraintMotion GetLinearYMotion() const
    {
        return ProfileInstance.LinearLimit.YMotion;
    }
 
    void SetLinearYMotion(ELinearConstraintMotion YConstraintType)
    {
        const FLinearConstraint& prevLimits = ProfileInstance.LinearLimit;
        SetLinearLimits(prevLimits.XMotion, YConstraintType, prevLimits.ZMotion, prevLimits.Limit);
    }
 
    void SetLinearYLimit(ELinearConstraintMotion YConstraintType, float InLinearLimitSize)
    {
        const FLinearConstraint& prevLimits = ProfileInstance.LinearLimit;
        SetLinearLimits(prevLimits.XMotion, YConstraintType, prevLimits.ZMotion, InLinearLimitSize);
    }
 
    ELinearConstraintMotion GetLinearZMotion() const
    {
        return ProfileInstance.LinearLimit.ZMotion;
    }
 
    void SetLinearZMotion(ELinearConstraintMotion ZConstraintType)
    {
        const FLinearConstraint& prevLimits = ProfileInstance.LinearLimit;
        SetLinearLimits(prevLimits.XMotion, prevLimits.YMotion, ZConstraintType, prevLimits.Limit);
    }
 
    void SetLinearZLimit(ELinearConstraintMotion ZConstraintType, float InLinearLimitSize)
    {
        const FLinearConstraint& prevLimits = ProfileInstance.LinearLimit;
        SetLinearLimits(prevLimits.XMotion, prevLimits.YMotion, ZConstraintType, InLinearLimitSize);
    }
 
    EAngularConstraintMotion GetAngularSwing1Motion() const
    {
        return ProfileInstance.ConeLimit.Swing1Motion;
    }
 
    void SetAngularSwing1Motion(EAngularConstraintMotion MotionType)
    {
        ProfileInstance.ConeLimit.Swing1Motion = MotionType;
        UpdateAngularLimit();
    }
 
    // The current swing1 of the constraint
    ENGINE_API float GetCurrentSwing1() const;
 
    float GetAngularSwing1Limit() const
    {
        return ProfileInstance.ConeLimit.Swing1LimitDegrees;
    }
 
    void SetAngularSwing1Limit(EAngularConstraintMotion MotionType, float InSwing1LimitAngle)
    {
        ProfileInstance.ConeLimit.Swing1Motion = MotionType;
        ProfileInstance.ConeLimit.Swing1LimitDegrees = InSwing1LimitAngle;
        UpdateAngularLimit();
    }
    
    EAngularConstraintMotion GetAngularSwing2Motion() const
    {
        return ProfileInstance.ConeLimit.Swing2Motion;
    }
 
    void SetAngularSwing2Motion(EAngularConstraintMotion MotionType)
    {
        ProfileInstance.ConeLimit.Swing2Motion = MotionType;
        UpdateAngularLimit();
    }
 
    // The current swing2 of the constraint
    ENGINE_API float GetCurrentSwing2() const;
 
    float GetAngularSwing2Limit() const
    {
        return ProfileInstance.ConeLimit.Swing2LimitDegrees;
    }
 
    void SetAngularSwing2Limit(EAngularConstraintMotion MotionType, float InSwing2LimitAngle)
    {
        ProfileInstance.ConeLimit.Swing2Motion = MotionType;
        ProfileInstance.ConeLimit.Swing2LimitDegrees = InSwing2LimitAngle;
        UpdateAngularLimit();
    }
 
    EAngularConstraintMotion GetAngularTwistMotion() const
    {
        return ProfileInstance.TwistLimit.TwistMotion;
    }
 
    void SetAngularTwistMotion(EAngularConstraintMotion MotionType)
    {
        ProfileInstance.TwistLimit.TwistMotion = MotionType;
        UpdateAngularLimit();
    }
 
    // The current twist of the constraint
    ENGINE_API float GetCurrentTwist() const;
 
    float GetAngularTwistLimit() const
    {
        return ProfileInstance.TwistLimit.TwistLimitDegrees;
    }
 
    void SetAngularTwistLimit(EAngularConstraintMotion MotionType, float InTwistLimitAngle)
    {
        ProfileInstance.TwistLimit.TwistMotion = MotionType;
        ProfileInstance.TwistLimit.TwistLimitDegrees = InTwistLimitAngle;
        UpdateAngularLimit();
    }
 
    bool GetIsSoftLinearLimit() const { return ProfileInstance.LinearLimit.bSoftConstraint; }
 
    float GetSoftLinearLimitStiffness() const { return ProfileInstance.LinearLimit.Stiffness; }
 
    float GetSoftLinearLimitDamping() const { return ProfileInstance.LinearLimit.Damping; }
 
    float GetSoftLinearLimitRestitution() const { return ProfileInstance.LinearLimit.Restitution; }
 
    float GetSoftLinearLimitContactDistance() const { return ProfileInstance.LinearLimit.ContactDistance; }
 
    void SetSoftLinearLimitParams(bool bIsSoftLimit, float Stiffness, float Damping, float Restitution, float ContactDistance)
    {
        ProfileInstance.LinearLimit.bSoftConstraint = bIsSoftLimit;
        ProfileInstance.LinearLimit.Stiffness = Stiffness;
        ProfileInstance.LinearLimit.Damping = Damping;
        ProfileInstance.LinearLimit.Restitution = Restitution;
        ProfileInstance.LinearLimit.ContactDistance = ContactDistance;
        UpdateLinearLimit();
    }
 
    bool GetIsSoftTwistLimit() const { return ProfileInstance.TwistLimit.bSoftConstraint; }
 
    float GetSoftTwistLimitStiffness() const {  return ProfileInstance.TwistLimit.Stiffness; }
 
    float GetSoftTwistLimitDamping() const { return ProfileInstance.TwistLimit.Damping; }
 
    float GetSoftTwistLimitRestitution() const { return ProfileInstance.TwistLimit.Restitution; }
 
    float GetSoftTwistLimitContactDistance() const { return ProfileInstance.TwistLimit.ContactDistance; }
 
    void SetSoftTwistLimitParams(bool bIsSoftLimit, float Stiffness, float Damping, float Restitution, float ContactDistance) 
    { 
        ProfileInstance.TwistLimit.bSoftConstraint = bIsSoftLimit;
        ProfileInstance.TwistLimit.Stiffness = Stiffness;
        ProfileInstance.TwistLimit.Damping = Damping;
        ProfileInstance.TwistLimit.Restitution = Restitution;
        ProfileInstance.TwistLimit.ContactDistance = ContactDistance;
        UpdateAngularLimit();
    }
 
    bool GetIsSoftSwingLimit() const { return ProfileInstance.ConeLimit.bSoftConstraint; }
 
    float GetSoftSwingLimitStiffness() const { return ProfileInstance.ConeLimit.Stiffness; }
 
    float GetSoftSwingLimitDamping() const { return ProfileInstance.ConeLimit.Damping; }
 
    float GetSoftSwingLimitRestitution() const { return ProfileInstance.ConeLimit.Restitution; }
 
    float GetSoftSwingLimitContactDistance() const { return ProfileInstance.ConeLimit.ContactDistance; }
 
    void SetSoftSwingLimitParams(bool bIsSoftLimit, float Stiffness, float Damping, float Restitution, float ContactDistance)
    {
        ProfileInstance.ConeLimit.bSoftConstraint = bIsSoftLimit;
        ProfileInstance.ConeLimit.Stiffness = Stiffness;
        ProfileInstance.ConeLimit.Damping = Damping;
        ProfileInstance.ConeLimit.Restitution = Restitution;
        ProfileInstance.ConeLimit.ContactDistance = ContactDistance;
        UpdateAngularLimit();
    }
 
    void SetLinearBreakable(bool bInLinearBreakable, float InLinearBreakThreshold)
    {
        ProfileInstance.bLinearBreakable = bInLinearBreakable;
        ProfileInstance.LinearBreakThreshold = InLinearBreakThreshold;
        UpdateBreakable();
    }
 
    bool IsLinearBreakable() const
    {
        return ProfileInstance.bLinearBreakable;
    }
 
    float GetLinearBreakThreshold() const
    {
        return ProfileInstance.LinearBreakThreshold;
    }
 
    void SetLinearPlasticity(bool bInLinearPlasticity, float InLinearPlasticityThreshold, EConstraintPlasticityType InLinearPlasticityType)
    {
        ProfileInstance.bLinearPlasticity = bInLinearPlasticity;
        ProfileInstance.LinearPlasticityThreshold = InLinearPlasticityThreshold;
        ProfileInstance.LinearPlasticityType = InLinearPlasticityType;
        UpdatePlasticity();
    }
 
    bool HasLinearPlasticity() const
    {
        return ProfileInstance.bLinearPlasticity;
    }
 
    float GetLinearPlasticityThreshold() const
    {
        return ProfileInstance.LinearPlasticityThreshold;
    }
 
    TEnumAsByte<enum EConstraintPlasticityType> GetLinearPlasticityType() const
    {
        return ProfileInstance.LinearPlasticityType;
    }
 
    void SetContactTransferScale(float InContactTransferScale)
    {
        ProfileInstance.ContactTransferScale = InContactTransferScale;
        UpdateContactTransferScale();
    }
 
    float GetContactTransferScale() const
    {
        return ProfileInstance.ContactTransferScale;
    }
 
    void SetAngularBreakable(bool bInAngularBreakable, float InAngularBreakThreshold)
    {
        ProfileInstance.bAngularBreakable = bInAngularBreakable;
        ProfileInstance.AngularBreakThreshold = InAngularBreakThreshold;
        UpdateBreakable();
    }
 
    bool IsAngularBreakable() const
    {
        return ProfileInstance.bAngularBreakable;
    }
 
    float GetAngularBreakThreshold() const
    {
        return ProfileInstance.AngularBreakThreshold;
    }
 
    void SetAngularPlasticity(bool bInAngularPlasticity, float InAngularPlasticityThreshold)
    {
        ProfileInstance.bAngularPlasticity = bInAngularPlasticity;
        ProfileInstance.AngularPlasticityThreshold = InAngularPlasticityThreshold;
        UpdatePlasticity();
    }
 
    bool HasAngularPlasticity() const
    {
        return ProfileInstance.bAngularPlasticity;
    }
 
    float GetAngularPlasticityThreshold() const
    {
        return ProfileInstance.AngularPlasticityThreshold;
    }
 
    // @todo document
    ENGINE_API void CopyConstraintGeometryFrom(const FConstraintInstance* FromInstance);
 
    // @todo document
    ENGINE_API void CopyConstraintParamsFrom(const FConstraintInstance* FromInstance);
 
    ENGINE_API void CopyConstraintPhysicalPropertiesFrom(const FConstraintInstance* FromInstance, bool bKeepPosition, bool bKeepRotation);
 
    // Retrieve the constraint force most recently applied to maintain this constraint. Returns 0 forces if the constraint is not initialized or broken.
    ENGINE_API void GetConstraintForce(FVector& OutLinearForce, FVector& OutAngularForce);
 
    // Retrieve the status of constraint being broken.
    ENGINE_API bool IsBroken();
 
    ENGINE_API void SetLinearPositionDrive(bool bEnableXDrive, bool bEnableYDrive, bool bEnableZDrive);
 
    bool IsLinearPositionDriveXEnabled() const
    {
        return ProfileInstance.LinearDrive.XDrive.bEnablePositionDrive;
    }
 
    bool IsLinearPositionDriveYEnabled() const
    {
        return ProfileInstance.LinearDrive.YDrive.bEnablePositionDrive;
    }
 
    bool IsLinearPositionDriveZEnabled() const
    {
        return ProfileInstance.LinearDrive.ZDrive.bEnablePositionDrive;
    }
 
    bool IsLinearPositionDriveEnabled() const
    {
        return ProfileInstance.LinearDrive.IsPositionDriveEnabled();
    }
 
    ENGINE_API void SetLinearPositionTarget(const FVector& InPosTarget);
 
    const FVector& GetLinearPositionTarget()
    {
        return ProfileInstance.LinearDrive.PositionTarget;
    }
 
    ENGINE_API void SetLinearVelocityDrive(bool bEnableXDrive, bool bEnableYDrive, bool bEnableZDrive);
 
    bool IsLinearVelocityDriveXEnabled() const
    {
        return ProfileInstance.LinearDrive.XDrive.bEnableVelocityDrive;
    }
 
    bool IsLinearVelocityDriveYEnabled() const
    {
        return ProfileInstance.LinearDrive.YDrive.bEnableVelocityDrive;
    }
 
    bool IsLinearVelocityDriveZEnabled() const
    {
        return ProfileInstance.LinearDrive.ZDrive.bEnableVelocityDrive;
    }
 
    bool IsLinearVelocityDriveEnabled() const
    {
        return ProfileInstance.LinearDrive.IsVelocityDriveEnabled();
    }
 
    ENGINE_API void SetLinearVelocityTarget(const FVector& InVelTarget);
 
    const FVector& GetLinearVelocityTarget()
    {
        return ProfileInstance.LinearDrive.VelocityTarget;
    }
 
    ENGINE_API void SetLinearDriveParams(float InPositionStrength, float InVelocityStrength, float InForceLimit);
 
    ENGINE_API void SetLinearDriveParams(const FVector& InPositionStrength, const FVector& InVelocityStrength, const FVector& InForceLimit);
 
    ENGINE_API void SetLinearDriveAccelerationMode(bool bAccelerationMode);
 
    ENGINE_API void GetLinearDriveParams(float& OutPositionStrength, float& OutVelocityStrength, float& OutForceLimit);
 
    ENGINE_API void GetLinearDriveParams(FVector& OutPositionStrength, FVector& OutVelocityStrength, FVector& OutForceLimit);
 
    ENGINE_API void SetOrientationDriveTwistAndSwing(bool bInEnableTwistDrive, bool bInEnableSwingDrive);
 
    ENGINE_API void GetOrientationDriveTwistAndSwing(bool& bOutEnableTwistDrive, bool& bOutEnableSwingDrive);
 
    ENGINE_API void SetOrientationDriveSLERP(bool bInEnableSLERP);
 
    bool GetOrientationDriveSLERP()
    {
        return ProfileInstance.AngularDrive.SlerpDrive.bEnablePositionDrive;
    }
 
    bool IsAngularOrientationDriveEnabled() const
    {
        return ProfileInstance.AngularDrive.IsOrientationDriveEnabled();
    }
    
    ENGINE_API void SetAngularOrientationTarget(const FQuat& InPosTarget);
 
    const FRotator& GetAngularOrientationTarget() const
    {
        return ProfileInstance.AngularDrive.OrientationTarget;
    }
 
    ENGINE_API void SetAngularVelocityDriveTwistAndSwing(bool bInEnableTwistDrive, bool bInEnableSwingDrive);
 
    ENGINE_API void GetAngularVelocityDriveTwistAndSwing(bool& bOutEnableTwistDrive, bool& bOutEnableSwingDrive);
 
    ENGINE_API void SetAngularVelocityDriveSLERP(bool bInEnableSLERP);
 
    bool GetAngularVelocityDriveSLERP()
    {
        return ProfileInstance.AngularDrive.SlerpDrive.bEnableVelocityDrive;
    }
 
    bool IsAngularVelocityDriveEnabled() const
    {
        return ProfileInstance.AngularDrive.IsVelocityDriveEnabled();
    }
    
    ENGINE_API void SetAngularVelocityTarget(const FVector& InVelTarget);
 
    const FVector& GetAngularVelocityTarget() const
    {
        return ProfileInstance.AngularDrive.AngularVelocityTarget;
    }
 
    ENGINE_API void SetAngularDriveParams(float InSpring, float InDamping, float InForceLimit);
 
    ENGINE_API void GetAngularDriveParams(float& OutSpring, float& OutDamping, float& OutForceLimit) const;
 
    ENGINE_API void SetAngularDriveMode(EAngularDriveMode::Type DriveMode);
 
    ENGINE_API void SetAngularDriveAccelerationMode(bool bAccelerationMode);
 
    EAngularDriveMode::Type GetAngularDriveMode()
    {
        return ProfileInstance.AngularDrive.AngularDriveMode;
    }
 
    ENGINE_API void SetDriveParams(
        const FVector& InPositionStrength, const FVector& InVelocityStrength, const FVector& InForceLimit,
        const FVector& InAngularSpring, const FVector& InAngularDamping, const FVector& InTorqueLimit,
        EAngularDriveMode::Type InAngularDriveMode);
 
    ENGINE_API void UpdateLinearLimit();
 
    ENGINE_API void UpdateAngularLimit();
 
    ENGINE_API void SetAngularDOFLimitScale(float InSwing1LimitScale, float InSwing2LimitScale, float InTwistLimitScale);
 
    ENGINE_API void SetLinearLimitSize(float NewLimitSize);
 
    ENGINE_API void InitConstraint(FBodyInstance* Body1, FBodyInstance* Body2, float Scale, UObject* DebugOwner, FOnConstraintBroken InConstraintBrokenDelegate = FOnConstraintBroken(), FOnPlasticDeformation InPlasticDeformationDelegate = FOnPlasticDeformation());
    ENGINE_API void InitConstraint(Chaos::FPhysicsObject* Body1, Chaos::FPhysicsObject* Body2, float Scale, UObject* DebugOwner, FOnConstraintBroken InConstraintBrokenDelegate = FOnConstraintBroken(), FOnPlasticDeformation InPlasticDeformationDelegate = FOnPlasticDeformation());
 
    ENGINE_API void InitConstraint_AssumesLocked(const FPhysicsActorHandle& ActorRef1, const FPhysicsActorHandle& ActorRef2, float InScale, FOnConstraintBroken InConstraintBrokenDelegate = FOnConstraintBroken(), FOnPlasticDeformation InPlasticDeformationDelegate = FOnPlasticDeformation());
    ENGINE_API void InitConstraint_AssumesLocked(Chaos::FPhysicsObject* Body1, Chaos::FPhysicsObject* Body2, float InScale, FOnConstraintBroken InConstraintBrokenDelegate = FOnConstraintBroken(), FOnPlasticDeformation InPlasticDeformationDelegate = FOnPlasticDeformation());
 
    ENGINE_API void TermConstraint();
 
    ENGINE_API bool IsTerminated() const;
 
    ENGINE_API bool IsValidConstraintInstance() const;
 
    // Get component ref frame
    ENGINE_API FTransform GetRefFrame(EConstraintFrame::Type Frame) const;
 
    // Pass in reference frame in. If the constraint is currently active, this will set its active local pose. Otherwise the change will take affect in InitConstraint. 
    ENGINE_API void SetRefFrame(EConstraintFrame::Type Frame, const FTransform& RefFrame);
 
    ENGINE_API FVector GetConstraintLocation();
 
    // Pass in reference position in (maintains reference orientation). If the constraint is currently active, this will set its active local pose. Otherwise the change will take affect in InitConstraint.
    ENGINE_API void SetRefPosition(EConstraintFrame::Type Frame, const FVector& RefPosition);
 
    // Pass in reference orientation in (maintains reference position). If the constraint is currently active, this will set its active local pose. Otherwise the change will take affect in InitConstraint.
    ENGINE_API void SetRefOrientation(EConstraintFrame::Type Frame, const FVector& PriAxis, const FVector& SecAxis);
 
    bool IsCollisionDisabled() const
    {
        return ProfileInstance.bDisableCollision;
    }
 
    ENGINE_API void SetDisableCollision(bool InDisableCollision);
 
    // @todo document
    void DrawConstraint(int32 ViewIndex, class FMeshElementCollector& Collector,
        float Scale, float LimitDrawScale, bool bDrawLimits, bool bDrawSelected,
        const FTransform& Con1Frame, const FTransform& Con2Frame, bool bDrawAsPoint, bool bDrawViolatedLimits) const
    {
        DrawConstraintImp(FPDIOrCollector(ViewIndex, Collector), Scale, LimitDrawScale, bDrawLimits, bDrawSelected, Con1Frame, Con2Frame, bDrawAsPoint, bDrawViolatedLimits);
    }
 
    void DrawConstraint(FPrimitiveDrawInterface* PDI,
        float Scale, float LimitDrawScale, bool bDrawLimits, bool bDrawSelected,
        const FTransform& Con1Frame, const FTransform& Con2Frame, bool bDrawAsPoint, bool bDrawViolatedLimits) const
    {
        DrawConstraintImp(FPDIOrCollector(PDI), Scale, LimitDrawScale, bDrawLimits, bDrawSelected, Con1Frame, Con2Frame, bDrawAsPoint, bDrawViolatedLimits);
    }
 
    ENGINE_API void GetUsedMaterials(TArray<UMaterialInterface*>& Materials);
 
    ENGINE_API bool Serialize(FArchive& Ar);
#if WITH_EDITORONLY_DATA
    ENGINE_API void PostSerialize(const FArchive& Ar);
#endif
 
    bool IsProjectionEnabled() const
    {
        return ProfileInstance.bEnableProjection;
    }
 
    ENGINE_API void EnableProjection();
 
    ENGINE_API void DisableProjection();
 
    ENGINE_API void SetProjectionParams(bool bEnableProjection, float ProjectionLinearAlpha, float ProjectionAngularAlpha, float ProjectionLinearTolerance, float ProjectionAngularTolerance);
 
    ENGINE_API void GetProjectionParams(float& ProjectionLinearAlpha, float& ProjectionAngularAlpha, float& ProjectionLinearTolerance, float& ProjectionAngularTolerance) const;
 
    ENGINE_API void SetShockPropagationParams(bool bEnableShockPropagation, float ShockPropagationAlpha);
 
    ENGINE_API float GetShockPropagationAlpha() const;
 
    bool IsParentDominatesEnabled() const
    {
        return ProfileInstance.bParentDominates;
    }
 
    ENGINE_API void EnableParentDominates();
    ENGINE_API void DisableParentDominates();
    ENGINE_API void SetParentDominates(bool bParentDominates);
 
    bool IsMassConditioningEnabled() const
    {
        return ProfileInstance.bEnableMassConditioning;
    }
 
    ENGINE_API void EnableMassConditioning();
 
    ENGINE_API void DisableMassConditioning();
 
    float GetLastKnownScale() const { return LastKnownScale; }
 
    //Hacks to easily get zeroed memory for special case when we don't use GC
    static ENGINE_API void Free(FConstraintInstance * Ptr);
    static ENGINE_API FConstraintInstance * Alloc();
 
private:
 
    ENGINE_API bool CreateJoint_AssumesLocked(Chaos::FPhysicsObject* Body1, Chaos::FPhysicsObject* Body2);
    ENGINE_API void UpdateAverageMass_AssumesLocked(Chaos::FPhysicsObject* Body1, Chaos::FPhysicsObject* Body2);
 
    struct FPDIOrCollector
    {
        FPrimitiveDrawInterface* PDI;
        FMeshElementCollector* Collector;
        int32 ViewIndex;
 
        FPDIOrCollector(FPrimitiveDrawInterface* InPDI)
            : PDI(InPDI)
            , Collector(nullptr)
            , ViewIndex(INDEX_NONE)
        {
        }
 
        FPDIOrCollector(int32 InViewIndex, FMeshElementCollector& InCollector)
            : PDI(nullptr)
            , Collector(&InCollector)
            , ViewIndex(InViewIndex)
        {
        }
 
        bool HasCollector() const
        {
            return Collector != nullptr;
        }
 
        FPrimitiveDrawInterface* GetPDI() const;
 
        void DrawCylinder(const FVector& Start, const FVector& End, const float Thickness, const FMaterialRenderProxy* const MaterialProxy, const ESceneDepthPriorityGroup DepthPriority) const;
        void DrawCone(const FMatrix& ConeTransform, const float AngleWidth, const float AngleHeight, const uint32 NumSides, const FColor& PDIColor, const FMaterialRenderProxy* const MaterialRenderProxy, const ESceneDepthPriorityGroup DepthPriority) const;
        void DrawArrow(const FMatrix& ArrowTransform, const float Length, const float Thickness, const uint32 NumSides, const FColor& PDIColor, const FMaterialRenderProxy* const MaterialRenderProxy, const ESceneDepthPriorityGroup DepthPriority) const;
 
    };
 
    ENGINE_API void DrawConstraintImp(const FPDIOrCollector& PDIOrCollector,
        float Scale, float LimitDrawScale, bool bDrawLimits, bool bDrawSelected,
        const FTransform& Con1Frame, const FTransform& Con2Frame, bool bDrawAsPoint, bool bDrawViolatedLimits = false) const;
 
    ENGINE_API void UpdateBreakable();
    ENGINE_API void UpdatePlasticity();
    ENGINE_API void UpdateContactTransferScale();
    ENGINE_API void UpdateDriveTarget();
 
public:
 
#if WITH_EDITORONLY_DATA
 
    ENGINE_API FTransform CalculateDefaultParentTransform(const UPhysicsAsset* const PhysicsAsset) const;
 
    ENGINE_API FTransform CalculateDefaultChildTransform() const;
 
    ENGINE_API void SnapTransformsToDefault(const EConstraintTransformComponentFlags SnapFlags, const UPhysicsAsset* const PhysicsAsset);
#endif // WITH_EDITORONLY_DATA
 
    // Most of these properties have moved inside the ProfileInstance member (FConstraintProfileProperties struct)
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint32 bDisableCollision_DEPRECATED : 1;
    UPROPERTY()
    uint32 bEnableProjection_DEPRECATED : 1;
    UPROPERTY()
    float ProjectionLinearTolerance_DEPRECATED;
    UPROPERTY()
    float ProjectionAngularTolerance_DEPRECATED;
    UPROPERTY()
    TEnumAsByte<enum ELinearConstraintMotion> LinearXMotion_DEPRECATED;
    UPROPERTY()
    TEnumAsByte<enum ELinearConstraintMotion> LinearYMotion_DEPRECATED;
    UPROPERTY()
    TEnumAsByte<enum ELinearConstraintMotion> LinearZMotion_DEPRECATED;
    UPROPERTY()
    float LinearLimitSize_DEPRECATED;
    UPROPERTY()
    uint32 bLinearLimitSoft_DEPRECATED : 1;
    UPROPERTY()
    float LinearLimitStiffness_DEPRECATED;
    UPROPERTY()
    float LinearLimitDamping_DEPRECATED;
    UPROPERTY()
    uint32 bLinearBreakable_DEPRECATED : 1;
    UPROPERTY()
    float LinearBreakThreshold_DEPRECATED;
    UPROPERTY()
    TEnumAsByte<enum EAngularConstraintMotion> AngularSwing1Motion_DEPRECATED;
    UPROPERTY()
    TEnumAsByte<enum EAngularConstraintMotion> AngularTwistMotion_DEPRECATED;
    UPROPERTY()
    TEnumAsByte<enum EAngularConstraintMotion> AngularSwing2Motion_DEPRECATED;
    UPROPERTY()
    uint32 bSwingLimitSoft_DEPRECATED : 1;
    UPROPERTY()
    uint32 bTwistLimitSoft_DEPRECATED : 1;
    UPROPERTY()
    float Swing1LimitAngle_DEPRECATED;
    UPROPERTY()
    float TwistLimitAngle_DEPRECATED;
    UPROPERTY()
    float Swing2LimitAngle_DEPRECATED;
    UPROPERTY()
    float SwingLimitStiffness_DEPRECATED;
    UPROPERTY()
    float SwingLimitDamping_DEPRECATED;
    UPROPERTY()
    float TwistLimitStiffness_DEPRECATED;
    UPROPERTY()
    float TwistLimitDamping_DEPRECATED;
    UPROPERTY()
    uint32 bAngularBreakable_DEPRECATED : 1;
    UPROPERTY()
    float AngularBreakThreshold_DEPRECATED;
private:
    UPROPERTY()
    uint32 bLinearXPositionDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bLinearXVelocityDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bLinearYPositionDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bLinearYVelocityDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bLinearZPositionDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bLinearZVelocityDrive_DEPRECATED : 1;
public:
    UPROPERTY()
    uint32 bLinearPositionDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bLinearVelocityDrive_DEPRECATED : 1;
    UPROPERTY()
    FVector LinearPositionTarget_DEPRECATED;
    UPROPERTY()
    FVector LinearVelocityTarget_DEPRECATED;
    UPROPERTY()
    float LinearDriveSpring_DEPRECATED;
    UPROPERTY()
    float LinearDriveDamping_DEPRECATED;
    UPROPERTY()
    float LinearDriveForceLimit_DEPRECATED;
    UPROPERTY()
    uint32 bSwingPositionDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bSwingVelocityDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bTwistPositionDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bTwistVelocityDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bAngularSlerpDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bAngularOrientationDrive_DEPRECATED : 1;
private:
    UPROPERTY()
    uint32 bEnableSwingDrive_DEPRECATED : 1;
    UPROPERTY()
    uint32 bEnableTwistDrive_DEPRECATED : 1;
public:
    UPROPERTY()
    uint32 bAngularVelocityDrive_DEPRECATED : 1;
    UPROPERTY()
    FQuat AngularPositionTarget_DEPRECATED;
    UPROPERTY()
    TEnumAsByte<EAngularDriveMode::Type> AngularDriveMode_DEPRECATED;
    UPROPERTY()
    FRotator AngularOrientationTarget_DEPRECATED;
    UPROPERTY()
    FVector AngularVelocityTarget_DEPRECATED;    // Revolutions per second
    UPROPERTY()
    float AngularDriveSpring_DEPRECATED;
    UPROPERTY()
    float AngularDriveDamping_DEPRECATED;
    UPROPERTY()
    float AngularDriveForceLimit_DEPRECATED;
#endif //EDITOR_ONLY_DATA
};
 
template<>
struct TStructOpsTypeTraits<FConstraintInstance> : public TStructOpsTypeTraitsBase2<FConstraintInstance>
{
    enum 
    {
        WithSerializer = true,
#if WITH_EDITORONLY_DATA
        WithPostSerialize = true
#endif
    };
};
 
 
// Wrapping type around instance pointer to be returned per value in Blueprints
USTRUCT(BlueprintType)
struct FConstraintInstanceAccessor
{
    GENERATED_USTRUCT_BODY()
 
public:
    FConstraintInstanceAccessor()
        : Owner(nullptr)
        , Index(0)
    {}
 
    FConstraintInstanceAccessor(const TWeakObjectPtr<UObject>& Owner, uint32 Index = 0, TFunction<void(void)> InOnRelease = TFunction<void(void)>())
        : Owner(Owner)
        , Index(Index)
#if WITH_EDITOR
        , OnRelease(InOnRelease)
#endif
    {}
 
#if WITH_EDITOR
    ~FConstraintInstanceAccessor()
    {
        if (OnRelease)
        {
            OnRelease();
        }
    }
#endif
 
    ENGINE_API FConstraintInstance* Get() const;
 
    ENGINE_API void Modify();
 
private:
    UPROPERTY()
    TWeakObjectPtr<UObject> Owner;
 
    UPROPERTY()
    uint32 Index;
 
#if WITH_EDITOR
    TFunction<void(void)> OnRelease;
#endif
};