TransformConstraint.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Constraint.h"
#include "ConstraintsManager.h"
 
#include "Kismet/BlueprintFunctionLibrary.h"
 
#include "Delegates/DelegateCombinations.h"
#include "Delegates/Delegate.h"
 
#include "TransformConstraint.generated.h"
 
enum class EHandleEvent : uint8;
class UTransformableHandle;
class UTransformableComponentHandle;
class USceneComponent;
enum class EMovieSceneTransformChannel : uint32;
class UWorld;
UCLASS(Abstract, Blueprintable, MinimalAPI)
class UTickableTransformConstraint : public UTickableConstraint
{
    GENERATED_BODY()
 
public:
 
    CONSTRAINTS_API void Setup();
    
    CONSTRAINTS_API virtual void PostLoad() override;
    CONSTRAINTS_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
 
    CONSTRAINTS_API virtual uint32 GetTargetHash() const override;
    
    CONSTRAINTS_API virtual bool ReferencesObject(TWeakObjectPtr<UObject> InObject) const override;
    CONSTRAINTS_API virtual bool HasBoundObjects() const override;
    
    CONSTRAINTS_API virtual void ResolveBoundObjects(FMovieSceneSequenceID LocalSequenceID, TSharedRef<UE::MovieScene::FSharedPlaybackState> SharedPlaybackState, UObject* SubObject = nullptr) override;
 
    virtual bool IsValid(const bool bDeepCheck = true) const override;
 
    CONSTRAINTS_API virtual bool IsFullyActive() const override;
 
    CONSTRAINTS_API virtual bool NeedsCompensation() const;
 
    CONSTRAINTS_API virtual UTickableConstraint* Duplicate(UObject* NewOuter) const override;
 
    CONSTRAINTS_API virtual void Evaluate(bool bTickHandlesAlso = false) const override;
 
    CONSTRAINTS_API virtual void SetActive(const bool bIsActive) override;
    
    UPROPERTY(BlueprintReadWrite, Category = "Handle")
    TObjectPtr<UTransformableHandle> ParentTRSHandle;
    
    UPROPERTY(BlueprintReadWrite, Category = "Handle")
    TObjectPtr<UTransformableHandle> ChildTRSHandle;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Offset", meta=(EditCondition="Type!=ETransformConstraintType::LookAt"))
    bool bMaintainOffset = true;
 
    // UPROPERTY(EditAnywhere, BlueprintReadWrite,Category="Weight", meta = (Input, ClampMin = "0.0", ClampMax = "1.0", UIMin = "0.0", UIMax = "1.0"))
    //@benoit when not EditAnywhere?
    UPROPERTY(meta = (Input, ClampMin = "0.0", ClampMax = "1.0", UIMin = "0.0", UIMax = "1.0"))
    float Weight = 1.f;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Offset", meta=(EditCondition="(Type!=ETransformConstraintType::LookAt) && bMaintainOffset"))
    bool bDynamicOffset = false;
 
    CONSTRAINTS_API int64 GetType() const;
 
    CONSTRAINTS_API FTransform GetChildGlobalTransform() const;
    
    CONSTRAINTS_API FTransform GetChildLocalTransform() const;
 
    CONSTRAINTS_API FTransform GetParentGlobalTransform() const;
    
    CONSTRAINTS_API FTransform GetParentLocalTransform() const;
 
    CONSTRAINTS_API EMovieSceneTransformChannel GetChannelsToKey() const;
 
    CONSTRAINTS_API virtual void OnHandleModified(UTransformableHandle* InHandle, EHandleEvent InEvent);
 
    CONSTRAINTS_API FTickFunction* GetChildHandleTickFunction() const;
    CONSTRAINTS_API FTickFunction* GetParentHandleTickFunction() const;
 
    CONSTRAINTS_API void EnsurePrimaryDependency(const UWorld* InWorld) const;
    
protected:
 
    CONSTRAINTS_API void UnregisterDelegates() const;
    CONSTRAINTS_API void RegisterDelegates();
 
    
    virtual void ComputeOffset() PURE_VIRTUAL(ComputeOffset, return;);
    
    CONSTRAINTS_API void SetupDependencies(const UWorld* InWorld);
 
    CONSTRAINTS_API void SetChildGlobalTransform(const FTransform& InGlobal) const;
    
    CONSTRAINTS_API void SetChildLocalTransform(const FTransform& InLocal) const;
 
    UPROPERTY()
    ETransformConstraintType Type = ETransformConstraintType::Parent;
 
    CONSTRAINTS_API void OnActiveStateChanged() const;
 
    CONSTRAINTS_API FTickFunction* GetHandleTickFunction(const TObjectPtr<UTransformableHandle>& InHandle) const;
 
    void PreEvaluate() const;
 
