InteractiveToolManager.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/Object.h"
#include "InteractiveTool.h"
#include "InteractiveToolBuilder.h"
#include "InputRouter.h"
#include "InteractiveToolChange.h"
#include "ToolContextInterfaces.h"
#include "InteractiveToolManager.generated.h"
 
class UInteractiveToolStorableSelection;
class UContextObjectStore;
 
UENUM()
enum class EToolSide
{
    Left = 1,
    Mouse = 1,
    Right = 2,
};
 
 
UENUM()
enum class EToolChangeTrackingMode
{
    NoChangeTracking = 1,
    UndoToExit = 2,
    FullUndoRedo = 3
};
 
UENUM()
enum class EToolManagerToolSwitchMode
{
    /* Accept if able, cancel if not (and complete if neither is possible) */
    AcceptIfAble,
    /* Cancel if able, complete if not */
    CancelIfAble,
    /* Like AcceptIfAble, except a tool can change the shutdown type by implementing IInteractiveToolShutdownQueryAPI */
    CustomizableAcceptIfAble,
    /* Like CancelIfAble, except a tool can change the shutdown type by implementing IInteractiveToolShutdownQueryAPI */
    CustomizableCancelIfAble,
};
 
 
UCLASS(Transient, MinimalAPI)
class UInteractiveToolManager : public UObject, public IToolContextTransactionProvider
{
    GENERATED_BODY()
 
protected:
    friend class UInteractiveToolsContext;      // to call Initialize/Shutdown
 
    INTERACTIVETOOLSFRAMEWORK_API UInteractiveToolManager();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Initialize(IToolsContextQueriesAPI* QueriesAPI, IToolsContextTransactionsAPI* TransactionsAPI, UInputRouter* InputRouter);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Shutdown();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void DoPostBuild(EToolSide Side, UInteractiveTool* InBuiltTool, UInteractiveToolBuilder* InToolBuilder, const FToolBuilderState& InBuilderState);
    
    INTERACTIVETOOLSFRAMEWORK_API virtual void DoPostSetup(EToolSide Side, UInteractiveTool* InInteractiveTool, UInteractiveToolBuilder* InToolBuilder, const FToolBuilderState& InBuilderState);
 
public:
 
 
    bool IsActive() const { return bIsActive; }
 
 
    //
    // Tool registration and Current Tool state
    //
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void RegisterToolType(const FString& Identifier, UInteractiveToolBuilder* Builder);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void UnregisterToolType(const FString& Identifier);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool SelectActiveToolType(EToolSide Side, const FString& Identifier);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual const FString& GetActiveToolType(EToolSide Side) const;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool CanActivateTool(EToolSide eSide, FString Identifier);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool ActivateTool(EToolSide Side);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool HasActiveTool(EToolSide Side) const;
 
    virtual EToolManagerToolSwitchMode GetToolSwitchMode() const { return ToolSwitchMode; }
 
    virtual void SetToolSwitchMode(EToolManagerToolSwitchMode ToolSwitchModeIn) { ToolSwitchMode = ToolSwitchModeIn; }
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool HasAnyActiveTool() const;
 
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveTool* GetActiveTool(EToolSide Side);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual UInteractiveToolBuilder* GetActiveToolBuilder(EToolSide Side);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FString GetActiveToolName(EToolSide Side);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool CanAcceptActiveTool(EToolSide Side);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool CanCancelActiveTool(EToolSide Side);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void DeactivateTool(EToolSide Side, EToolShutdownType ShutdownType);
 
    INTERACTIVETOOLSFRAMEWORK_API EToolShutdownType GetPreferredShutdownType(EToolSide Side,
        EToolShutdownReason ShutdownReason = EToolShutdownReason::Unspecified);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void ConfigureChangeTrackingMode(EToolChangeTrackingMode ChangeMode);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual EToolChangeTrackingMode GetChangeTrackingMode() const;
 
    //
    // Functions that Tools can call to interact with Transactions API
    //
    
    INTERACTIVETOOLSFRAMEWORK_API virtual void DisplayMessage(const FText& Message, EToolMessageLevel Level);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void PostInvalidation();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void BeginUndoTransaction(const FText& Description);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void EndUndoTransaction();
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void EmitObjectChange(UObject* TargetObject, TUniquePtr<FToolCommandChange> Change, const FText& Description );
 
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool RequestSelectionChange(const FSelectedObjectsChangeList& SelectionChange);
 
    //
    // State control  (@todo: have the Context call these? not safe for anyone to call)
    //
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Tick(float DeltaTime);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Render(IToolsContextRenderAPI* RenderAPI);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void DrawHUD(FCanvas* Canvas, IToolsContextRenderAPI* RenderAPI);
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool PostActiveToolShutdownRequest(
        UInteractiveTool* Tool, 
        EToolShutdownType ShutdownType,
        bool bShowUnexpectedShutdownMessage = false,
        const FText& UnexpectedShutdownMessage = FText() );
 
    DECLARE_DELEGATE_RetVal_ThreeParams(bool, FOnToolShutdownRequest, UInteractiveToolManager*, UInteractiveTool*, EToolShutdownType);
    FOnToolShutdownRequest OnToolShutdownRequest;
    
    DECLARE_MULTICAST_DELEGATE_FourParams(FOnToolUnexpectedShutdownMessage, UInteractiveToolManager*, UInteractiveTool*, const FText& Message, bool bWasDuringToolSetup);
 
