PhysicsConstraintComponent.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 "Engine/EngineTypes.h"
#include "Components/SceneComponent.h"
#include "PhysicsEngine/ConstraintInstance.h"
#include "PhysicsConstraintComponent.generated.h"
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
#include "UObject/UObjectMigrationContext.h"
#endif
 
class AActor;
class UPrimitiveComponent;
struct FBodyInstance;
 
UCLASS(ClassGroup=Physics, meta=(BlueprintSpawnableComponent), HideCategories=(Activation,"Components|Activation", Physics, Mobility), ShowCategories=("Physics|Components|PhysicsConstraint"), MinimalAPI)
class UPhysicsConstraintComponent : public USceneComponent
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY(EditInstanceOnly, Category=Constraint)
    TObjectPtr<AActor> ConstraintActor1;
 
    UPROPERTY(EditAnywhere, Category=Constraint)
    FConstrainComponentPropName ComponentName1;
 
 
    UPROPERTY(EditInstanceOnly, Category=Constraint)
    TObjectPtr<AActor> ConstraintActor2;
 
    UPROPERTY(EditAnywhere, Category=Constraint)
    FConstrainComponentPropName ComponentName2;
 
 
    TWeakObjectPtr<UPrimitiveComponent> OverrideComponent1;
 
    TWeakObjectPtr<UPrimitiveComponent> OverrideComponent2;
 
 
    UPROPERTY(instanced)
    TObjectPtr<class UPhysicsConstraintTemplate> ConstraintSetup_DEPRECATED;
 
    UPROPERTY(BlueprintAssignable)
    FConstraintBrokenSignature OnConstraintBroken;
 
    UPROPERTY(BlueprintAssignable)
    FPlasticDeformationEventSignature OnPlasticDeformation;
 
public:
    UPROPERTY(EditAnywhere, Category=ConstraintComponent, meta=(ShowOnlyInnerProperties))
    FConstraintInstance         ConstraintInstance;
 
    //Begin UObject Interface
    ENGINE_API virtual void BeginDestroy() override;
    ENGINE_API virtual void PostLoad() override;
