InteractiveTool.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "Delegates/Delegate.h"
#include "HAL/Platform.h"
#include "InputBehaviorSet.h"
#include "InteractiveToolActionSet.h"
#include "Internationalization/Text.h"
#include "Misc/AssertionMacros.h"
#include "Misc/Optional.h"
#include "Shader.h"
#include "Templates/EnableIf.h"
#include "Templates/Function.h"
#include "Templates/Models.h"
#include "Templates/UniquePtr.h"
#include "Templates/UnrealTemplate.h"
#include "ToolContextInterfaces.h"
#include "UObject/Class.h"
#include "UObject/Object.h"
#include "UObject/ObjectMacros.h"
#include "UObject/ObjectPtr.h"
#include "UObject/Package.h"
#include "UObject/UObjectGlobals.h"
 
#include "InteractiveTool.generated.h"
 
class FCanvas;
class FInteractiveToolActionSet;
class FProperty;
class IToolsContextRenderAPI;
class UInputBehavior;
class UInteractiveTool;
class UInteractiveToolManager;
struct FPropertyChangedEvent;
struct FSlateBrush;
 
UENUM(BlueprintType)
enum class EToolShutdownType : uint8
{
    Completed = 0,
    Accept = 1,
    Cancel = 2
};
 
enum class EToolShutdownReason : uint8
{
    Unspecified = 0,
    SwitchTool = 1
};
 
struct FInteractiveToolInfo
{
    FText ToolDisplayName = FText::GetEmpty();
    FText ToolDisplayMessage = FText::GetEmpty();
    const FSlateBrush* ToolIcon = nullptr;
};
 
 
class FWatchablePropertySet
{
public:
    //
    // Property watching infrastructure
    //
    class FPropertyWatcher
    {
    public:
        virtual ~FPropertyWatcher() = default;
        virtual void CheckAndUpdate() = 0;
        virtual void SilentUpdate() = 0;
    };
 
    template <typename PropType>
    class TPropertyWatcher : public FPropertyWatcher
    {
    public:
        using FValueGetter = TFunction<PropType(void)>;
        using FChangedCallback = TFunction<void(const PropType&)>;
        using FNotEqualTestFunction = TFunction<bool(const PropType&, const PropType&)>;    // Define "!=" for PropType
 
        struct CInequalityComparable
        {
            template <typename T>
            auto Requires(bool& Result, const T& A, const T& B) -> decltype(
                Result = A != B
                );
        };
 
        // If PropType is CInequalityComparable, allow the two-argument constructor and default to using the type's 
        // existing != operator.
        // If PropType is not CInequalityComparable, the caller must use the three-argument constructor to provide a
        // "not equal" function.
 
        // Two-argument constructor, enabled only if PropType is CInequalityComparable
        template<typename Q = PropType, typename = typename TEnableIf<TModels_V<CInequalityComparable, Q>>::Type>
        TPropertyWatcher(const PropType& Property,
                         FChangedCallback OnChangedIn)
            : Cached(),
            GetValue([&Property]() {return Property; }),
            OnChanged(MoveTemp(OnChangedIn)),
            NotEqual([](const PropType& A, const PropType& B) { return A != B; })
        {}
 
        // Two-argument constructor, enabled only if PropType is CInequalityComparable
        template<typename Q = PropType, typename = typename TEnableIf<TModels_V<CInequalityComparable, Q>>::Type>
        TPropertyWatcher(FValueGetter GetValueIn,
                         FChangedCallback OnChangedIn)
            : Cached(),
            GetValue(MoveTemp(GetValueIn)),
            OnChanged(MoveTemp(OnChangedIn)),
            NotEqual([](const PropType& A, const PropType& B) { return A != B; })
        {}
    
        TPropertyWatcher(const PropType& Property,
                         FChangedCallback OnChangedIn,
                         FNotEqualTestFunction NotEqualIn)
            : Cached(),
            GetValue([&Property]() {return Property; }),
            OnChanged(MoveTemp(OnChangedIn)),
            NotEqual(MoveTemp(NotEqualIn))
        {}
 
        TPropertyWatcher(FValueGetter GetValueIn,
                         FChangedCallback OnChangedIn,
                         FNotEqualTestFunction NotEqualIn)
            : Cached(),
            GetValue(MoveTemp(GetValueIn)),
            OnChanged(MoveTemp(OnChangedIn)),
            NotEqual(MoveTemp(NotEqualIn))
        {}
 
        void CheckAndUpdate() final
        {
            PropType Value = GetValue();
            if ((!Cached.IsSet()) || NotEqual(Cached.GetValue(), Value))
            {
                Cached = Value;
                OnChanged(Cached.GetValue());
            }
        }
 
        void SilentUpdate() final
        {
            Cached = GetValue();
        }
 
