ConstraintsManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "UObject/Object.h"
#include "Engine/EngineBaseTypes.h"
#include "MovieSceneSequenceID.h"
#include "Misc/Guid.h"
#include "Engine/Level.h"
#include "ConstraintsManager.generated.h"
 
class UTickableConstraint;
 
namespace UE::MovieScene { struct FSharedPlaybackState; }
 
USTRUCT()
struct FConstraintTickFunction : public FTickFunction
{
    GENERATED_USTRUCT_BODY()
public:
    CONSTRAINTS_API FConstraintTickFunction();
    CONSTRAINTS_API ~FConstraintTickFunction();
 
    CONSTRAINTS_API FConstraintTickFunction(const FConstraintTickFunction& In);
    /* Begin FTickFunction Interface */
    CONSTRAINTS_API virtual void ExecuteTick(
        float DeltaTime,
        ELevelTick TickType,
        ENamedThreads::Type CurrentThread,
        const FGraphEventRef& MyCompletionGraphEvent) override;
    
    CONSTRAINTS_API virtual FString DiagnosticMessage() override;
    /* End FTickFunction Interface */
 
    using ConstraintFunction = TFunction<void()>;
    
    CONSTRAINTS_API void RegisterFunction(ConstraintFunction InConstraint);
    
    CONSTRAINTS_API void EvaluateFunctions() const;
 
    TWeakObjectPtr<UTickableConstraint> Constraint;
    
    TArray<ConstraintFunction> ConstraintFunctions;
};
 
template<>
struct TStructOpsTypeTraits<FConstraintTickFunction> : public TStructOpsTypeTraitsBase2<FConstraintTickFunction>
{
    enum
    {
        WithCopy = false
    };
};
 
UCLASS(Abstract, Blueprintable, MinimalAPI)
class UTickableConstraint : public UObject
{
    GENERATED_BODY()
    
public:
    UTickableConstraint() {}
    virtual ~UTickableConstraint() {}
 
    virtual FConstraintTickFunction::ConstraintFunction GetFunction() const PURE_VIRTUAL(GetFunction, return {};);
 
    CONSTRAINTS_API virtual void Evaluate(bool bTickHandlesAlso = false) const;
 
    virtual bool IsValid(const bool bDeepCheck = true) const PURE_VIRTUAL(IsValid, return false;);
    CONSTRAINTS_API virtual void SetActive(const bool bIsActive);
 
    CONSTRAINTS_API virtual bool IsFullyActive() const;
    virtual bool HasBoundObjects() const PURE_VIRTUAL(HasBoundObjects, return false;);
    virtual void ResolveBoundObjects(FMovieSceneSequenceID LocalSequenceID, TSharedRef<UE::MovieScene::FSharedPlaybackState> SharedPlaybackState, UObject* SubObject = nullptr)  PURE_VIRTUAL(ResolveBoundObjects);
 
    virtual uint32 GetTargetHash() const PURE_VIRTUAL(GetTargetHash, return 0;);
    virtual bool ReferencesObject(TWeakObjectPtr<UObject> InObject) const PURE_VIRTUAL(ReferencesObject, return false;);
    CONSTRAINTS_API virtual UTickableConstraint* Duplicate(UObject* NewOuter) const;
    virtual void InitConstraint(UWorld * InWorld)  PURE_VIRTUAL(UTickableConstraint::InitConstraint);
    virtual void TeardownConstraint(UWorld* InWorld)  PURE_VIRTUAL(UTickableConstraint::DeInitConstraint);
    virtual void AddedToWorld(UWorld* InWorld) PURE_VIRTUAL(UTickableConstraint::AddedToWorld);
    
    CONSTRAINTS_API FConstraintTickFunction& GetTickFunction(UWorld* InWorld);
    CONSTRAINTS_API const FConstraintTickFunction& GetTickFunction(UWorld* InWorld) const;
 