#if WITH_EDITOR
    ENGINE_API virtual void PostEditChangeChainProperty(FPropertyChangedChainEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
#endif // WITH_EDITOR
#if WITH_EDITORONLY_DATA || UE_WITH_REMOTE_OBJECT_HANDLE
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
#endif
    //End UObject interface
 
    //Begin ActorComponent interface
#if WITH_EDITOR
    ENGINE_API virtual void CheckForErrors() override;
    ENGINE_API virtual void OnRegister() override;
#endif // WITH_EDITOR
    ENGINE_API virtual void EndPlay(const EEndPlayReason::Type EndPlayReason) override;
    ENGINE_API virtual void OnUnregister() override;
    ENGINE_API virtual void InitializeComponent() override;
    //End ActorComponent interface
 
#if UE_WITH_REMOTE_OBJECT_HANDLE
    ENGINE_API virtual void PostMigrate(const struct FUObjectMigrationContext& MigrationContext) override;
    ENGINE_API void ApplyMigratedPhysicsState(Chaos::FSerializedDataBufferPtr MigratedStateData = nullptr);
    ENGINE_API bool HasValidPhysicsState() const;
#endif
 
    UFUNCTION()
    ENGINE_API void ReInitConstraintAndApplyPhysicsState(UPrimitiveComponent* ChangedComponent, EComponentPhysicsStateChange StateChange);
 
    //~ Begin SceneComponent Interface
#if WITH_EDITOR
    ENGINE_API virtual void PostEditComponentMove(bool bFinished) override;
#endif // WITH_EDITOR
    //~ End SceneComponent Interface
 
    ENGINE_API FTransform GetBodyTransform(EConstraintFrame::Type Frame) const;
    
    ENGINE_API FBox GetBodyBox(EConstraintFrame::Type Frame) const;
 
    ENGINE_API void InitComponentConstraint();
 
    ENGINE_API void TermComponentConstraint();
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetConstrainedComponents(UPrimitiveComponent* Component1, FName BoneName1, UPrimitiveComponent* Component2, FName BoneName2);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void GetConstrainedComponents(UPrimitiveComponent*& OutComponent1, FName& OutBoneName1, UPrimitiveComponent*& OutComponent2, FName& OutBoneName2);
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void BreakConstraint();
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearPositionDrive(bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearVelocityDrive(bool bEnableDriveX, bool bEnableDriveY, bool bEnableDriveZ);
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint", meta=(DeprecatedFunction, DeprecationMessage = "Use SetOrientationDriveTwistAndSwing instead."))
    void SetAngularOrientationDrive(bool bEnableSwingDrive, bool bEnableTwistDrive)
    {
        SetOrientationDriveTwistAndSwing(bEnableTwistDrive, bEnableSwingDrive);
    }
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetOrientationDriveTwistAndSwing(bool bEnableTwistDrive, bool bEnableSwingDrive);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetOrientationDriveSLERP(bool bEnableSLERP);
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint", meta = (DeprecatedFunction, DeprecationMessage = "Use SetAngularVelocityDriveTwistAndSwing instead."))
    void SetAngularVelocityDrive(bool bEnableSwingDrive, bool bEnableTwistDrive)
    {
        SetAngularVelocityDriveTwistAndSwing(bEnableTwistDrive, bEnableSwingDrive);
    }
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularVelocityDriveTwistAndSwing(bool bEnableTwistDrive, bool bEnableSwingDrive);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularVelocityDriveSLERP(bool bEnableSLERP);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularDriveMode(EAngularDriveMode::Type DriveMode);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularDriveAccelerationMode(bool bAccelerationMode);
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearPositionTarget(const FVector& InPosTarget);
    
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearVelocityTarget(const FVector& InVelTarget);
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearDriveParams(float PositionStrength, float VelocityStrength, float InForceLimit);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearDriveAccelerationMode(bool bAccelerationMode);
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularOrientationTarget(const FRotator& InPosTarget);
 
    
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularVelocityTarget(const FVector& InVelTarget);
 
    UFUNCTION(BlueprintCallable, Category="Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularDriveParams(float PositionStrength, float VelocityStrength, float InForceLimit);
 
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearXLimit(ELinearConstraintMotion ConstraintType, float LimitSize);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearYLimit(ELinearConstraintMotion ConstraintType, float LimitSize);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearZLimit(ELinearConstraintMotion ConstraintType, float LimitSize);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularSwing1Limit(EAngularConstraintMotion MotionType, float Swing1LimitAngle);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularSwing2Limit(EAngularConstraintMotion MotionType, float Swing2LimitAngle);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularTwistLimit(EAngularConstraintMotion ConstraintType, float TwistLimitAngle);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearBreakable(bool bLinearBreakable, float LinearBreakThreshold);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetLinearPlasticity(bool bLinearPlasticity, float LinearPlasticityThreshold, EConstraintPlasticityType PlasticityType);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularBreakable(bool bAngularBreakable, float AngularBreakThreshold);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetAngularPlasticity(bool bAngularPlasticity, float AngularPlasticityThreshold);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetContactTransferScale(float ContactTransferScale);
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API float GetCurrentTwist() const;
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API float GetCurrentSwing1() const;
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API float GetCurrentSwing2() const;
 
    ENGINE_API void UpdateConstraintFrames();
 
    // 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. 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetConstraintReferenceFrame(EConstraintFrame::Type Frame, const FTransform& RefFrame);
    
    // 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.
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetConstraintReferencePosition(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.
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetConstraintReferenceOrientation(EConstraintFrame::Type Frame, const FVector& PriAxis, const FVector& SecAxis);
 
    // If true, the collision between the two rigid bodies of the constraint will be disabled.
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetDisableCollision(bool bDisableCollision);
 
    // If true, joint projection is enabled. Projection is a semi-physics post-solve correction for fixing small errors, and a teleport for fixing larger errors. See SetProjectionParams
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetProjectionEnabled(bool bProjectionEnabled);
 
    // Is projection enabled. See SetProjectionEnabled
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    bool IsProjectionEnabled() const;
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void SetProjectionParams(float ProjectionLinearAlpha, float ProjectionAngularAlpha, float ProjectionLinearTolerance, float ProjectionAngularTolerance);
 
    // Retrieve the constraint force most recently applied to maintain this constraint. Returns 0 forces if the constraint is not initialized or broken.
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API void GetConstraintForce(FVector& OutLinearForce, FVector& OutAngularForce);
 
    // Retrieve the status of constraint being broken.
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API bool IsBroken();
 
    UFUNCTION(BlueprintCallable, Category = "Physics|Components|PhysicsConstraint")
    ENGINE_API FConstraintInstanceAccessor GetConstraint();
 
#if WITH_EDITOR
    ENGINE_API void UpdateSpriteTexture();
#endif
 
protected:
 
    friend class FConstraintComponentVisualizer;
 
    ENGINE_API FBodyInstance* GetBodyInstance(EConstraintFrame::Type Frame) const;
 
    ENGINE_API Chaos::FPhysicsObject* GetPhysicsObject(EConstraintFrame::Type Frame) const;
 
    ENGINE_API FTransform GetBodyTransformInternal(EConstraintFrame::Type Frame, FName InBoneName) const;
    ENGINE_API FBox GetBodyBoxInternal(EConstraintFrame::Type Frame, FName InBoneName) const;
    ENGINE_API UPrimitiveComponent* GetComponentInternal(EConstraintFrame::Type Frame) const;
 
    ENGINE_API void OnConstraintBrokenHandler(FConstraintInstance* BrokenConstraint);
 
    ENGINE_API void OnPlasticDeformationHandler(FConstraintInstance* Constraint);
 
    ENGINE_API float GetConstraintScale() const;
 
private:
 
    bool bIsBrokenLocal;
 
    ENGINE_API void OnConstraintBrokenWrapper(int32 ConstraintIndex);
 
    ENGINE_API void OnPlasticDeformationWrapper(int32 ConstraintIndex);
#if UE_WITH_REMOTE_OBJECT_HANDLE
    bool CanReInitConstraintAndApplyPhysicsState() const;
 
    void MigratePhysicsState(FArchive& Ar);
    
    ENGINE_API bool CanSendMigratedPhysicsState(const FUObjectMigrationContext* MigrationContext, EObjectMigrationSendType ObjMigrationSendType) const;
 
    void CheckAndUnbindPhysicsStateDelegates();
#endif
};