ConstraintDrives.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 "EngineDefines.h"
#include "ConstraintDrives.generated.h"
 
UENUM()
namespace EAngularDriveMode
{
    enum Type : int
    {
        SLERP,
        TwistAndSwing
    };
}
 
 
USTRUCT()
struct FConstraintDrive
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Constraint, meta = (ClampMin = "0.0"))
    float Stiffness;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Constraint, meta = (ClampMin = "0.0"))
    float Damping;
 
    UPROPERTY(EditAnywhere, AdvancedDisplay, Category = Constraint, meta = (ClampMin = "0.0"))
    float MaxForce;
 
    UPROPERTY(EditAnywhere, Category = Constraint)
    uint8 bEnablePositionDrive : 1;
 
    UPROPERTY(EditAnywhere, Category = Constraint)
    uint8 bEnableVelocityDrive : 1;
 
    ENGINE_API FConstraintDrive();
 
    //void UpdatePhysXDrive_AssumesLocked(physx::PxD6Joint* Joint, int DriveType, bool bDriveEnabled) const;
 
private:
    friend struct FConstraintInstance;
    friend struct FLinearDriveConstraint;
    friend struct FAngularDriveConstraint;
    //These functions may leave the struct in an invalid state unless calling UpdatePhysX* functions.
    //They are only meant as helpers for FConstraintInstance
    ENGINE_API void SetDriveParams(float InStiffness, float InDamping, float InForceLimit);
 
 
};
 
USTRUCT()
struct FLinearDriveConstraint
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category = LinearMotor)
    FVector PositionTarget;
 
    UPROPERTY(EditAnywhere, Category = LinearMotor)
    FVector VelocityTarget;
 
    UPROPERTY(EditAnywhere, Category = LinearMotor)
    FConstraintDrive XDrive;
 
    UPROPERTY(EditAnywhere, Category = LinearMotor)
    FConstraintDrive YDrive;
 
    UPROPERTY(EditAnywhere, Category = LinearMotor)
    FConstraintDrive ZDrive;
    
    UPROPERTY(EditAnywhere, Category = AngularMotor)
    bool bAccelerationMode = true;
 
#if WITH_EDITORONLY_DATA
    PRAGMA_DISABLE_DEPRECATION_WARNINGS
    UPROPERTY(config, meta = (DeprecatedProperty, DeprecationMessage = "Enable/disable of drives is done inside the individual constraint drives."))
    uint8 bEnablePositionDrive_DEPRECATED : 1;
    PRAGMA_ENABLE_DEPRECATION_WARNINGS
#endif
 
    ENGINE_API FLinearDriveConstraint();
 
    bool IsPositionDriveEnabled() const
    {
        return XDrive.bEnablePositionDrive || YDrive.bEnablePositionDrive || ZDrive.bEnablePositionDrive;
    }
 
    bool IsVelocityDriveEnabled() const
    {
        return XDrive.bEnableVelocityDrive || YDrive.bEnableVelocityDrive || ZDrive.bEnableVelocityDrive;
    }
 
    //These functions may leave the struct in an invalid state unless calling UpdatePhysX* functions.
    //They are only meant as helpers for FConstraintInstance
    ENGINE_API void SetLinearPositionDrive(bool bEnableXDrive, bool bEnableYDrive, bool bEnableZDrive);
    ENGINE_API void SetLinearVelocityDrive(bool bEnableXDrive, bool bEnableYDrive, bool bEnableZDrive);
    ENGINE_API void SetDriveParams(float InStiffness, float InDamping, float InForceLimit);
    ENGINE_API void SetDriveParams(const FVector& InStiffness, const FVector& InDamping, const FVector& InForceLimit);
    ENGINE_API void GetDriveParams(float& OutStiffness, float& OutDamping, float& OutForceLimit) const;
    ENGINE_API void GetDriveParams(FVector& OutStiffness, FVector& OutDamping, FVector& OutForceLimit) const;
    ENGINE_API void SetAccelerationMode(bool bAccelerationMode);
    ENGINE_API bool GetAccelerationMode() const;
};
 
 
USTRUCT()
struct FAngularDriveConstraint
{
    GENERATED_BODY()
 
    
    UPROPERTY(EditAnywhere, Category = LinearMotor, meta = (DisplayName="Twist"))
    FConstraintDrive TwistDrive;
 
    UPROPERTY(EditAnywhere, Category = LinearMotor, meta = (DisplayName = "Swing"))
    FConstraintDrive SwingDrive;
 
    UPROPERTY(EditAnywhere, Category = LinearMotor, meta = (DisplayName = "SLERP"))
    FConstraintDrive SlerpDrive;
    
    UPROPERTY(EditAnywhere, Category = AngularMotor)
    FRotator OrientationTarget;
 
    UPROPERTY(EditAnywhere, Category = AngularMotor)
    FVector AngularVelocityTarget;
 
    UPROPERTY(EditAnywhere, Category = AngularMotor)
    TEnumAsByte<enum EAngularDriveMode::Type> AngularDriveMode;
 
    UPROPERTY(EditAnywhere, Category = AngularMotor)
    bool bAccelerationMode = true;
 
    ENGINE_API FAngularDriveConstraint();
 
    bool IsOrientationDriveEnabled() const
    {
        if(AngularDriveMode == EAngularDriveMode::TwistAndSwing)
        {
            return TwistDrive.bEnablePositionDrive || SwingDrive.bEnablePositionDrive;
        }
        else
        {
            return SlerpDrive.bEnablePositionDrive;
        }
    }
 
    bool IsVelocityDriveEnabled() const
    {
        if (AngularDriveMode == EAngularDriveMode::TwistAndSwing)
        {
            return TwistDrive.bEnableVelocityDrive || SwingDrive.bEnableVelocityDrive;
        }
        else
        {
            return SlerpDrive.bEnableVelocityDrive;
        }
        
    }
 
    //void UpdatePhysXAngularDrive_AssumesLocked(physx::PxD6Joint* Joint) const;
 
    //These functions may leave the struct in an invalid state unless calling UpdatePhysX* functions.
    //They are only meant as helpers for FConstraintInstance
    ENGINE_API void SetOrientationDriveTwistAndSwing(bool InEnableTwistDrive, bool InEnableSwingDrive);
    ENGINE_API void SetOrientationDriveSLERP(bool InEnableSLERP);
    ENGINE_API void SetAngularVelocityDriveTwistAndSwing(bool InEnableTwistDrive, bool InEnableSwingDrive);
    ENGINE_API void SetAngularVelocityDriveSLERP(bool InEnableSLERP);
    // Sets the three drive parameters (swing, twist and slerp) to the same value 
    ENGINE_API void SetDriveParams(float InStiffness, float InDamping, float InForceLimit);
    // Sets drive parameters in the order swing, twist, slerp
    ENGINE_API void SetDriveParams(const FVector& InStiffness, const FVector& InDamping, const FVector& InForceLimit);
    // Gets just the swing drive parameters - assuming the single-float set function has previously been used
    ENGINE_API void GetDriveParams(float& OutStiffness, float& OutDamping, float& OutForceLimit) const;
    // Gets drive parameters in the order swing, twist, slerp
    ENGINE_API void GetDriveParams(FVector& OutStiffness, FVector& OutDamping, FVector& OutForceLimit) const;
    ENGINE_API void SetAngularDriveMode(EAngularDriveMode::Type DriveMode);
    ENGINE_API void SetAccelerationMode(bool bAccelerationMode);
    ENGINE_API bool GetAccelerationMode() const;
};