    // UObject interface
    CONSTRAINTS_API virtual void PostLoad() override;
    CONSTRAINTS_API virtual void PostDuplicate(bool bDuplicateForPIE) override;
    CONSTRAINTS_API virtual void PostInitProperties() override;
    // End of UObject interface
    
#if WITH_EDITOR
    CONSTRAINTS_API virtual FString GetLabel() const;
    CONSTRAINTS_API virtual FString GetFullLabel() const;
 
    CONSTRAINTS_API virtual FString GetTypeLabel() const;
 
    // UObject editor only interface
    CONSTRAINTS_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    CONSTRAINTS_API virtual void PostEditUndo() override;
    // End of UObject editor only interface
    
#endif
    UPROPERTY(EditAnywhere, BlueprintReadWrite, DisplayName="Active State", Category="Constraint")
    bool Active = true;
 
    UPROPERTY()
    bool bValid = false;
 
 
    FGuid ConstraintID;
 
protected:
 
    mutable TMap<TWeakObjectPtr<ULevel>,FConstraintTickFunction> ConstraintTicks;
};
 
 
UCLASS(BLUEPRINTABLE, MinimalAPI)
class UConstraintsManager : public UObject
{
    GENERATED_BODY()
public:
 
    using ConstraintPtr = TObjectPtr<UTickableConstraint>;
 
    DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_TwoParams(FOnConstraintAdded, UConstraintsManager, OnConstraintAdded_BP, UConstraintsManager*, Mananger, UTickableConstraint*, Constraint);
    DECLARE_DYNAMIC_MULTICAST_SPARSE_DELEGATE_ThreeParams(FOnConstraintRemoved, UConstraintsManager, OnConstraintRemoved_BP, UConstraintsManager*, Mananger, UTickableConstraint*, Constraint, bool, bDoNotCompensate);
 
    
    CONSTRAINTS_API UConstraintsManager();
    CONSTRAINTS_API virtual ~UConstraintsManager();
    
    //UObjects
    CONSTRAINTS_API virtual void    PostLoad() override;
 
    CONSTRAINTS_API void Init(UWorld* InWorld);
    CONSTRAINTS_API void Clear(UWorld* World);
 
    void RemoveStaticConstraint(UTickableConstraint* InConstraint) { Constraints.Remove(InConstraint); }
    bool IsStaticConstraint(UTickableConstraint* InConstraint) const { return Constraints.Contains(InConstraint); }
 
    static CONSTRAINTS_API UConstraintsManager* Find(const UWorld* InWorld);
 
private:
    static CONSTRAINTS_API UConstraintsManager* Get(UWorld* InWorld);
 
 
public:
    UPROPERTY(BlueprintAssignable, Category = Constraints, meta = (DisplayName = "OnConstraintAdded"))
    FOnConstraintAdded OnConstraintAdded_BP;
    
    UPROPERTY(BlueprintAssignable, Category = Constraints, meta = (DisplayName = "OnConstraintRemoved"))
    FOnConstraintRemoved OnConstraintRemoved_BP;
 
private:
 
 
    FDelegateHandle OnActorDestroyedHandle;
    CONSTRAINTS_API void OnActorDestroyed(AActor* InActor);
 
    CONSTRAINTS_API void RegisterDelegates(UWorld* World);
    CONSTRAINTS_API void UnregisterDelegates(UWorld* World);
 
 
    CONSTRAINTS_API void Dump() const;
 
    UPROPERTY()
    TArray< TObjectPtr<UTickableConstraint> > Constraints;
 
    friend class AConstraintsActor;
    friend class FConstraintsManagerController;
};
 
enum class EConstraintsManagerNotifyType
{
    ConstraintAdded,                    
    ConstraintRemoved,                  
    ConstraintRemovedWithCompensation,  
    ManagerUpdated,                     
    GraphUpdated                        
};
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FConstraintsManagerNotifyDelegate, EConstraintsManagerNotifyType /* type */, UObject* /* subject */);
 
class FConstraintsManagerController
{
public:
    static CONSTRAINTS_API bool bDoNotRemoveConstraint;
    static CONSTRAINTS_API FConstraintsManagerController& Get(UWorld* InWorld);
 
