544 lines
17 KiB
C++
544 lines
17 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "VREditorActions.h"
|
|
#include "VREditorModule.h"
|
|
#include "UI/VREditorUISystem.h"
|
|
#include "VREditorMode.h"
|
|
#include "ViewportWorldInteraction.h"
|
|
#include "VREditorInteractor.h"
|
|
#include "UI/VREditorFloatingUI.h"
|
|
#include "SLevelViewport.h"
|
|
#include "ImageUtils.h"
|
|
#include "Misc/FileHelper.h"
|
|
#include "Framework/Application/SlateApplication.h"
|
|
#include "ILevelEditor.h"
|
|
#include "LevelEditor.h"
|
|
|
|
#include "IAssetTools.h"
|
|
#include "AssetToolsModule.h"
|
|
#include "Modules/ModuleManager.h"
|
|
#include "LevelSequence.h"
|
|
#include "LevelSequenceActor.h"
|
|
#include "ISequencer.h"
|
|
#include "SequencerSettings.h"
|
|
#include "UnrealEdGlobals.h"
|
|
#include "Editor/UnrealEdEngine.h"
|
|
#include "EditorModes.h"
|
|
#include "EdMode.h"
|
|
#include "Engine/Selection.h"
|
|
#include "VREditorInteractor.h"
|
|
#include "LevelEditorActions.h"
|
|
#include "UObject/UObjectIterator.h"
|
|
#include "Factories/Factory.h"
|
|
#include "Subsystems/AssetEditorSubsystem.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "VREditorActions"
|
|
|
|
namespace VREd
|
|
{
|
|
static FAutoConsoleVariable AllowPlay(TEXT("VREd.AllowPlay"), 1, TEXT("Allow to start play."));
|
|
}
|
|
|
|
FText FVREditorActionCallbacks::GizmoCoordinateSystemText;
|
|
FText FVREditorActionCallbacks::GizmoModeText;
|
|
FText FVREditorActionCallbacks::SelectingCandidateActorsText;
|
|
FText FVREditorActionCallbacks::SequencerLoopText;
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::GetTranslationSnapState()
|
|
{
|
|
return GetDefault<ULevelEditorViewportSettings>()->GridEnabled ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::OnTranslationSnapSizeButtonClicked()
|
|
{
|
|
const TArray<float>& GridSizes = GEditor->GetCurrentPositionGridArray();
|
|
const int32 CurrentGridSize = GetDefault<ULevelEditorViewportSettings>()->CurrentPosGridSize;
|
|
|
|
int32 NewGridSize = CurrentGridSize + 1;
|
|
if (NewGridSize >= GridSizes.Num())
|
|
{
|
|
NewGridSize = 0;
|
|
}
|
|
|
|
GEditor->SetGridSize(NewGridSize);
|
|
|
|
GetTranslationSnapSizeText();
|
|
|
|
}
|
|
|
|
FText FVREditorActionCallbacks::GetTranslationSnapSizeText()
|
|
{
|
|
return FText::AsNumber(GEditor->GetGridSize());
|
|
|
|
}
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::GetRotationSnapState()
|
|
{
|
|
return GetDefault<ULevelEditorViewportSettings>()->RotGridEnabled ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::OnRotationSnapSizeButtonClicked()
|
|
{
|
|
const TArray<float>& GridSizes = GEditor->GetCurrentRotationGridArray();
|
|
const int32 CurrentGridSize = GetDefault<ULevelEditorViewportSettings>()->CurrentRotGridSize;
|
|
const ERotationGridMode CurrentGridMode = GetDefault<ULevelEditorViewportSettings>()->CurrentRotGridMode;
|
|
|
|
int32 NewGridSize = CurrentGridSize + 1;
|
|
if (NewGridSize >= GridSizes.Num())
|
|
{
|
|
NewGridSize = 0;
|
|
}
|
|
|
|
GEditor->SetRotGridSize(NewGridSize, CurrentGridMode);
|
|
|
|
}
|
|
|
|
FText FVREditorActionCallbacks::GetRotationSnapSizeText()
|
|
{
|
|
return FText::AsNumber(GEditor->GetRotGridSize().Yaw);
|
|
}
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::GetScaleSnapState()
|
|
{
|
|
return GetDefault<ULevelEditorViewportSettings>()->SnapScaleEnabled ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::OnScaleSnapSizeButtonClicked()
|
|
{
|
|
const ULevelEditorViewportSettings* ViewportSettings = GetMutableDefault<ULevelEditorViewportSettings>();
|
|
const int32 NumGridSizes = ViewportSettings->ScalingGridSizes.Num();
|
|
|
|
const int32 CurrentGridSize = GetDefault<ULevelEditorViewportSettings>()->CurrentScalingGridSize;
|
|
|
|
int32 NewGridSize = CurrentGridSize + 1;
|
|
if (NewGridSize >= NumGridSizes)
|
|
{
|
|
NewGridSize = 0;
|
|
}
|
|
|
|
GEditor->SetScaleGridSize(NewGridSize);
|
|
|
|
|
|
}
|
|
|
|
FText FVREditorActionCallbacks::GetScaleSnapSizeText()
|
|
{
|
|
return FText::AsNumber(GEditor->GetScaleGridSize());
|
|
}
|
|
|
|
void FVREditorActionCallbacks::OnGizmoCoordinateSystemButtonClicked(UVREditorMode* InVRMode)
|
|
{
|
|
InVRMode->GetWorldInteraction().CycleTransformGizmoCoordinateSpace();
|
|
UpdateGizmoModeText(InVRMode);
|
|
UpdateGizmoCoordinateSystemText(InVRMode);
|
|
|
|
}
|
|
|
|
void FVREditorActionCallbacks::SetCoordinateSystem(UVREditorMode* InVRMode, ECoordSystem InCoordSystem)
|
|
{
|
|
if (!(InVRMode->GetWorldInteraction().GetTransformGizmoCoordinateSpace() == InCoordSystem))
|
|
{
|
|
InVRMode->GetWorldInteraction().SetTransformGizmoCoordinateSpace(InCoordSystem);
|
|
UpdateGizmoCoordinateSystemText(InVRMode);
|
|
}
|
|
}
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::IsActiveCoordinateSystem(UVREditorMode* InVRMode, ECoordSystem InCoordSystem)
|
|
{
|
|
return (InVRMode->GetWorldInteraction().GetTransformGizmoCoordinateSpace() == InCoordSystem) ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
|
|
void FVREditorActionCallbacks::SetGizmoMode(UVREditorMode* InVRMode, EGizmoHandleTypes InGizmoMode)
|
|
{
|
|
if (!(InVRMode->GetWorldInteraction().GetCurrentGizmoType() == InGizmoMode))
|
|
{
|
|
InVRMode->GetWorldInteraction().SetGizmoHandleType(InGizmoMode);
|
|
UpdateGizmoCoordinateSystemText(InVRMode);
|
|
}
|
|
}
|
|
|
|
EGizmoHandleTypes FVREditorActionCallbacks::GetGizmoMode(const UVREditorMode* InVRMode)
|
|
{
|
|
return InVRMode->GetWorldInteraction().GetCurrentGizmoType();
|
|
}
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::IsActiveGizmoMode(UVREditorMode* InVRMode, EGizmoHandleTypes InGizmoMode)
|
|
{
|
|
return (InVRMode->GetWorldInteraction().GetCurrentGizmoType() == InGizmoMode) ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
FText FVREditorActionCallbacks::GetGizmoCoordinateSystemText()
|
|
{
|
|
return FVREditorActionCallbacks::GizmoCoordinateSystemText;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::UpdateGizmoCoordinateSystemText(UVREditorMode* InVRMode)
|
|
{
|
|
const ECoordSystem CurrentCoordSystem = InVRMode->GetWorldInteraction().GetTransformGizmoCoordinateSpace(); //@todo VREditor
|
|
FVREditorActionCallbacks::GizmoCoordinateSystemText = (CurrentCoordSystem == COORD_World ? LOCTEXT("WorldCoordinateSystem", "World") : LOCTEXT("LocalCoordinateSystem", "Local"));
|
|
}
|
|
|
|
void FVREditorActionCallbacks::OnGizmoModeButtonClicked(UVREditorMode* InVRMode)
|
|
{
|
|
const EGizmoHandleTypes CurrentGizmoMode = InVRMode->GetWorldInteraction().GetCurrentGizmoType();
|
|
InVRMode->CycleTransformGizmoHandleType();
|
|
UpdateGizmoModeText(InVRMode);
|
|
UpdateGizmoCoordinateSystemText(InVRMode);
|
|
|
|
}
|
|
|
|
FText FVREditorActionCallbacks::GetGizmoModeText()
|
|
{
|
|
return FVREditorActionCallbacks::GizmoModeText;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::UpdateGizmoModeText(UVREditorMode* InVRMode)
|
|
{
|
|
const EGizmoHandleTypes CurrentGizmoType = InVRMode->GetWorldInteraction().GetCurrentGizmoType();
|
|
FText GizmoTypeText;
|
|
switch (CurrentGizmoType)
|
|
{
|
|
case EGizmoHandleTypes::All:
|
|
GizmoTypeText = LOCTEXT("AllGizmoType", "Universal");
|
|
break;
|
|
|
|
case EGizmoHandleTypes::Translate:
|
|
GizmoTypeText = LOCTEXT("TranslateGizmoType", "Translate");
|
|
break;
|
|
|
|
case EGizmoHandleTypes::Rotate:
|
|
GizmoTypeText = LOCTEXT("RotationGizmoType", "Rotate");
|
|
break;
|
|
|
|
case EGizmoHandleTypes::Scale:
|
|
GizmoTypeText = LOCTEXT("ScaleGizmoType", "Scale");
|
|
break;
|
|
|
|
default:
|
|
check(0); // Unrecognized type
|
|
break;
|
|
}
|
|
|
|
FVREditorActionCallbacks::GizmoModeText = GizmoTypeText;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::OnUIToggleButtonClicked(UVREditorMode* InVRMode, VREditorPanelID PanelToToggle)
|
|
{
|
|
InVRMode->GetUISystem().TogglePanelVisibility(PanelToToggle);
|
|
}
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::GetUIToggledState(UVREditorMode* InVRMode, VREditorPanelID PanelToCheck)
|
|
{
|
|
return InVRMode->GetUISystem().IsShowingEditorUIPanel(PanelToCheck) ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::OnSnapActorsToGroundClicked(UVREditorMode* InVRMode)
|
|
{
|
|
InVRMode->SnapSelectedActorsToGround();
|
|
}
|
|
|
|
void FVREditorActionCallbacks::SimulateCharacterEntry(const FString InChar)
|
|
{
|
|
|
|
for (int32 CharIndex = 0; CharIndex < InChar.Len(); CharIndex++)
|
|
{
|
|
TCHAR CharKey = InChar[CharIndex];
|
|
const bool bRepeat = false;
|
|
FCharacterEvent CharacterEvent(CharKey, FModifierKeysState(), 0, bRepeat);
|
|
FSlateApplication::Get().ProcessKeyCharEvent(CharacterEvent);
|
|
}
|
|
|
|
}
|
|
|
|
void FVREditorActionCallbacks::SimulateBackspace()
|
|
{
|
|
// Slate editable text fields handle backspace as a character entry
|
|
FString BackspaceString = FString(TEXT("\b"));
|
|
bool bRepeat = false;
|
|
SimulateCharacterEntry(BackspaceString);
|
|
}
|
|
|
|
void FVREditorActionCallbacks::SimulateKeyDown(const FKey Key, const bool bRepeat)
|
|
{
|
|
const uint32* KeyCodePtr;
|
|
const uint32* CharCodePtr;
|
|
FInputKeyManager::Get().GetCodesFromKey(Key, KeyCodePtr, CharCodePtr);
|
|
|
|
uint32 KeyCode = KeyCodePtr ? *KeyCodePtr : 0;
|
|
uint32 CharCode = CharCodePtr ? *CharCodePtr : 0;
|
|
|
|
FKeyEvent KeyEvent( Key, FModifierKeysState(), 0, bRepeat, KeyCode, CharCode );
|
|
bool DownResult = FSlateApplication::Get().ProcessKeyDownEvent( KeyEvent );
|
|
|
|
if (CharCodePtr)
|
|
{
|
|
FCharacterEvent CharacterEvent( (TCHAR)CharCode, FModifierKeysState(), 0, bRepeat );
|
|
FSlateApplication::Get().ProcessKeyCharEvent( CharacterEvent );
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::SimulateKeyUp(const FKey Key)
|
|
{
|
|
const uint32* KeyCodePtr;
|
|
const uint32* CharCodePtr;
|
|
FInputKeyManager::Get().GetCodesFromKey(Key, KeyCodePtr, CharCodePtr);
|
|
|
|
uint32 KeyCode = KeyCodePtr ? *KeyCodePtr : 0;
|
|
uint32 CharCode = CharCodePtr ? *CharCodePtr : 0;
|
|
|
|
FKeyEvent KeyEvent( Key, FModifierKeysState(), 0, false, KeyCode, CharCode );
|
|
FSlateApplication::Get().ProcessKeyUpEvent( KeyEvent );
|
|
}
|
|
|
|
void FVREditorActionCallbacks::CreateNewSequence(UVREditorMode* InVRMode)
|
|
{
|
|
// Create a new level sequence
|
|
IAssetTools& AssetTools = FModuleManager::GetModuleChecked<FAssetToolsModule>("AssetTools").Get();
|
|
|
|
UObject* NewAsset = nullptr;
|
|
|
|
// Attempt to create a new asset
|
|
for (TObjectIterator<UClass> It; It; ++It)
|
|
{
|
|
UClass* CurrentClass = *It;
|
|
if (CurrentClass->IsChildOf(UFactory::StaticClass()) && !(CurrentClass->HasAnyClassFlags(CLASS_Abstract)))
|
|
{
|
|
UFactory* Factory = Cast<UFactory>(CurrentClass->GetDefaultObject());
|
|
if (Factory->CanCreateNew() && Factory->ImportPriority >= 0 && Factory->SupportedClass == ULevelSequence::StaticClass())
|
|
{
|
|
FString NewPackageName;
|
|
FString NewAssetName;
|
|
// Sequences created in VR editor will have a sequential VRSequencer00X naming scheme and be stored in Game/Sequences
|
|
AssetTools.CreateUniqueAssetName(TEXT("/Game/Cinematics/Sequences/VRSequence"), TEXT("001"), NewPackageName, NewAssetName);
|
|
NewAsset = AssetTools.CreateAsset(NewAssetName, TEXT("/Game/Cinematics/Sequences"), ULevelSequence::StaticClass(), Factory);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!NewAsset)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Spawn an actor at the origin, and move in front of the camera and open for edit
|
|
UActorFactory* ActorFactory = GEditor->FindActorFactoryForActorClass(ALevelSequenceActor::StaticClass());
|
|
if (!ensure(ActorFactory))
|
|
{
|
|
return;
|
|
}
|
|
|
|
ALevelSequenceActor* NewActor = CastChecked<ALevelSequenceActor>(GEditor->UseActorFactory(ActorFactory, FAssetData(NewAsset), &FTransform::Identity));
|
|
|
|
InVRMode->GetUISystem().SequencerOpenendFromRadialMenu(true);
|
|
|
|
// Open the Sequencer window
|
|
GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->OpenEditorForAsset(NewAsset);
|
|
}
|
|
|
|
void FVREditorActionCallbacks::CloseSequencer(UMovieSceneSequence* OpenSequence)
|
|
{
|
|
IAssetEditorInstance* SequencerEditor = GEditor->GetEditorSubsystem<UAssetEditorSubsystem>()->FindEditorForAsset(OpenSequence, false);
|
|
if (SequencerEditor != nullptr)
|
|
{
|
|
SequencerEditor->CloseWindow(EAssetEditorCloseReason::AssetEditorHostClosed);
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::PlaySequenceAtRate(UVREditorMode* InVRMode, float Rate)
|
|
{
|
|
ISequencer* CurrentSequencer = InVRMode->GetCurrentSequencer();
|
|
if (CurrentSequencer != nullptr)
|
|
{
|
|
CurrentSequencer->SetPlaybackSpeed(Rate);
|
|
CurrentSequencer->OnPlay(false);
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::PauseSequencePlayback(UVREditorMode* InVRMode)
|
|
{
|
|
ISequencer* CurrentSequencer = InVRMode->GetCurrentSequencer();
|
|
if (CurrentSequencer != nullptr)
|
|
{
|
|
CurrentSequencer->SetPlaybackSpeed(1.0f);
|
|
CurrentSequencer->Pause();
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::PlayFromBeginning(UVREditorMode* InVRMode)
|
|
{
|
|
ISequencer* CurrentSequencer = InVRMode->GetCurrentSequencer();
|
|
if (CurrentSequencer != nullptr)
|
|
{
|
|
CurrentSequencer->SetLocalTime(0);
|
|
CurrentSequencer->SetPlaybackSpeed(1.f);
|
|
CurrentSequencer->OnPlay(false);
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::ToggleLooping(UVREditorMode* InVRMode)
|
|
{
|
|
ISequencer* CurrentSequencer = InVRMode->GetCurrentSequencer();
|
|
|
|
if (CurrentSequencer != nullptr)
|
|
{
|
|
ESequencerLoopMode LoopMode = CurrentSequencer->GetSequencerSettings()->GetLoopMode();
|
|
if (LoopMode == ESequencerLoopMode::SLM_NoLoop)
|
|
{
|
|
CurrentSequencer->GetSequencerSettings()->SetLoopMode(ESequencerLoopMode::SLM_Loop);
|
|
}
|
|
else if (LoopMode == ESequencerLoopMode::SLM_Loop && !CurrentSequencer->GetSelectionRange().IsEmpty())
|
|
{
|
|
CurrentSequencer->GetSequencerSettings()->SetLoopMode(ESequencerLoopMode::SLM_LoopSelectionRange);
|
|
}
|
|
else if (LoopMode == ESequencerLoopMode::SLM_LoopSelectionRange || CurrentSequencer->GetSelectionRange().IsEmpty())
|
|
{
|
|
CurrentSequencer->GetSequencerSettings()->SetLoopMode(ESequencerLoopMode::SLM_NoLoop);
|
|
}
|
|
}
|
|
}
|
|
|
|
FText FVREditorActionCallbacks::GetSequencerLoopingText()
|
|
{
|
|
return FVREditorActionCallbacks::SequencerLoopText;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::UpdateSequencerLoopingText(UVREditorMode* InVRMode)
|
|
{
|
|
ISequencer* CurrentSequencer = InVRMode->GetCurrentSequencer();
|
|
if (CurrentSequencer != nullptr)
|
|
{
|
|
const ESequencerLoopMode CurrentLoopingType = CurrentSequencer->GetSequencerSettings()->GetLoopMode();
|
|
FText LoopText;
|
|
switch (CurrentLoopingType)
|
|
{
|
|
case ESequencerLoopMode::SLM_NoLoop:
|
|
LoopText = LOCTEXT("NoLooping", "No Looping");
|
|
break;
|
|
|
|
case ESequencerLoopMode::SLM_Loop:
|
|
LoopText = LOCTEXT("LoopAll", "Loop All");
|
|
break;
|
|
|
|
case ESequencerLoopMode::SLM_LoopSelectionRange:
|
|
LoopText = LOCTEXT("LoopRange", "Loop Range");
|
|
break;
|
|
|
|
default:
|
|
check(0); // Unrecognized type
|
|
break;
|
|
}
|
|
|
|
FVREditorActionCallbacks::SequencerLoopText = LoopText;
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::SetSelectionRangeStart(UVREditorMode* InVRMode)
|
|
{
|
|
ISequencer* CurrentSequencer = InVRMode->GetCurrentSequencer();
|
|
if (CurrentSequencer != nullptr)
|
|
{
|
|
CurrentSequencer->SetSelectionRangeStart(CurrentSequencer->GetLocalTime().Time);
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::SetSelectionRangeEnd(UVREditorMode* InVRMode)
|
|
{
|
|
ISequencer* CurrentSequencer = InVRMode->GetCurrentSequencer();
|
|
if (CurrentSequencer != nullptr)
|
|
{
|
|
CurrentSequencer->SetSelectionRangeEnd(CurrentSequencer->GetLocalTime().Time);
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::ToggleSequencerScrubbing(UVREditorMode* InVRMode, UVREditorInteractor* InController)
|
|
{
|
|
InController->ToggleSequencerScrubbingMode();
|
|
if (!InController->IsScrubbingSequencer())
|
|
{
|
|
PauseSequencePlayback(InVRMode);
|
|
}
|
|
}
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::GetSequencerScrubState(UVREditorInteractor* InController)
|
|
{
|
|
return InController->IsScrubbingSequencer() ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::ToggleAligningToActors(UVREditorMode* InVRMode)
|
|
{
|
|
if (InVRMode->GetWorldInteraction().AreAligningToActors())
|
|
{
|
|
// Deselect any candidates if we have them
|
|
if (InVRMode->GetWorldInteraction().HasCandidatesSelected())
|
|
{
|
|
ToggleSelectingCandidateActors(InVRMode);
|
|
}
|
|
GUnrealEd->Exec(InVRMode->GetWorld(), TEXT("VI.ActorSnap 0"));
|
|
}
|
|
else
|
|
{
|
|
GUnrealEd->Exec(InVRMode->GetWorld(), TEXT("VI.ActorSnap 1"));
|
|
}
|
|
}
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::AreAligningToActors(UVREditorMode* InVRMode)
|
|
{
|
|
return InVRMode->GetWorldInteraction().AreAligningToActors() ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::ToggleSelectingCandidateActors(UVREditorMode* InVRMode)
|
|
{
|
|
InVRMode->GetWorldInteraction().SetSelectionAsCandidates();
|
|
UpdateSelectingCandidateActorsText(InVRMode);
|
|
}
|
|
|
|
bool FVREditorActionCallbacks::CanSelectCandidateActors(UVREditorMode* InVRMode)
|
|
{
|
|
return InVRMode->GetWorldInteraction().AreAligningToActors();
|
|
}
|
|
|
|
FText FVREditorActionCallbacks::GetSelectingCandidateActorsText()
|
|
{
|
|
return FVREditorActionCallbacks::SelectingCandidateActorsText;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::UpdateSelectingCandidateActorsText(UVREditorMode* InVRMode)
|
|
{
|
|
if (InVRMode->GetWorldInteraction().HasCandidatesSelected())
|
|
{
|
|
FVREditorActionCallbacks::SelectingCandidateActorsText = LOCTEXT("ResetCandidates", "Reset Targets");
|
|
}
|
|
else
|
|
{
|
|
FVREditorActionCallbacks::SelectingCandidateActorsText = LOCTEXT("SetCandidates", "Set Targets");
|
|
}
|
|
}
|
|
|
|
void FVREditorActionCallbacks::ChangeEditorModes(FEditorModeID InMode)
|
|
{
|
|
// *Important* - activate the mode first since FEditorModeTools::DeactivateMode will
|
|
// activate the default mode when the stack becomes empty, resulting in multiple active visible modes.
|
|
GLevelEditorModeTools().ActivateMode(InMode);
|
|
}
|
|
|
|
ECheckBoxState FVREditorActionCallbacks::EditorModeActive(FEditorModeID InMode)
|
|
{
|
|
return GLevelEditorModeTools().IsModeActive(InMode) ? ECheckBoxState::Checked : ECheckBoxState::Unchecked;
|
|
}
|
|
|
|
void FVREditorActionCallbacks::DeselectAll()
|
|
{
|
|
GEditor->SelectNone(true, true, false);
|
|
GEditor->GetSelectedActors()->DeselectAll();
|
|
GEditor->GetSelectedObjects()->DeselectAll();
|
|
}
|
|
|
|
void FVREditorActionCallbacks::ExitVRMode(UVREditorMode* InVRMode)
|
|
{
|
|
InVRMode->StartExitingVRMode();
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|