ConstraintInstanceBlueprintLibrary.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Kismet/BlueprintFunctionLibrary.h"
#include "Engine/EngineTypes.h"
#include "PhysicsEngine/ConstraintInstance.h"
 
#include "ConstraintInstanceBlueprintLibrary.generated.h"
 
UCLASS(MinimalAPI)
class UConstraintInstanceBlueprintLibrary : public UBlueprintFunctionLibrary
{
    GENERATED_BODY()
 
public:
    //---------------------------------------------------------------------------------------------------
    //     
    // CONSTRAINT BODIES
    // 
    //---------------------------------------------------------------------------------------------------
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "rigid body name name parent child"))
        static ENGINE_API void GetAttachedBodyNames(
            UPARAM(ref) FConstraintInstanceAccessor& Accessor,
            FName& ParentBody,
            FName& ChildBody
        );
 
    //---------------------------------------------------------------------------------------------------
    //
    // CONSTRAINT BEHAVIOR 
    //
    //---------------------------------------------------------------------------------------------------
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "disable enable collision"))
    static ENGINE_API void SetDisableCollision(
            UPARAM(ref) FConstraintInstanceAccessor& Accessor,
            bool bDisableCollision
        );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "disable enable collision"))
    static ENGINE_API bool GetDisableCollsion(UPARAM(ref) FConstraintInstanceAccessor& Accessor);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "enable linear angular"))
    static ENGINE_API void SetProjectionParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bEnableProjection,
        float ProjectionLinearAlpha,
        float ProjectionAngularAlpha
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "enable linear angular"))
    static ENGINE_API void GetProjectionParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bEnableProjection,
        float& ProjectionLinearAlpha,
        float& ProjectionAngularAlpha
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void SetParentDominates(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bParentDominates
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API bool GetParentDominates(UPARAM(ref) FConstraintInstanceAccessor& Accessor);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void SetMassConditioningEnabled(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bEnableMassConditioning);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API bool GetMassConditioningEnabled(UPARAM(ref) FConstraintInstanceAccessor& Accessor);
 
 
    //---------------------------------------------------------------------------------------------------
    //
    // LINEAR LIMITS
    //
    //---------------------------------------------------------------------------------------------------
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motion free limited locked linear angular"))
    static ENGINE_API void SetLinearLimits(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        TEnumAsByte<ELinearConstraintMotion> XMotion,
        TEnumAsByte<ELinearConstraintMotion> YMotion,
        TEnumAsByte<ELinearConstraintMotion> ZMotion,
        float Limit
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motion free limited locked linear angular"))
    static ENGINE_API void GetLinearLimits(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        TEnumAsByte<ELinearConstraintMotion>& XMotion,
        TEnumAsByte<ELinearConstraintMotion>& YMotion,
        TEnumAsByte<ELinearConstraintMotion>& ZMotion,
        float& Limit
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "soft stiffness damping restitution contact distance"))
    static ENGINE_API void SetLinearSoftLimitParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bSoftLinearLimit,
        float LinearLimitStiffness,
        float LinearLimitDamping,
        float LinearLimitRestitution,
        float LinearLimitContactDistance
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "soft stiffness damping restitution contact distance"))
    static ENGINE_API void GetLinearSoftLimitParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bSoftLinearLimit,
        float& LinearLimitStiffness,
        float& LinearLimitDamping,
        float& LinearLimitRestitution,
        float& LinearLimitContactDistance
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void SetLinearBreakable(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor, 
        bool bLinearBreakable, 
        float LinearBreakThreshold
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void GetLinearBreakable(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bLinearBreakable,
        float& LinearBreakThreshold
    );
 
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
        static ENGINE_API void SetLinearPlasticity(
            UPARAM(ref) FConstraintInstanceAccessor& Accessor,
            bool bLinearPlasticity,
            float LinearPlasticityThreshold,
            TEnumAsByte<EConstraintPlasticityType> PlasticityType
        );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
        static ENGINE_API void GetLinearPlasticity(
            UPARAM(ref) FConstraintInstanceAccessor& Accessor,
            bool& bLinearPlasticity,
            float& LinearPlasticityThreshold,
            TEnumAsByte<EConstraintPlasticityType>& PlasticityType
        );
 
    //---------------------------------------------------------------------------------------------------
    //
    // Contact Transfer
    //
    //---------------------------------------------------------------------------------------------------
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
        static ENGINE_API void GetContactTransferScale(
            UPARAM(ref) FConstraintInstanceAccessor& Accessor,
            float& ContactTransferScale
        );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void SetContactTransferScale(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        float ContactTransferScale
    );
 
    //---------------------------------------------------------------------------------------------------
    //
    // ANGULAR LIMITS 
    //
    //---------------------------------------------------------------------------------------------------
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "swing twist motion free limited locked"))
    static ENGINE_API void SetAngularLimits(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor, 
        TEnumAsByte<EAngularConstraintMotion> Swing1MotionType,
        float Swing1LimitAngle, 
        TEnumAsByte<EAngularConstraintMotion> Swing2MotionType,
        float Swing2LimitAngle,
        TEnumAsByte<EAngularConstraintMotion> TwistMotionType,
        float TwistLimitAngle
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "swing twist motion free limited locked"))
    static ENGINE_API void GetAngularLimits(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        TEnumAsByte<EAngularConstraintMotion>& Swing1MotionType,
        float& Swing1LimitAngle,
        TEnumAsByte<EAngularConstraintMotion>& Swing2MotionType,
        float& Swing2LimitAngle,
        TEnumAsByte<EAngularConstraintMotion>& TwistMotionType,
        float& TwistLimitAngle
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "soft stiffness damping restitution contact distance"))
    static ENGINE_API void SetAngularSoftSwingLimitParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bSoftSwingLimit,
        float SwingLimitStiffness,
        float SwingLimitDamping,
        float SwingLimitRestitution,
        float SwingLimitContactDistance
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "soft stiffness damping restitution contact distance"))
    static ENGINE_API void GetAngularSoftSwingLimitParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bSoftSwingLimit,
        float& SwingLimitStiffness,
        float& SwingLimitDamping,
        float& SwingLimitRestitution,
        float& SwingLimitContactDistance
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "soft stiffness damping restitution contact distance"))
    static ENGINE_API void SetAngularSoftTwistLimitParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bSoftTwistLimit,
        float TwistLimitStiffness,
        float TwistLimitDamping,
        float TwistLimitRestitution,
        float TwistLimitContactDistance
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "soft stiffness damping restitution contact distance"))
        static ENGINE_API void GetAngularSoftTwistLimitParams(
            UPARAM(ref) FConstraintInstanceAccessor& Accessor,
            bool& bSoftTwistLimit,
            float& TwistLimitStiffness,
            float& TwistLimitDamping,
            float& TwistLimitRestitution,
            float& TwistLimitContactDistance
        );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void SetAngularBreakable(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bAngularBreakable, 
        float AngularBreakThreshold
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void GetAngularBreakable(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bAngularBreakable,
        float& AngularBreakThreshold
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void SetAngularPlasticity(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bAngularPlasticity, 
        float AngularPlasticityThreshold
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void GetAngularPlasticity(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bAngularPlasticity,
        float& AngularPlasticityThreshold
    );
 
    //---------------------------------------------------------------------------------------------------
    //
    // LINEAR MOTOR
    //
    //---------------------------------------------------------------------------------------------------
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor position target"))
    static ENGINE_API void SetLinearPositionDrive(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor, 
        bool bEnableDriveX, 
        bool bEnableDriveY, 
        bool bEnableDriveZ
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor position target"))
    static ENGINE_API void GetLinearPositionDrive(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bOutEnableDriveX,
        bool& bOutEnableDriveY,
        bool& bOutEnableDriveZ
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor velocity target"))
    static ENGINE_API void SetLinearVelocityDrive(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bEnableDriveX, 
        bool bEnableDriveY, 
        bool bEnableDriveZ
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor velocity target"))
    static ENGINE_API void GetLinearVelocityDrive(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bOutEnableDriveX,
        bool& bOutEnableDriveY,
        bool& bOutEnableDriveZ
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void SetLinearPositionTarget(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor, 
        const FVector& InPosTarget
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void GetLinearPositionTarget(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        FVector& OutPosTarget
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void SetLinearVelocityTarget(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor, 
        const FVector& InVelTarget
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void GetLinearVelocityTarget(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        FVector& OutVelTarget
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor position velocity target strength max force"))
    static ENGINE_API void SetLinearDriveParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        float PositionStrength, 
        float VelocityStrength, 
        float InForceLimit
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor position velocity target strength max force"))
    static ENGINE_API void GetLinearDriveParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        float& OutPositionStrength,
        float& OutVelocityStrength,
        float& OutForceLimit
    );
 
    //---------------------------------------------------------------------------------------------------
    //
    // ANGULAR MOTOR
    //
    //---------------------------------------------------------------------------------------------------
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target"))
    static ENGINE_API void SetOrientationDriveTwistAndSwing(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor, 
        bool bEnableTwistDrive, 
        bool bEnableSwingDrive
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target"))
    static ENGINE_API void GetOrientationDriveTwistAndSwing(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bOutEnableTwistDrive,
        bool& bOutEnableSwingDrive
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target"))
    static ENGINE_API void SetOrientationDriveSLERP(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor, 
        bool bEnableSLERP
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target"))
    static ENGINE_API void GetOrientationDriveSLERP(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bOutEnableSLERP
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target"))
    static ENGINE_API void SetAngularVelocityDriveTwistAndSwing(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor, 
        bool bEnableTwistDrive, 
        bool bEnableSwingDrive
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target"))
    static ENGINE_API void GetAngularVelocityDriveTwistAndSwing(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bOutEnableTwistDrive,
        bool& bOutEnableSwingDrive
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target"))
    static ENGINE_API void SetAngularVelocityDriveSLERP(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool bEnableSLERP
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target"))
    static ENGINE_API void GetAngularVelocityDriveSLERP(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        bool& bOutEnableSLERP
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void SetAngularDriveMode(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        EAngularDriveMode::Type DriveMode
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void GetAngularDriveMode(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        TEnumAsByte<EAngularDriveMode::Type>& OutDriveMode
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void SetAngularOrientationTarget(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        const FRotator& InPosTarget
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void GetAngularOrientationTarget(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        FRotator& OutPosTarget
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void SetAngularVelocityTarget(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        const FVector& InVelTarget
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor"))
    static ENGINE_API void GetAngularVelocityTarget(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        FVector& OutVelTarget
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target orientation velocity strength max force"))
    static ENGINE_API void SetAngularDriveParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        float PositionStrength, 
        float VelocityStrength, 
        float InForceLimit
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints", meta = (Keywords = "motor target orientation velocity strength max force"))
    static ENGINE_API void GetAngularDriveParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        float& OutPositionStrength,
        float& OutVelocityStrength,
        float& OutForceLimit
    );
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Constraints")
    static ENGINE_API void CopyParams(
        UPARAM(ref) FConstraintInstanceAccessor& Accessor,
        UPARAM(ref) FConstraintInstanceAccessor& SourceAccessor,
        bool bKeepPosition = true,
        bool bKeepRotation = true
    );
};