// Copyright Epic Games, Inc. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "UObject/ObjectMacros.h" #include "Templates/SubclassOf.h" #include "GameFramework/Actor.h" #include "Misc/NotifyHook.h" #include "Editor/EditorEngine.h" #include "IPackageAutoSaver.h" #include "ISourceControlProvider.h" #include "IDDCNotifications.h" #include "ComponentVisualizer.h" #include "ComponentVisualizerManager.h" #include "UnrealEdEngine.generated.h" class AGroupActor; class FCanvas; class FLevelEditorViewportClient; class FPerformanceMonitor; class FPrimitiveDrawInterface; class FSceneView; class FViewport; class IEngineLoop; class ITargetPlatform; class UPrimitiveComponent; class UTexture2D; class UUnrealEdOptions; class FName; typedef FName FEditorModeID; UENUM() enum EPackageNotifyState { /** Updating the source control state of the package */ NS_Updating, /** The user has been prompted with the balloon taskbar message. */ NS_BalloonPrompted, /** The user responded to the balloon task bar message and got the modal prompt to checkout dialog and responded to it. */ NS_DialogPrompted, /** The package has been marked dirty and is pending a balloon prompt. */ NS_PendingPrompt, /** The package has been marked dirty but cannot be checked out, and is pending a modal warning dialog. */ NS_PendingWarning, NS_MAX, }; /** Used during asset renaming/duplication to specify class-specific package/group targets. */ USTRUCT() struct FClassMoveInfo { GENERATED_USTRUCT_BODY() /** The type of asset this MoveInfo applies to. */ UPROPERTY(config) FString ClassName; /** The target package info which assets of this type are moved/duplicated. */ UPROPERTY(config) FString PackageName; /** The target group info which assets of this type are moved/duplicated. */ UPROPERTY(config) FString GroupName; /** If true, this info is applied when moving/duplicating assets. */ UPROPERTY(config) uint32 bActive : 1; FClassMoveInfo() : bActive(false) { } }; /** Used during asset renaming/duplication to specify class-specific package/group targets. */ USTRUCT() struct FTemplateMapInfo { GENERATED_USTRUCT_BODY() /** The Texture2D associated with this map template */ UPROPERTY() UTexture2D* ThumbnailTexture; /** The object path to the template map */ UPROPERTY(config) FString Map; FTemplateMapInfo() : ThumbnailTexture(NULL) { } }; class FPerformanceMonitor; UCLASS(config = Engine, transient) class UNREALED_API UUnrealEdEngine: public UEditorEngine , public FNotifyHook { public: GENERATED_BODY() public: /** Global instance of the editor options class. */ UPROPERTY() class UUnrealEdOptions* EditorOptionsInst; /** * Manager responsible for configuring auto reimport */ UPROPERTY() class UAutoReimportManager* AutoReimportManager; /** A buffer for implementing material expression copy/paste. */ UPROPERTY() class UMaterial* MaterialCopyPasteBuffer; /** A buffer for implementing matinee track/group copy/paste. */ UPROPERTY() TArray MatineeCopyPasteBuffer; /** A buffer for implementing sound cue nodes copy/paste. */ UPROPERTY() class USoundCue* SoundCueCopyPasteBuffer; /** Global list of instanced animation compression algorithms. */ UPROPERTY() TArray AnimationCompressionAlgorithms; /** Array of packages to be fully loaded at Editor startup. */ UPROPERTY(config) TArray PackagesToBeFullyLoadedAtStartup; /** Current target for LOD parenting operations (actors will use this as the replacement) */ UPROPERTY() class AActor* CurrentLODParentActor; /** Whether the user needs to be prompted about a package being saved with an engine version newer than the current one or not */ UPROPERTY() uint32 bNeedWarningForPkgEngineVer : 1; /** Whether there is a pending package notification */ uint32 bShowPackageNotification : 1; /** Array of sorted, localized editor sprite categories */ UPROPERTY() TArray SortedSpriteCategories_DEPRECATED; /** List of info for all known template maps */ UPROPERTY(config) TArray TemplateMapInfos; /** Cooker server incase we want to cook on the side while editing... */ UPROPERTY() class UCookOnTheFlyServer* CookServer; /** A list of packages dirtied this tick */ TArray> PackagesDirtiedThisTick; /** A mapping of packages to their checkout notify state. This map only contains dirty packages. Once packages become clean again, they are removed from the map.*/ TMap, uint8> PackageToNotifyState; /** Mapping of sprite category ids to their matching indices in the sorted sprite categories array */ TMap SpriteIDToIndexMap; /** Map from component class to visualizer object to use */ TMap> ComponentVisualizerMap; /** Manages currently active visualizer and routes interactions to it */ FComponentVisualizerManager ComponentVisManager; //~ Begin UObject Interface. ~UUnrealEdEngine(); virtual void FinishDestroy() override; virtual void Serialize(FArchive& Ar) override; //~ End UObject Interface. //~ Begin FNotify Interface. virtual void NotifyPreChange(FProperty* PropertyAboutToChange) override; virtual void NotifyPostChange(const FPropertyChangedEvent& PropertyChangedEvent, FProperty* PropertyThatChanged) override; //~ End FNotify Interface. //~ Begin UEditorEngine Interface virtual void SelectActor(AActor* Actor, bool InSelected, bool bNotify, bool bSelectEvenIfHidden = false, bool bForceRefresh = false) override; virtual bool CanSelectActor(AActor* Actor, bool InSelected, bool bSelectEvenIfHidden = false, bool bWarnIfLevelLocked = false) const override; virtual void SelectGroup(AGroupActor* InGroupActor, bool bForceSelection = false, bool bInSelected = true, bool bNotify = true) override; virtual void SelectComponent(class UActorComponent* Component, bool bInSelected, bool bNotify, bool bSelectEvenIfHidden = false) override; virtual void SelectBSPSurf(UModel* InModel, int32 iSurf, bool bSelected, bool bNoteSelectionChange) override; virtual void SelectNone(bool bNoteSelectionChange, bool bDeselectBSPSurfs, bool WarnAboutManyActors = true) override; virtual void DeselectAllSurfaces() override; virtual void NoteSelectionChange(bool bNotify = true) override; virtual void NoteActorMovement() override; virtual void FinishAllSnaps() override; virtual void Cleanse(bool ClearSelection, bool Redraw, const FText& Reason) override; virtual bool GetMapBuildCancelled() const override; virtual void SetMapBuildCancelled(bool InCancelled) override; virtual FVector GetPivotLocation() override; virtual void SetPivot(FVector NewPivot, bool bSnapPivotToGrid, bool bIgnoreAxis, bool bAssignPivot = false) override; virtual void ResetPivot() override; virtual void RedrawLevelEditingViewports(bool bInvalidateHitProxies = true) override; virtual void TakeHighResScreenShots() override; virtual void GetPackageList(TArray* InPackages, UClass* InClass) override; virtual bool ShouldAbortActorDeletion() const override; virtual void CloseEditor() override; virtual void OnOpenMatinee() override; virtual bool IsAutosaving() const override; //~ End UEditorEngine Interface //~ Begin FExec Interface virtual bool Exec(UWorld* InWorld, const TCHAR* Cmd, FOutputDevice& Ar = *GLog) override; //~ End FExec Interface //~ Begin UEngine Interface. virtual void Init(IEngineLoop* InEngineLoop) override; virtual void PreExit() override; virtual void Tick(float DeltaSeconds, bool bIdleMode) override; //~ End UEngine Interface. /** Builds a list of sprite categories for use in menus */ static void MakeSortedSpriteInfo(TArray& OutSortedSpriteInfo); /** called when a package has has its dirty state updated */ void OnPackageDirtyStateUpdated(UPackage* Pkg); /** called when a package's source control state is updated */ void OnSourceControlStateUpdated(const FSourceControlOperationRef& SourceControlOp, ECommandResult::Type ResultType, TArray> Packages); /** called when a package is automatically checked out from source control */ void OnPackagesCheckedOut(const FSourceControlOperationRef& SourceControlOp, ECommandResult::Type ResultType, TArray> Packages); /** caled by FCoreDelegate::PostGarbageCollect */ void OnPostGarbageCollect(); /** called by color picker change event */ void OnColorPickerChanged(); /** called by the viewport client before a windows message is processed */ void OnPreWindowsMessage(FViewport* Viewport, uint32 Message); /** called by the viewport client after a windows message is processed */ void OnPostWindowsMessage(FViewport* Viewport, uint32 Message); /** Register a function to draw extra information when a particular component is selected */ void RegisterComponentVisualizer(FName ComponentClassName, TSharedPtr Visualizer); /** Unregister component visualizer function */ void UnregisterComponentVisualizer(FName ComponentClassName); /** Find a component visualizer for the given component class name */ TSharedPtr FindComponentVisualizer(FName ComponentClassName) const; /** Find a component visualizer for the given component class (checking parent classes too) */ TSharedPtr FindComponentVisualizer(UClass* ComponentClass) const; /** Draw component visualizers for components for selected actors */ void DrawComponentVisualizers(const FSceneView* View, FPrimitiveDrawInterface* PDI); /** Draw component visualizers HUD elements for components for selected actors */ void DrawComponentVisualizersHUD(const FViewport* Viewport, const FSceneView* View, FCanvas* Canvas); /** Updates the property windows of selected actors */ virtual void UpdateFloatingPropertyWindows(bool bForceRefresh = false); /** * Updates the property windows of the actors in the supplied ActorList * * @param ActorList The list of actors whose property windows should be updated * */ virtual void UpdateFloatingPropertyWindowsFromActorList(const TArray& ActorList, bool bForceRefresh = false); /** * Fast track function to set render thread flags marking selection rather than reconnecting all components * @param InActor - the actor to toggle view flags for */ virtual void SetActorSelectionFlags(AActor* InActor); /** * Set whether the pivot has been moved independently or not */ void SetPivotMovedIndependently(bool bMovedIndependently); /** * Return whether the pivot has been moved independently or not */ bool IsPivotMovedIndependently() const; /** * Called to reset the editor's pivot (widget) location using the currently selected objects. Usually * called when the selection changes. * @param bOnChange Set to true when we know for a fact the selected object has changed */ void UpdatePivotLocationForSelection(bool bOnChange = false); /** * Replaces the specified actor with a new actor of the specified class. The new actor * will be selected if the current actor was selected. * * @param CurrentActor The actor to replace. * @param NewActorClass The class for the new actor. * @param Archetype The template to use for the new actor. * @param bNoteSelectionChange If true, call NoteSelectionChange if the new actor was created successfully. * @return The new actor. */ virtual AActor* ReplaceActor(AActor* CurrentActor, UClass* NewActorClass, UObject* Archetype, bool bNoteSelectionChange); /** * @return Returns the global instance of the editor options class. */ UUnrealEdOptions* GetUnrealEdOptions(); /** * Iterate over all levels of the world and create a list of world infos, then * Iterate over selected actors and assemble a list of actors which can be deleted. * * @param InWorld The world we want to examine * @param bStopAtFirst Whether or not we should stop at the first deletable actor we encounter * @param bLogUndeletable Should we log all the undeletable actors * @param OutDeletableActors Can be NULL, provides a list of all the actors, from the selection, that are deletable * @return true if any of the selection can be deleted */ bool CanDeleteSelectedActors(const UWorld* InWorld, const bool bStopAtFirst, const bool bLogUndeletable, TArray* OutDeletableActors = NULL) const; // UnrealEdSrv stuff. bool Exec_Edit(UWorld* InWorld, const TCHAR* Str, FOutputDevice& Ar); bool Exec_Pivot(const TCHAR* Str, FOutputDevice& Ar); bool Exec_Actor(UWorld* InWorld, const TCHAR* Str, FOutputDevice& Ar); bool Exec_Mode(const TCHAR* Str, FOutputDevice& Ar); bool Exec_Group(const TCHAR* Str, FOutputDevice& Ar); // Editor actor virtuals from EditorActor.cpp. /** * Select all actors and BSP models, except those which are hidden. */ virtual void edactSelectAll(UWorld* InWorld); /** * Invert the selection of all actors and BSP models. */ virtual void edactSelectInvert(UWorld* InWorld); /** * Select all children actors of the current selection. * * @param bRecurseChildren true to recurse through all descendants of the children */ virtual void edactSelectAllChildren(bool bRecurseChildren); /** * Select all actors in a particular class. * * @param InWorld World context * @param InClass Class of actor to select */ virtual void edactSelectOfClass(UWorld* InWorld, UClass* Class); /** * Select all actors of a particular class and archetype. * * @param InWorld World context * @param InClass Class of actor to select * @param InArchetype Archetype of actor to select */ virtual void edactSelectOfClassAndArchetype(UWorld* InWorld, const TSubclassOf InClass, const UObject* InArchetype); /** * Select all actors in a particular class and its subclasses. * * @param InWorld World context */ virtual void edactSelectSubclassOf(UWorld* InWorld, UClass* Class); /** * Select all actors in a level that are marked for deletion. * * @param InWorld World context */ virtual void edactSelectDeleted(UWorld* InWorld); /** * Select all actors that have the same static mesh assigned to them as the selected ones. * * @param bAllClasses If true, also select non-AStaticMeshActor actors whose meshes match. */ virtual void edactSelectMatchingStaticMesh(bool bAllClasses); /** * Select all actors that have the same skeletal mesh assigned to them as the selected ones. * * @param bAllClasses If true, also select non-ASkeletalMeshActor actors whose meshes match. */ virtual void edactSelectMatchingSkeletalMesh(bool bAllClasses); /** * Select all material actors that have the same material assigned to them as the selected ones. */ virtual void edactSelectMatchingMaterial(); /** * Select all emitter actors that have the same particle system template assigned to them as the selected ones. */ virtual void edactSelectMatchingEmitter(); /** * Select the relevant lights for all selected actors * * @param InWorld World context */ virtual void edactSelectRelevantLights(UWorld* InWorld); /** * Deletes all selected actors * * @param InWorld World context * @param bVerifyDeletionCanHappen [opt] If true (default), verify that deletion can be performed. * @param bWarnAboutReferences [opt] If true (default), we prompt the user about referenced actors they are about to delete * @param bWarnAboutSoftReferences [opt] If true (default), we prompt the user about soft references to actors they are about to delete * @return true unless the delete operation was aborted. */ virtual bool edactDeleteSelected(UWorld* InWorld, bool bVerifyDeletionCanHappen = true, bool bWarnAboutReferences = true, bool bWarnAboutSoftReferences = true) override; /** * Creates a new group from the current selection removing any existing groups. */ UE_DEPRECATED(4.17, "edactRegroupFromSelected is deprecated, use UActorGroupingUtils::GroupSelected") virtual void edactRegroupFromSelected(); /** * Disbands any groups in the current selection, does not attempt to maintain any hierarchy */ UE_DEPRECATED(4.17, "edactUngroupFromSelected is deprecated, use UActorGroupingUtils::UngroupSelected") virtual void edactUngroupFromSelected(); /** * Locks any groups in the current selection */ UE_DEPRECATED(4.17, "edactLockSelectedGroups is deprecated, use UActorGroupingUtils::LockSelectedGroups") virtual void edactLockSelectedGroups(); /** * Unlocks any groups in the current selection */ UE_DEPRECATED(4.17, "edactUnlockSelectedGroups is deprecated, use UActorGroupingUtils::UnlockSelectedGroups") virtual void edactUnlockSelectedGroups(); /** * Activates "Add to Group" mode which allows the user to select a group to append current selection */ UE_DEPRECATED(4.17, "edactAddToGroup is deprecated, use UActorGroupingUtils::AddSelectedToGroup") virtual void edactAddToGroup(); /** * Removes any groups or actors in the current selection from their immediate parent. * If all actors/subgroups are removed, the parent group will be destroyed. */ UE_DEPRECATED(4.17, "edactRemoveFromGroup is deprecated, use UActorGroupingUtils::RemoveSelectedFromGroup") virtual void edactRemoveFromGroup(); /** * Copy selected actors to the clipboard. Does not copy PrefabInstance actors or parts of Prefabs. * * @param InWorld World context * @param DestinationData If != NULL, additionally copy data to string */ virtual void edactCopySelected(UWorld* InWorld, FString* DestinationData = NULL) override; /** * Paste selected actors from the clipboard. * * @param InWorld World context * @param bDuplicate Is this a duplicate operation (as opposed to a real paste)? * @param bOffsetLocations Should the actor locations be offset after they are created? * @param bWarnIfHidden If true displays a warning if the destination level is hidden * @param SourceData If != NULL, use instead of clipboard data */ virtual void edactPasteSelected(UWorld* InWorld, bool bDuplicate, bool bOffsetLocations, bool bWarnIfHidden, FString* SourceData = NULL) override; /** * Duplicates selected actors. Handles the case where you are trying to duplicate PrefabInstance actors. * * @param InLevel Level to place duplicate * @param bUseOffset Should the actor locations be offset after they are created? */ virtual void edactDuplicateSelected(ULevel* InLevel, bool bUseOffset) override; /** * Replace all selected brushes with the default brush. * * @param InWorld World context */ virtual void edactReplaceSelectedBrush(UWorld* InWorld); /** * Replace all selected non-brush actors with the specified class. */ virtual void edactReplaceSelectedNonBrushWithClass(UClass* Class); /** * Replace all actors of the specified source class with actors of the destination class. * * @param InWorld World context * @param SrcClass The class of actors to replace. * @param DstClass The class to replace with. */ virtual void edactReplaceClassWithClass(UWorld* InWorld, UClass* SrcClass, UClass* DstClass); /** * Align the origin with the current grid. */ virtual void edactAlignOrigin(); /** * Align all vertices with the current grid. */ virtual void edactAlignVertices(); /** * Hide selected actors and BSP models by marking their bHiddenEdTemporary flags true. Will not * modify/dirty actors/BSP. */ virtual void edactHideSelected(UWorld* InWorld); /** * Hide unselected actors and BSP models by marking their bHiddenEdTemporary flags true. Will not * modify/dirty actors/BSP. */ virtual void edactHideUnselected(UWorld* InWorld); /** * Attempt to unhide all actors and BSP models by setting their bHiddenEdTemporary flags to false if they * are true. Note: Will not unhide actors/BSP hidden by higher priority visibility settings, such as bHiddenEdGroup, * but also will not modify/dirty actors/BSP. */ virtual void edactUnHideAll(UWorld* InWorld); /** * Mark all selected actors and BSP models to be hidden upon editor startup, by setting their bHiddenEd flag to * true, if it is not already. This directly modifies/dirties the relevant actors/BSP. */ virtual void edactHideSelectedStartup(UWorld* InWorld); /** * Mark all actors and BSP models to be shown upon editor startup, by setting their bHiddenEd flag to false, if it is * not already. This directly modifies/dirties the relevant actors/BSP. */ virtual void edactUnHideAllStartup(UWorld* InWorld); /** * Mark all selected actors and BSP models to be shown upon editor startup, by setting their bHiddenEd flag to false, if it * not already. This directly modifies/dirties the relevant actors/BSP. */ virtual void edactUnHideSelectedStartup(UWorld* InWorld); /** * Show selected actors and BSP models by marking their bHiddenEdTemporary flags false. Will not * modify/dirty actors/BSP. */ virtual void edactUnhideSelected(UWorld* InWorld); /** Will create a map of currently visible BSP surfaces. */ virtual void CreateBSPVisibilityMap(UWorld* InWorld, TMap>& OutBSPMap, bool& bOutAllVisible); /** Go through a map of BSP and make only the requested objects visible. */ virtual void MakeBSPMapVisible(const TMap>& InBSPMap, UWorld* InWorld); /** Returns the configuration of attachment that would result from calling AttachSelectedActors at this point in time */ AActor* GetDesiredAttachmentState(TArray& OutNewChildren); /** Uses the current selection state to attach actors together. Last selected Actor becomes the base. */ void AttachSelectedActors(); /** * Can the editor do cook by the book in the editor process space */ virtual bool CanCookByTheBookInEditor(const FString& PlatformName) const override; /** * Can the editor act as a cook on the fly server */ virtual bool CanCookOnTheFlyInEditor(const FString& PlatformName) const override; /** * Start cook by the book in the editor process space */ virtual void StartCookByTheBookInEditor(const TArray& TargetPlatforms, const TArray& CookMaps, const TArray& CookDirectories, const TArray& CookCultures, const TArray& IniMapSections) override; /** * Checks if the cook by the book is finished */ virtual bool IsCookByTheBookInEditorFinished() const override; /** * cancels the current cook by the book in editor */ virtual void CancelCookByTheBookInEditor() override; // Hook replacements. void ShowActorProperties(); /** * Checks to see if any worlds are dirty (that is, they need to be saved.) * * @param InWorld World to search for dirty worlds * * @return true if any worlds are dirty */ bool AnyWorldsAreDirty(UWorld* InWorld) const; /** * Checks to see if any content packages are dirty (that is, they need to be saved.) * * @return true if any content packages are dirty */ bool AnyContentPackagesAreDirty() const; // Misc /** * Attempts to prompt the user with a balloon notification to checkout modified packages from source control. * Will defer prompting the user if they are interacting with something */ void AttemptModifiedPackageNotification(); /** * Prompts the user with a modal checkout dialog to checkout packages from source control. * This should only be called by the auto prompt to checkout package notification system. * For a general checkout packages routine use FEditorFileUtils::PromptToCheckoutPackages * * @param bPromptAll If true we prompt for all packages in the PackageToNotifyState map. If false only prompt about ones we have never prompted about before. */ void PromptToCheckoutModifiedPackages(bool bPromptAll = false); /** * Displays a toast notification or warning when a package is dirtied, indicating that it needs checking out (or that it cannot be checked out) */ void ShowPackageNotification(); /** * @return Returns the number of dirty packages that require checkout. */ int32 GetNumDirtyPackagesThatNeedCheckout() const; /** * Checks to see if there are any packages in the PackageToNotifyState map that are not checked out by the user * * @return True if packages need to be checked out. */ bool DoDirtyPackagesNeedCheckout() const; /** * Checks whether the specified map is a template map. * * @return true if the map is a template map, false otherwise. */ bool IsTemplateMap(const FString& MapName) const; /** * Returns true if the user is currently interacting with a viewport. */ bool IsUserInteracting(); void SetCurrentClass(UClass* InClass); /** * @return true if selection of translucent objects in perspective viewports is allowed */ virtual bool AllowSelectTranslucent() const override; /** * @return true if only editor-visible levels should be loaded in Play-In-Editor sessions */ virtual bool OnlyLoadEditorVisibleLevelsInPIE() const override; /** * @return true if level streaming should prefer to stream levels from disk instead of duplicating them from editor world */ virtual bool PreferToStreamLevelsInPIE() const override; /** * If all selected actors belong to the same level, that level is made the current level. */ void MakeSelectedActorsLevelCurrent(); /** Returns the thumbnail manager and creates it if missing */ class UThumbnailManager* GetThumbnailManager(); /** * Returns whether saving the specified package is allowed */ virtual bool CanSavePackage(UPackage* PackageToSave); /** Converts kismet based matinees in the current level to matinees controlled via matinee actors */ void ConvertMatinees(); /** * Updates the volume actor visibility for all viewports based on the passed in volume class * * @param InVolumeActorClass The type of volume actors to update. If NULL is passed in all volume actor types are updated. * @param InViewport The viewport where actor visibility should apply. Pass NULL for all editor viewports. */ void UpdateVolumeActorVisibility(UClass* InVolumeActorClass = NULL, FLevelEditorViewportClient* InViewport = NULL); /** * Identify any brushes whose sense is inverted and repair them */ void FixAnyInvertedBrushes(UWorld* World); /** * Get the index of the provided sprite category * * @param InSpriteCategory Sprite category to get the index of * * @return Index of the provided sprite category, if possible; INDEX_NONE otherwise */ virtual int32 GetSpriteCategoryIndex(const FName& InSpriteCategory) override; /** * Shows the LightingStaticMeshInfoWindow, creating it first if it hasn't been initialized. */ void ShowLightingStaticMeshInfoWindow(); /** * Shows the SceneStatsWindow, creating it first if it hasn't been initialized. */ void OpenSceneStatsWindow(); /** * Shows the TextureStatsWindow, creating it first if it hasn't been initialized. */ void OpenTextureStatsWindow(); /** * Puts all of the AVolume classes into the passed in array and sorts them by class name. * * @param VolumeClasses Array to populate with AVolume classes. */ static void GetSortedVolumeClasses(TArray* VolumeClasses); /** * Checks the destination level visibility and warns the user if he is trying to paste to a hidden level, offering the option to cancel the operation or unhide the level that is hidden * * @param InWorld World context */ bool WarnIfDestinationLevelIsHidden(UWorld* InWorld); /** * Generate the package thumbails if they are needed. */ UPackage* GeneratePackageThumbnailsIfRequired(const TCHAR* Str, FOutputDevice& Ar, TArray& ThumbNamesToUnload); /** @return The package auto-saver instance used by the editor */ IPackageAutoSaver& GetPackageAutoSaver() const { return *PackageAutoSaver; } /** @return The DDC notifications instance used by the editor */ IDDCNotifications& GetDDCNotifications() const { return *DDCNotifications; } /** * Exec command handlers */ bool HandleDumpModelGUIDCommand(const TCHAR* Str, FOutputDevice& Ar); bool HandleModalTestCommand(const TCHAR* Str, FOutputDevice& Ar); bool HandleDisallowExportCommand(const TCHAR* Str, FOutputDevice& Ar); bool HandleDumpBPClassesCommand(const TCHAR* Str, FOutputDevice& Ar); bool HandleFindOutdateInstancesCommand(const TCHAR* Str, FOutputDevice& Ar); bool HandleDumpSelectionCommand(const TCHAR* Str, FOutputDevice& Ar); bool HandleBuildLightingCommand(const TCHAR* Str, FOutputDevice& Ar, UWorld* InWorld); bool HandleBuildPathsCommand(const TCHAR* Str, FOutputDevice& Ar, UWorld* InWorld); bool HandleRecreateLandscapeCollisionCommand(const TCHAR* Str, FOutputDevice& Ar, UWorld* InWorld); bool HandleRemoveLandscapeXYOffsetsCommand(const TCHAR* Str, FOutputDevice& Ar, UWorld* InWorld); bool HandleConvertMatineesCommand(const TCHAR* Str, FOutputDevice& Ar, UWorld* InWorld); bool HandleDisasmScriptCommand(const TCHAR* Str, FOutputDevice& Ar); /** OnEditorModeChanged delegate which looks for Matinee editor closing */ void UpdateEdModeOnMatineeClose(const FEditorModeID& EditorModeID, bool IsEntering); bool IsComponentSelected(const UPrimitiveComponent* PrimComponent); /** Return if we have write permission under the mount point this packages lives in. */ bool HasMountWritePersmissionForPackage(const FString& PackageName); protected: /** Called when global editor selection changes */ void OnEditorSelectionChanged(UObject* SelectionThatChanged); /** The package auto-saver instance used by the editor */ TUniquePtr PackageAutoSaver; /** The DDC notifications instance used by the editor */ TUniquePtr DDCNotifications; /** * The list of visualizers to draw when selection changes */ TArray VisualizersForSelection; /** Instance responsible for monitoring this editor's performance */ FPerformanceMonitor* PerformanceMonitor; /** Handle to the registered OnMatineeEditorClosed delegate. */ FDelegateHandle OnMatineeEditorClosedDelegateHandle; /** Handle to the registered UpdateEdModeOnMatineeClose delegate. */ FDelegateHandle UpdateEdModeOnMatineeCloseDelegateHandle; /** Whether the pivot has been moved independently */ bool bPivotMovedIndependently; /** Weak Pointer to the file checkout notification toast. */ TWeakPtr CheckOutNotificationWeakPtr; private: /** Verify if we have write permission under the specified mount point. */ bool VerifyMountPointWritePermission(FName MountPoint); /** Delegate when a new mount point is added, used to test writing permission. */ void OnContentPathMounted(const FString& AssetPath, const FString& FileSystemPath); /** Delegate when a new mount point is removed, used to test writing permission. */ void OnContentPathDismounted(const FString& AssetPath, const FString& FileSystemPath); /** Map to track which mount point has write permissions. */ TMap MountPointCheckedForWritePermission; /** Weak Pointer to the write permission warning toast. */ TWeakPtr WritePermissionWarningNotificationWeakPtr; /** * Internal helper function to count how many dirty packages require checkout. * * @param bCheckIfAny If true, checks instead if any packages need checkout. * * @return Returns the number of dirty packages that require checkout. If bCheckIfAny is true, returns 1 if any packages will require checkout. */ int32 InternalGetNumDirtyPackagesThatNeedCheckout(bool bCheckIfAny) const; /** * Internal function to validate free space on drives used by Unreal Engine * The intent is to notify the user of situations where stability maybe impacted. */ void ValidateFreeDiskSpace() const; };