    private:
        TOptional<PropType> Cached;
        FValueGetter GetValue;
        FChangedCallback OnChanged;
        FNotEqualTestFunction NotEqual;
    };
 
    FWatchablePropertySet() = default;
    FWatchablePropertySet(const FWatchablePropertySet&) = delete;
    FWatchablePropertySet& operator=(const FWatchablePropertySet&) = delete;
 
    void CheckAndUpdateWatched()
    {
        for ( auto& PropWatcher : PropertyWatchers )
        {
            PropWatcher->CheckAndUpdate();
        }
    }
    void SilentUpdateWatched()
    {
        for ( auto& PropWatcher : PropertyWatchers )
        {
            PropWatcher->SilentUpdate();
        }
    }
    void SilentUpdateWatcherAtIndex(int32 i)
    {
        check(i >= 0 && i < PropertyWatchers.Num());
        PropertyWatchers[i]->SilentUpdate();
    }
 
    template <typename PropType>
    int32 WatchProperty(const PropType& ValueIn,
                       typename TPropertyWatcher<PropType>::FChangedCallback OnChangedIn)
    {
        return PropertyWatchers.Emplace(MakeUnique<TPropertyWatcher<PropType>>(ValueIn, OnChangedIn));
    }
    template <typename PropType>
    int32 WatchProperty(typename TPropertyWatcher<PropType>::FValueGetter GetValueIn,
                       typename TPropertyWatcher<PropType>::FChangedCallback OnChangedIn)
    {
        return PropertyWatchers.Emplace(MakeUnique<TPropertyWatcher<PropType>>(GetValueIn, OnChangedIn));
    }
 
    template <typename PropType>
    int32 WatchProperty(const PropType& ValueIn,
                        typename TPropertyWatcher<PropType>::FChangedCallback OnChangedIn,
                        typename TPropertyWatcher<PropType>::FNotEqualTestFunction NotEqualsIn)
    {
        return PropertyWatchers.Emplace(MakeUnique<TPropertyWatcher<PropType>>(ValueIn, OnChangedIn, NotEqualsIn));
    }
    template <typename PropType>
    int32 WatchProperty(typename TPropertyWatcher<PropType>::FValueGetter GetValueIn,
                      typename TPropertyWatcher<PropType>::FChangedCallback OnChangedIn,
                      typename TPropertyWatcher<PropType>::FNotEqualTestFunction NotEqualsIn)
    {
        return PropertyWatchers.Emplace(MakeUnique<TPropertyWatcher<PropType>>(GetValueIn, OnChangedIn, NotEqualsIn));
    }
 
private:
    TArray<TUniquePtr<FPropertyWatcher>> PropertyWatchers;
};
 
DECLARE_MULTICAST_DELEGATE_TwoParams(FInteractiveToolPropertySetModifiedSignature, UObject*, FProperty*);
 
 
UCLASS(Transient, MinimalAPI)
class UInteractiveToolPropertySet : public UObject, public FWatchablePropertySet
{
    GENERATED_BODY()
 
public:
    FInteractiveToolPropertySetModifiedSignature& GetOnModified()
    {
        return OnModified;
    }
 
    bool IsPropertySetEnabled() const
    {
        return bIsPropertySetEnabled;
    }
 
    //
    // Setting saving/serialization
    //
    INTERACTIVETOOLSFRAMEWORK_API virtual void SaveProperties(UInteractiveTool* SaveFromTool, const FString& CacheIdentifier = TEXT(""));
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void RestoreProperties(UInteractiveTool* RestoreToTool, const FString& CacheIdentifier = TEXT(""));
 
protected:
    // Utility func used to implement the default Save/RestoreProperties funcs
    INTERACTIVETOOLSFRAMEWORK_API virtual void SaveRestoreProperties(UInteractiveTool* RestoreToTool, const FString& CacheIdentifier, bool bSaving);
 
    INTERACTIVETOOLSFRAMEWORK_API TObjectPtr<UInteractiveToolPropertySet> GetDynamicPropertyCache(const FString& CacheIdentifier, bool& bWasCreatedOut);
 
public:
#if WITH_EDITOR
    INTERACTIVETOOLSFRAMEWORK_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent);
#endif
 
protected:
    UPROPERTY(Transient, DuplicateTransient, NonTransactional, SkipSerialization)
    TMap<FString, TObjectPtr<UInteractiveToolPropertySet>> CachedPropertiesMap;
 
    // Controls whether a property set is shown in the UI.  Transient so that disabling a PropertySet in one tool doesn't disable it in others.
    UPROPERTY(Transient, DuplicateTransient, SkipSerialization, meta=(TransientToolProperty))
    bool bIsPropertySetEnabled = true;
 
    friend class UInteractiveTool;  // so that tool can enable/disable
 
    FInteractiveToolPropertySetModifiedSignature OnModified;
};
 
 
UCLASS(Transient, MinimalAPI)
class UInteractiveTool : public UObject, public IInputBehaviorSource
{
    GENERATED_BODY()
 
public:
    INTERACTIVETOOLSFRAMEWORK_API UInteractiveTool();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Setup();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Shutdown(EToolShutdownType ShutdownType);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Render(IToolsContextRenderAPI* RenderAPI);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void DrawHUD( FCanvas* Canvas, IToolsContextRenderAPI* RenderAPI );
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Tick(float DeltaTime) final;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveToolManager* GetToolManager() const;
 
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool HasCancel() const;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool HasAccept() const;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool CanAccept() const;
 
 
 