    void PostEvaluate() const;
 
public:
    CONSTRAINTS_API virtual void InitConstraint(UWorld * InWorld) override;
    CONSTRAINTS_API virtual void TeardownConstraint(UWorld * InWorld) override;
    CONSTRAINTS_API virtual void AddedToWorld(UWorld* InWorld) override;
 
    UPROPERTY(EditAnywhere, Transient, Category="Offset", meta = (DisplayPriority=0))
    bool bUseCurrentOffset = true;
    
#if WITH_EDITOR
public:
    CONSTRAINTS_API virtual FString GetLabel() const override;
    CONSTRAINTS_API virtual FString GetFullLabel() const override;
 
    CONSTRAINTS_API virtual FString GetTypeLabel() const override;
 
    // UObject interface
    CONSTRAINTS_API virtual bool CanEditChange(const FProperty* InProperty) const override;
    CONSTRAINTS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    CONSTRAINTS_API virtual void PostEditUndo() override;
    // End of UObject interface
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FOnConstraintChanged, UTickableTransformConstraint*, const FPropertyChangedEvent&);
    static CONSTRAINTS_API FOnConstraintChanged& GetOnConstraintChanged();
 
protected:
    static CONSTRAINTS_API FOnConstraintChanged OnConstraintChanged;
#endif
};
 
UCLASS(Blueprintable, MinimalAPI)
class UTickableTranslationConstraint : public UTickableTransformConstraint
{
    GENERATED_BODY()
 
public:
    CONSTRAINTS_API UTickableTranslationConstraint();
 
    CONSTRAINTS_API virtual FConstraintTickFunction::ConstraintFunction GetFunction() const override;
 
    CONSTRAINTS_API virtual void OnHandleModified(UTransformableHandle* InHandle, EHandleEvent InEvent) override;
 
protected:
 
    struct FDynamicCache
    {
        uint32 CachedInputHash = 0;
    };
    mutable FDynamicCache Cache;
    CONSTRAINTS_API uint32 CalculateInputHash() const;
    
    CONSTRAINTS_API virtual void ComputeOffset() override;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Offset", meta=(EditCondition="bMaintainOffset"))
    FVector OffsetTranslation = FVector::ZeroVector;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Axis Filter")
    FFilterOptionPerAxis AxisFilter;
 
#if WITH_EDITOR
public:
    // UObject interface
    CONSTRAINTS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    // End of UObject interface
#endif
};
 
UCLASS(Blueprintable, MinimalAPI)
class UTickableRotationConstraint : public UTickableTransformConstraint
{
    GENERATED_BODY()
 
public:
    CONSTRAINTS_API UTickableRotationConstraint();
 
    CONSTRAINTS_API virtual FConstraintTickFunction::ConstraintFunction GetFunction() const override;
 
    CONSTRAINTS_API virtual void OnHandleModified(UTransformableHandle* InHandle, EHandleEvent InEvent) override;
 
protected:
 
    struct FDynamicCache
    {
        uint32 CachedInputHash = 0;
    };
    mutable FDynamicCache Cache;
    CONSTRAINTS_API uint32 CalculateInputHash() const;
    
    CONSTRAINTS_API virtual void ComputeOffset() override;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Offset", meta=(EditCondition="bMaintainOffset"))
    FQuat OffsetRotation = FQuat::Identity;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Axis Filter")
    FFilterOptionPerAxis AxisFilter;
 
#if WITH_EDITOR
public:
    // UObject interface
    CONSTRAINTS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    // End of UObject interface
#endif
};
 
UCLASS(Blueprintable, MinimalAPI)
class UTickableScaleConstraint : public UTickableTransformConstraint
{
    GENERATED_BODY()
 
public:
    CONSTRAINTS_API UTickableScaleConstraint();
    
    CONSTRAINTS_API virtual FConstraintTickFunction::ConstraintFunction GetFunction() const override;
 
    CONSTRAINTS_API virtual void OnHandleModified(UTransformableHandle* InHandle, EHandleEvent InEvent) override;
    
protected:
    CONSTRAINTS_API virtual void ComputeOffset() override;
 
    struct FDynamicCache
    {
        uint32 CachedInputHash = 0;
    };
    mutable FDynamicCache Cache;
    CONSTRAINTS_API uint32 CalculateInputHash() const;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Offset", meta=(EditCondition="bMaintainOffset"))
    FVector OffsetScale = FVector::OneVector;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Axis Filter")
    FFilterOptionPerAxis AxisFilter;
 
#if WITH_EDITOR
public:
    // UObject interface
    CONSTRAINTS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    // End of UObject interface
#endif
};
 
UCLASS(Blueprintable, MinimalAPI)
class UTickableParentConstraint : public UTickableTransformConstraint
{
    GENERATED_BODY()
 
public:
    CONSTRAINTS_API UTickableParentConstraint();
    