    template< typename TConstraint >
    TConstraint* AllocateConstraintT(const FName& InBaseName, const bool bUseDefault = false) const;
 
    CONSTRAINTS_API bool AddConstraint(UTickableConstraint* InConstraint) const;
    
    CONSTRAINTS_API UTickableConstraint* AddConstraintFromCopy(UTickableConstraint* CopyOfConstraint) const;
 
    CONSTRAINTS_API int32 GetConstraintIndex(const FGuid& InGuid) const;
 
    CONSTRAINTS_API bool RemoveConstraint(const int32 InConstraintIndex, bool bDoNotCompensate = false);
 
    CONSTRAINTS_API bool RemoveConstraint(UTickableConstraint* InConstraint, bool bDoNotCompensate = false);
    
    CONSTRAINTS_API bool UnregisterConstraint(UTickableConstraint* InConstraint);
 
    CONSTRAINTS_API bool RemoveAllConstraints(bool bDoNotCompensate = false);
 
    CONSTRAINTS_API UTickableConstraint* GetConstraint(const FGuid& InGuid) const;
 
    CONSTRAINTS_API UTickableConstraint* GetConstraint(const int32 InConstraintIndex) const;
    
    CONSTRAINTS_API const TArray< TWeakObjectPtr<UTickableConstraint> >& GetConstraintsArray() const;
 
    CONSTRAINTS_API TArray< TWeakObjectPtr<UTickableConstraint> > GetAllConstraints(const bool bSorted = false) const;
 
    CONSTRAINTS_API TArray< TWeakObjectPtr<UTickableConstraint> > GetStaticConstraints(const bool bSorted = false) const;
 
    template <typename Predicate>
    TArray< TWeakObjectPtr<UTickableConstraint> > GetConstraintsByPredicate(Predicate Pred, const bool bSorted = false) const;
 
    CONSTRAINTS_API TArray< TWeakObjectPtr<UTickableConstraint> > GetParentConstraints(
        const uint32 InTargetHash,
        const bool bSorted = false) const;
 
    CONSTRAINTS_API void SetConstraintsDependencies(
        const FName& InNameToTickBefore,
        const FName& InNameToTickAfter) const;
 
    CONSTRAINTS_API void SetConstraintsDependencies(
        const FGuid& InGuidToTickBefore,
        const FGuid& InGuidToTickAfter) const;
 
    CONSTRAINTS_API void EvaluateAllConstraints() const;
 
    UE_DEPRECATED(5.7, "Function is no longer needed.")
    CONSTRAINTS_API bool DoesExistInAnyWorld(UTickableConstraint* InConstraint);
 
    UE_DEPRECATED(5.7, "Function is no longer needed.")
    CONSTRAINTS_API void StaticConstraintCreated(UWorld* InWorld, UTickableConstraint* InConstraint);
 
    CONSTRAINTS_API void StaticConstraintCreated(UTickableConstraint* InConstraint);
 
private:
    int32 GetConstraintIndex(const FName& InConstraintName) const;
    
    CONSTRAINTS_API UConstraintsManager* GetManager();
    
    CONSTRAINTS_API UConstraintsManager* FindManager() const;
 
    CONSTRAINTS_API void DestroyManager() const;
 
    UWorld* World = nullptr;
 
public:
    DECLARE_MULTICAST_DELEGATE_OneParam(FOnSceneComponentConstrained, USceneComponent* /*InSceneComponent*/);
    CONSTRAINTS_API static FOnSceneComponentConstrained& OnSceneComponentConstrained();
 
    CONSTRAINTS_API static FConstraintsManagerNotifyDelegate& GetNotifyDelegate();
 
    CONSTRAINTS_API static void Notify(EConstraintsManagerNotifyType InNotifyType, UObject* InObject);
 
    CONSTRAINTS_API void MarkConstraintForEvaluation(UTickableConstraint* InConstraint) const;
    CONSTRAINTS_API void InvalidateEvaluationGraph() const;
    CONSTRAINTS_API void FlushEvaluationGraph() const;
};