    FOnToolUnexpectedShutdownMessage OnToolUnexpectedShutdownMessage;
    
 
    //
    // access to APIs, etc
    //
    
    virtual IToolsContextQueriesAPI* GetContextQueriesAPI() { return QueriesAPI; }
 
    virtual IToolsContextTransactionsAPI* GetContextTransactionsAPI() final { return TransactionsAPI; }
 
    INTERACTIVETOOLSFRAMEWORK_API UInteractiveGizmoManager* GetPairedGizmoManager();
 
    INTERACTIVETOOLSFRAMEWORK_API UContextObjectStore* GetContextObjectStore() const;
 
public:
    UPROPERTY()
    TObjectPtr<UInteractiveTool> ActiveLeftTool;
 
    UPROPERTY()
    TObjectPtr<UInteractiveTool> ActiveRightTool;
 
 
 
 
public:
    DECLARE_MULTICAST_DELEGATE_TwoParams(FToolManagerToolStartedSignature, UInteractiveToolManager*, UInteractiveTool*);
    FToolManagerToolStartedSignature OnToolStarted;
 
    DECLARE_MULTICAST_DELEGATE_FiveParams(FToolManagerToolPostBuildSignature, UInteractiveToolManager*, EToolSide, UInteractiveTool*, UInteractiveToolBuilder*, const FToolBuilderState&);
    FToolManagerToolPostBuildSignature OnToolPostBuild;
 
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FToolManagerToolPostSetupSignature, UInteractiveToolManager*, EToolSide, UInteractiveTool*);
    FToolManagerToolPostSetupSignature OnToolPostSetup;
 
    DECLARE_MULTICAST_DELEGATE_TwoParams(FToolManagerToolEndedSignature, UInteractiveToolManager*, UInteractiveTool*);
    FToolManagerToolEndedSignature OnToolEnded;
 
    // Variant of OnToolEnded that also reports the EToolShutdownType
    DECLARE_MULTICAST_DELEGATE_ThreeParams(FToolManagerToolCancelledSignature, UInteractiveToolManager*, UInteractiveTool*, EToolShutdownType);
    FToolManagerToolCancelledSignature OnToolEndedWithStatus;
 
 
protected:
    IToolsContextQueriesAPI* QueriesAPI;
    IToolsContextTransactionsAPI* TransactionsAPI;
 
    UInputRouter* InputRouter;
 
    bool bIsActive = false;
 
    // This bool is for handling the case where a Tool posts a shutdown request during it's Setup() call.
    // In that case we will terminate the Tool immediately
    bool bInToolSetup = false;
    bool bToolRequestedTerminationDuringSetup = false;
 
 
    UPROPERTY()
    TMap<FString, TObjectPtr<UInteractiveToolBuilder>> ToolBuilders;
 
    FString ActiveLeftBuilderName;
    UInteractiveToolBuilder* ActiveLeftBuilder;
    FString ActiveRightBuilderName;
    UInteractiveToolBuilder* ActiveRightBuilder;
 
    EToolChangeTrackingMode ActiveToolChangeTrackingMode;
    EToolManagerToolSwitchMode ToolSwitchMode = EToolManagerToolSwitchMode::CustomizableAcceptIfAble;
 
    FString ActiveLeftToolName;
    FString ActiveRightToolName;
    bool bInToolShutdown = false;
 
    UE_DEPRECATED(5.5, "bActiveToolMadeSelectionStoreRequest is no longer used.")
    bool bActiveToolMadeSelectionStoreRequest = false;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool ActivateToolInternal(EToolSide Side);
    INTERACTIVETOOLSFRAMEWORK_API virtual void DeactivateToolInternal(EToolSide Side, EToolShutdownType ShutdownType);
 
    friend class FBeginToolChange;
    friend class FActivateToolChange;
};
 
 
 
 
class FBeginToolChange : public FToolCommandChange
{
public:
    INTERACTIVETOOLSFRAMEWORK_API virtual void Apply(UObject* Object) override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Revert(UObject* Object) override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool HasExpired(UObject* Object) const override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FString ToString() const override;
};
 
class FActivateToolChange : public FToolCommandChange
{
public:
    EToolSide Side;
    FString ToolType;
    bool bIsDeactivate = false;
    EToolShutdownType ShutdownType;
 
    FActivateToolChange(EToolSide SideIn, FString ToolTypeIn)
        : Side(SideIn), ToolType(ToolTypeIn), bIsDeactivate(false) {}
    FActivateToolChange(EToolSide SideIn, FString ToolTypeIn, EToolShutdownType ShutdownTypeIn)
        : Side(SideIn), ToolType(ToolTypeIn), bIsDeactivate(true), ShutdownType(ShutdownTypeIn) {}
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Apply(UObject* Object) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual void Revert(UObject* Object) override;
    INTERACTIVETOOLSFRAMEWORK_API virtual bool HasExpired(UObject* Object) const override;
    INTERACTIVETOOLSFRAMEWORK_API virtual FString ToString() const override;
};
 
 
 
 
 
class FToolChangeWrapperChange : public FToolCommandChange
{
public:
    TWeakObjectPtr<UInteractiveToolManager> ToolManager;
    TWeakObjectPtr<UInteractiveTool> ActiveTool;
    TUniquePtr<FToolCommandChange> ToolChange;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Apply(UObject* Object) override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual void Revert(UObject* Object) override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual bool HasExpired(UObject* Object) const override;
 
    INTERACTIVETOOLSFRAMEWORK_API virtual FString ToString() const override;
};