    CONSTRAINTS_API virtual FConstraintTickFunction::ConstraintFunction GetFunction() const override;
 
    bool IsScalingEnabled() const
    {
        return bScaling;
    }
    
    void SetScaling(const bool bInScale)
    {
        bScaling = bInScale;
    }
 
    static FName GetScalingPropertyName() { return GET_MEMBER_NAME_CHECKED(UTickableParentConstraint, bScaling); }
 
    CONSTRAINTS_API virtual void OnHandleModified(UTransformableHandle* InHandle, EHandleEvent InEvent) override;
 
protected:
    struct FDynamicCache
    {
        uint32 CachedInputHash = 0;
    };
    mutable FDynamicCache Cache;
    CONSTRAINTS_API uint32 CalculateInputHash() const;
 
    CONSTRAINTS_API virtual void ComputeOffset() override;
 
public:
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Offset", meta=(EditCondition="bMaintainOffset"))
    FTransform OffsetTransform = FTransform::Identity;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Properties")
    bool bScaling = false;
 
    UPROPERTY(EditDefaultsOnly, BlueprintReadWrite, Category = "Axis Filter") 
    FTransformFilter TransformFilter;
 
#if WITH_EDITOR
public:
    // UObject interface
    CONSTRAINTS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    // End of UObject interface
#endif
};
 
UCLASS(Blueprintable, MinimalAPI)
class UTickableLookAtConstraint : public UTickableTransformConstraint
{
    GENERATED_BODY()
 
public:
    CONSTRAINTS_API UTickableLookAtConstraint();
    
    CONSTRAINTS_API virtual FConstraintTickFunction::ConstraintFunction GetFunction() const override;
 
    CONSTRAINTS_API virtual bool NeedsCompensation() const override;
 
protected:
    CONSTRAINTS_API virtual void ComputeOffset() override;
 
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category="Axis")
    FVector Axis = FVector::XAxisVector;
 
private:
 
    static FQuat FindQuatBetweenNormals(const FVector& A, const FVector& B);
 
#if WITH_EDITOR
public:
    // UObject interface
    CONSTRAINTS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    // End of UObject interface
#endif
};
 
struct FTransformConstraintUtils
{
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.")
    static CONSTRAINTS_API void GetParentConstraints(
        UWorld* World,
        const AActor* InChild,
        TArray< TWeakObjectPtr<UTickableConstraint> >& OutConstraints);
 
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.")
    static CONSTRAINTS_API UTransformableComponentHandle* CreateHandleForSceneComponent(
        USceneComponent* InSceneComponent,
        const FName& InSocketName);
 
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.")
    static CONSTRAINTS_API UTickableTransformConstraint* CreateFromType(
        UWorld* InWorld,
        const ETransformConstraintType InType,
        const bool bUseDefault = false);
 
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.") 
    static CONSTRAINTS_API UTickableTransformConstraint* CreateAndAddFromObjects(
        UWorld* InWorld,
        UObject* InParent, const FName& InParentSocketName,
        UObject* InChild, const FName& InChildSocketName,
        const ETransformConstraintType InType,
        const bool bMaintainOffset = true,
        const bool bUseDefault = false);
 
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.") 
    static CONSTRAINTS_API bool AddConstraint(
        UWorld* InWorld,
        UTransformableHandle* InParentHandle,
        UTransformableHandle* InChildHandle,
        UTickableTransformConstraint* Constraint,
        const bool bMaintainOffset = true,
        const bool bUseDefault = false);
 
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.")
    static CONSTRAINTS_API FTransform ComputeRelativeTransform(
        const FTransform& InChildLocal,
        const FTransform& InChildWorld,
        const FTransform& InSpaceWorld,
        const UTickableTransformConstraint* InConstraint);
 
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.")
    static CONSTRAINTS_API TOptional<FTransform> GetRelativeTransform(UWorld* InWorld, const uint32 InHandleHash);
    static CONSTRAINTS_API TOptional<FTransform> GetConstraintsRelativeTransform(
        const TArray< TWeakObjectPtr<UTickableConstraint> >& InConstraints,
        const FTransform& InChildLocal, const FTransform& InChildWorld);
 
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.")
    static CONSTRAINTS_API int32 GetLastActiveConstraintIndex(const TArray< TWeakObjectPtr<UTickableConstraint> >& InConstraints);
 
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.")
    static CONSTRAINTS_API void GetChildrenConstraints(
        UWorld* World,
        const UTickableTransformConstraint* InConstraint,
        TArray< TWeakObjectPtr<UTickableConstraint> >& OutConstraints,
        const bool bIncludeTarget = false);
    
    UE_DEPRECATED(5.6, "This function was moved to the UE::TransformConstraintUtil namespace.")
    static CONSTRAINTS_API void UpdateTransformBasedOnConstraint(FTransform& CurrentTransform, USceneComponent* SceneComponent);
};