    //
    // Input Behaviors support
    //
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void AddInputBehavior(UInputBehavior* Behavior, void* Source = nullptr);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void RemoveInputBehaviorsBySource(void* Source);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual const UInputBehaviorSet* GetInputBehaviors() const;
 
 
    //
    // Property support
    //
 
    INTERACTIVETOOLSFRAMEWORK_API virtual TArray<UObject*> GetToolProperties(bool bEnabledOnly = true) const;
 
    DECLARE_MULTICAST_DELEGATE(OnInteractiveToolPropertySetsModified);
    OnInteractiveToolPropertySetsModified OnPropertySetsModified;
 
    DECLARE_MULTICAST_DELEGATE_OneParam(OnInteractiveToolPropertyInternallyModified, UObject*);
    OnInteractiveToolPropertyInternallyModified OnPropertyModifiedDirectlyByTool;
 
    virtual void OnPropertyModified(UObject* PropertySet, FProperty* Property)
    {
    }
 
 
protected:
 
    UPROPERTY(Transient, DuplicateTransient, NonTransactional, SkipSerialization)
    TObjectPtr<UInputBehaviorSet> InputBehaviors;
 
    UPROPERTY(Transient, DuplicateTransient, NonTransactional, SkipSerialization)
    TArray<TObjectPtr<UObject>> ToolPropertyObjects;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void AddToolPropertySource(UObject* PropertyObject);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void AddToolPropertySource(UInteractiveToolPropertySet* PropertySet);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool RemoveToolPropertySource(UInteractiveToolPropertySet* PropertySet);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool ReplaceToolPropertySource(UInteractiveToolPropertySet* CurPropertySet, UInteractiveToolPropertySet* ReplaceWith, bool bSetToEnabled = true);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool SetToolPropertySourceEnabled(UInteractiveToolPropertySet* PropertySet, bool bEnabled);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void NotifyOfPropertyChangeByTool(UInteractiveToolPropertySet* PropertySet) const;
 
    enum EAcceptWarning
    {
        NoWarning,
        EmptyForbidden
    };
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void UpdateAcceptWarnings(EAcceptWarning Warning);
 
private:
    // Tracks whether the UpdateAcceptWarnings function showed a warning the last time it was called.
    // Used to avoid clearing the tool display message in cases where it was not set by this function.
    bool bLastShowedAcceptWarning = false;
 
 
 
protected:
    virtual void OnTick(float DeltaTime){};
 
 
 
    //
    // Action support/system
    //
    // Your Tool subclass can register a set of "Actions" it can execute
    // by overloading RegisterActions(). Then external systems can use GetActionSet() to
    // find out what Actions your Tool supports, and ExecuteAction() to run those actions.
    //
public:
    INTERACTIVETOOLSFRAMEWORK_API virtual FInteractiveToolActionSet* GetActionSet();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void ExecuteAction(int32 ActionID);
 
 
protected:
    INTERACTIVETOOLSFRAMEWORK_API virtual void RegisterActions(FInteractiveToolActionSet& ActionSet);
 
 
private:
    FInteractiveToolActionSet* ToolActionSet = nullptr;
 
 
 
    //
    // Tool Information (name, icon, help text, etc)
    //
 
 
public:
    virtual FInteractiveToolInfo GetToolInfo() const
    {
        return DefaultToolInfo;
    }
 
    virtual void SetToolInfo(const FInteractiveToolInfo& NewInfo)
    {
        DefaultToolInfo = NewInfo;
    }
 
    virtual void SetToolDisplayName(const FText& NewName)
    {
        DefaultToolInfo.ToolDisplayName = NewName;
    }
 
    virtual void SetToolDisplayMessage(const FText& NewDisplayMessage)
    {
        DefaultToolInfo.ToolDisplayMessage = NewDisplayMessage;
    }
 
    virtual void SetToolIcon(const FSlateBrush* NewIcon)
    {
        DefaultToolInfo.ToolIcon = NewIcon;
    }
 
private:
    FInteractiveToolInfo DefaultToolInfo;
 
 
 
private:
 
    // InteractionMechanic needs to be able to talk to Tool internals, eg property sets, behaviors, etc
    friend class UInteractionMechanic;
};