312 lines
12 KiB
C++
312 lines
12 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#pragma once
|
|
|
|
#include "Tools/Modes.h"
|
|
#include "InputCoreTypes.h"
|
|
#include "UnrealWidget.h"
|
|
#include "EditorComponents.h"
|
|
#include "Templates/SharedPointer.h"
|
|
#include "UObject/Object.h"
|
|
#include "InputState.h"
|
|
#include "Math/Ray.h"
|
|
#include "UObject/SoftObjectPtr.h"
|
|
#include "Engine/EngineBaseTypes.h"
|
|
|
|
#include "UEdMode.generated.h"
|
|
|
|
class FCanvas;
|
|
class FEditorModeTools;
|
|
class FEditorViewportClient;
|
|
class FModeToolkit;
|
|
class FPrimitiveDrawInterface;
|
|
class FSceneView;
|
|
class FViewport;
|
|
class UTexture2D;
|
|
class UEdModeInteractiveToolsContext;
|
|
class UInteractiveToolManager;
|
|
class UInteractiveTool;
|
|
|
|
class FEditorViewportClient;
|
|
class HHitProxy;
|
|
struct FViewportClick;
|
|
class FEditorViewportClient;
|
|
class UInteractiveToolBuilder;
|
|
class FUICommandInfo;
|
|
class FUICommandList;
|
|
class FEdMode;
|
|
|
|
/** Outcomes when determining whether it's possible to perform an action on the edit modes*/
|
|
namespace EEditAction
|
|
{
|
|
enum Type
|
|
{
|
|
/** Can't process this action */
|
|
Skip = 0,
|
|
/** Can process this action */
|
|
Process,
|
|
/** Stop evaluating other modes (early out) */
|
|
Halt,
|
|
};
|
|
}; // namespace EEditAction
|
|
|
|
/**
|
|
* Base class for all editor modes.
|
|
*/
|
|
UCLASS(Abstract)
|
|
class UNREALED_API UEdMode: public UObject
|
|
, public FEditorCommonDrawHelper
|
|
{
|
|
GENERATED_BODY()
|
|
|
|
public:
|
|
/** Friends so it can access mode's internals on construction */
|
|
friend class UAssetEditorSubsystem;
|
|
|
|
UEdMode();
|
|
|
|
virtual void Initialize();
|
|
|
|
virtual bool MouseEnter(FEditorViewportClient* ViewportClient, FViewport* Viewport, int32 x, int32 y);
|
|
|
|
virtual bool MouseLeave(FEditorViewportClient* ViewportClient, FViewport* Viewport);
|
|
|
|
virtual bool MouseMove(FEditorViewportClient* ViewportClient, FViewport* Viewport, int32 x, int32 y);
|
|
|
|
virtual bool ReceivedFocus(FEditorViewportClient* ViewportClient, FViewport* Viewport);
|
|
|
|
virtual bool LostFocus(FEditorViewportClient* ViewportClient, FViewport* Viewport);
|
|
|
|
/**
|
|
* Called when the mouse is moved while a window input capture is in effect
|
|
*
|
|
* @param InViewportClient Level editor viewport client that captured the mouse input
|
|
* @param InViewport Viewport that captured the mouse input
|
|
* @param InMouseX New mouse cursor X coordinate
|
|
* @param InMouseY New mouse cursor Y coordinate
|
|
*
|
|
* @return true if input was handled
|
|
*/
|
|
virtual bool CapturedMouseMove(FEditorViewportClient* InViewportClient, FViewport* InViewport, int32 InMouseX, int32 InMouseY);
|
|
|
|
/** Process all captured mouse moves that occurred during the current frame */
|
|
virtual bool ProcessCapturedMouseMoves(FEditorViewportClient* InViewportClient, FViewport* InViewport, const TArrayView<FIntPoint>& CapturedMouseMoves) { return false; }
|
|
|
|
virtual bool InputKey(FEditorViewportClient* ViewportClient, FViewport* Viewport, FKey Key, EInputEvent Event);
|
|
virtual bool InputAxis(FEditorViewportClient* InViewportClient, FViewport* Viewport, int32 ControllerId, FKey Key, float Delta, float DeltaTime);
|
|
virtual bool InputDelta(FEditorViewportClient* InViewportClient, FViewport* InViewport, FVector& InDrag, FRotator& InRot, FVector& InScale);
|
|
virtual bool StartTracking(FEditorViewportClient* InViewportClient, FViewport* InViewport);
|
|
virtual bool EndTracking(FEditorViewportClient* InViewportClient, FViewport* InViewport);
|
|
// Added for handling EDIT Command...
|
|
virtual EEditAction::Type GetActionEditDuplicate() { return EEditAction::Skip; }
|
|
virtual EEditAction::Type GetActionEditDelete() { return EEditAction::Skip; }
|
|
virtual EEditAction::Type GetActionEditCut() { return EEditAction::Skip; }
|
|
virtual EEditAction::Type GetActionEditCopy() { return EEditAction::Skip; }
|
|
virtual EEditAction::Type GetActionEditPaste() { return EEditAction::Skip; }
|
|
virtual bool ProcessEditDuplicate() { return false; }
|
|
virtual bool ProcessEditDelete();
|
|
virtual bool ProcessEditCut() { return false; }
|
|
virtual bool ProcessEditCopy() { return false; }
|
|
virtual bool ProcessEditPaste() { return false; }
|
|
|
|
virtual void Tick(FEditorViewportClient* ViewportClient, float DeltaTime);
|
|
|
|
virtual bool IsCompatibleWith(FEditorModeID OtherModeID) const { return false; }
|
|
virtual void ActorMoveNotify() {}
|
|
virtual void ActorsDuplicatedNotify(TArray<AActor*>& PreDuplicateSelection, TArray<AActor*>& PostDuplicateSelection, bool bOffsetLocations) {}
|
|
virtual void ActorSelectionChangeNotify() {};
|
|
virtual void ActorPropChangeNotify() {}
|
|
virtual void MapChangeNotify() {}
|
|
|
|
/** If the Edmode is handling its own mouse deltas, it can disable the MouseDeltaTacker */
|
|
virtual bool DisallowMouseDeltaTracking() const { return false; }
|
|
|
|
/**
|
|
* Lets each mode/tool specify a pivot point around which the camera should orbit
|
|
* @param OutPivot The custom pivot point returned by the mode/tool
|
|
* @return true if a custom pivot point was specified, false otherwise.
|
|
*/
|
|
virtual bool GetPivotForOrbit(FVector& OutPivot) const { return false; }
|
|
|
|
/**
|
|
* Get a cursor to override the default with, if any.
|
|
* @return true if the cursor was overridden.
|
|
*/
|
|
virtual bool GetCursor(EMouseCursor::Type& OutCursor) const { return false; }
|
|
|
|
/** Get override cursor visibility settings */
|
|
virtual bool GetOverrideCursorVisibility(bool& bWantsOverride, bool& bHardwareCursorVisible, bool bSoftwareCursorVisible) const { return false; }
|
|
|
|
/** Called before mouse movement is converted to drag/rot */
|
|
virtual bool PreConvertMouseMovement(FEditorViewportClient* InViewportClient) { return false; }
|
|
|
|
/** Called after mouse movement is converted to drag/rot */
|
|
virtual bool PostConvertMouseMovement(FEditorViewportClient* InViewportClient) { return false; }
|
|
|
|
virtual bool ShouldDrawBrushWireframe(AActor* InActor) const { return true; }
|
|
|
|
/** If Rotation Snap should be enabled for this mode*/
|
|
virtual bool IsSnapRotationEnabled();
|
|
|
|
/** If this mode should override the snap rotation
|
|
* @param Rotation The Rotation Override
|
|
*
|
|
* @return True if you have overridden the value
|
|
*/
|
|
virtual bool SnapRotatorToGridOverride(FRotator& Rotation) { return false; };
|
|
|
|
virtual void UpdateInternalData() {}
|
|
|
|
virtual void Enter();
|
|
|
|
virtual void RegisterTool(TSharedPtr<FUICommandInfo> UICommand, FString ToolIdentifier, UInteractiveToolBuilder* Builder);
|
|
|
|
virtual void Exit();
|
|
virtual UTexture2D* GetVertexTexture();
|
|
|
|
virtual void PostUndo() {}
|
|
|
|
/**
|
|
* Check to see if this UEdMode wants to disallow AutoSave
|
|
* @return true if AutoSave can be applied right now
|
|
*/
|
|
virtual bool CanAutoSave() const { return true; }
|
|
|
|
virtual void SelectNone();
|
|
virtual void SelectionChanged() {}
|
|
|
|
virtual bool HandleClick(FEditorViewportClient* InViewportClient, HHitProxy* HitProxy, const FViewportClick& Click);
|
|
|
|
/**
|
|
* Allows an editor mode to override the bounding box used to focus the viewport on a selection
|
|
*
|
|
* @param Actor The selected actor that is being considered for focus
|
|
* @param PrimitiveComponent The component in the actor being considered for focus
|
|
* @param InOutBox The box that should be computed for the actor and component
|
|
* @return bool true if the mode overrides the box and populated InOutBox, false if it did not populate InOutBox
|
|
*/
|
|
virtual bool ComputeBoundingBoxForViewportFocus(AActor* Actor, UPrimitiveComponent* PrimitiveComponent, FBox& InOutBox) const { return false; }
|
|
|
|
/** Handling SelectActor */
|
|
virtual bool Select(AActor* InActor, bool bInSelected) { return 0; }
|
|
|
|
/** Check to see if an actor can be selected in this mode - no side effects */
|
|
virtual bool IsSelectionAllowed(AActor* InActor, bool bInSelection) const { return true; }
|
|
|
|
/** @return True if this mode allows the viewport to use a drag tool */
|
|
virtual bool AllowsViewportDragTool() const { return true; }
|
|
|
|
/** Returns the editor mode identifier. */
|
|
FEditorModeID GetID() const { return Info.ID; }
|
|
|
|
/** Returns the editor mode information. */
|
|
const FEditorModeInfo& GetModeInfo() const { return Info; }
|
|
|
|
/** @name Rendering */
|
|
//@{
|
|
/** Draws translucent polygons on brushes and volumes. */
|
|
virtual void Render(const FSceneView* View, FViewport* Viewport, FPrimitiveDrawInterface* PDI);
|
|
// void DrawGridSection(int32 ViewportLocX,int32 ViewportGridY,FVector* A,FVector* B,float* AX,float* BX,int32 Axis,int32 AlphaCase,FSceneView* View,FPrimitiveDrawInterface* PDI);
|
|
|
|
/** Overlays the editor hud (brushes, drag tools, static mesh vertices, etc*. */
|
|
virtual void DrawHUD(FEditorViewportClient* ViewportClient, FViewport* Viewport, const FSceneView* View, FCanvas* Canvas);
|
|
//@}
|
|
|
|
/**
|
|
* Called when the mode wants to draw brackets around selected objects
|
|
*/
|
|
virtual void DrawBrackets(FEditorViewportClient* ViewportClient, FViewport* Viewport, const FSceneView* View, FCanvas* Canvas);
|
|
|
|
/** True if this mode uses a toolkit mode (eventually they all should) */
|
|
virtual bool UsesToolkits() const;
|
|
|
|
/** Gets the toolkit created by this mode */
|
|
TSharedPtr<FModeToolkit> GetToolkit() { return Toolkit; }
|
|
|
|
/** Returns the world this toolkit is editing */
|
|
UWorld* GetWorld() const;
|
|
|
|
/** Returns the owning mode manager for this mode */
|
|
FEditorModeTools* GetModeManager() const;
|
|
|
|
/**
|
|
* For use by the EditorModeTools class to get the legacy FEdMode type from a legacy FEdMode wrapper
|
|
* You should not need to override this function in your UEdMode implementation.
|
|
*/
|
|
virtual FEdMode* AsLegacyMode() { return nullptr; }
|
|
|
|
public:
|
|
/** Request that this mode be deleted at the next convenient opportunity (FEditorModeTools::Tick) */
|
|
void RequestDeletion() { bPendingDeletion = true; }
|
|
|
|
/** returns true if this mode is to be deleted at the next convenient opportunity (FEditorModeTools::Tick) */
|
|
bool IsPendingDeletion() const { return bPendingDeletion; }
|
|
|
|
protected:
|
|
/** true if this mode is pending removal from its owner */
|
|
bool bPendingDeletion;
|
|
|
|
protected:
|
|
/** Information pertaining to this mode. Should be assigned in the constructor. */
|
|
FEditorModeInfo Info;
|
|
|
|
/** Editor Mode Toolkit that is associated with this toolkit mode */
|
|
TSharedPtr<FModeToolkit> Toolkit;
|
|
|
|
/** Pointer back to the mode tools that we are registered with */
|
|
FEditorModeTools* Owner;
|
|
|
|
protected:
|
|
/**
|
|
* Returns the first selected Actor, or NULL if there is no selection.
|
|
*/
|
|
AActor* GetFirstSelectedActorInstance() const;
|
|
|
|
bool bHaveSavedEditorState;
|
|
bool bSavedAntiAliasingState;
|
|
|
|
public:
|
|
/**
|
|
* @return active ToolManager
|
|
*/
|
|
virtual UInteractiveToolManager* GetToolManager() const;
|
|
|
|
virtual TMap<FName, TArray<TSharedPtr<FUICommandInfo>>> GetModeCommands() const
|
|
{
|
|
return TMap<FName, TArray<TSharedPtr<FUICommandInfo>>>();
|
|
};
|
|
|
|
void SetCurrentPaletteName(FName InName)
|
|
{
|
|
CurrentPaletteName = InName;
|
|
UpdateOnPaletteChange();
|
|
};
|
|
|
|
FName GetCurrentPaletteName() const
|
|
{
|
|
return CurrentPaletteName;
|
|
}
|
|
|
|
protected:
|
|
virtual void CreateToolkit();
|
|
virtual void OnToolStarted(UInteractiveToolManager* Manager, UInteractiveTool* Tool) {};
|
|
virtual void OnToolEnded(UInteractiveToolManager* Manager, UInteractiveTool* Tool) {};
|
|
virtual void ActivateDefaultTool() {};
|
|
virtual void UpdateOnPaletteChange() {};
|
|
|
|
protected:
|
|
UPROPERTY()
|
|
UEdModeInteractiveToolsContext* ToolsContext;
|
|
TSoftClassPtr<UEdModeInteractiveToolsContext> ToolsContextClass;
|
|
/** Command list lives here so that the key bindings on the commands can be processed in the viewport. */
|
|
TSharedPtr<FUICommandList> ToolCommandList;
|
|
|
|
UPROPERTY()
|
|
TSoftClassPtr<UObject> SettingsClass;
|
|
|
|
UPROPERTY(Transient)
|
|
UObject* SettingsObject;
|
|
|
|
FName CurrentPaletteName;
|
|
};
|