/** @return true if something was selected/deselected, false otherwise. */
bool FModeTool_GeometryModify::FrustumSelect( const FConvexVolume& InFrustum, bool InSelect /* = true */ )
{
bool bResult = false;
if( GLevelEditorModeTools().IsModeActive( FBuiltinEditorModes::EM_Geometry ) )
{
FEdModeGeometry* mode = (FEdModeGeometry*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_Geometry );
for( FEdModeGeometry::TGeomObjectIterator Itor( mode->GeomObjectItor() ) ; Itor ; ++Itor )
{
FGeomObjectPtr go = *Itor;
FTransform ActorToWorld = go->GetActualBrush()->ActorToWorld();
// Check each vertex to see if its inside the frustum
for( int32 v = 0 ; v < go->VertexPool.Num() ; ++v )
{
FGeomVertex& gv = go->VertexPool[v];
if( InFrustum.IntersectBox( ActorToWorld.TransformPosition( gv.GetMid() ), FVector::ZeroVector ) )
{
gv.Select( InSelect );
bResult = true;
}
}
}
}
return bResult;
}
/** @return true if something was selected/deselected, false otherwise. */
bool FModeTool_GeometryModify::BoxSelect( FBox& InBox, bool InSelect )
{
bool bResult = false;
if( GLevelEditorModeTools().IsModeActive( FBuiltinEditorModes::EM_Geometry ) )
{
FEdModeGeometry* mode = (FEdModeGeometry*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_Geometry );
for( FEdModeGeometry::TGeomObjectIterator Itor( mode->GeomObjectItor() ) ; Itor ; ++Itor )
{
FGeomObjectPtr go = *Itor;
FTransform ActorToWorld = go->GetActualBrush()->ActorToWorld();
// Only verts for box selection
for( int32 v = 0 ; v < go->VertexPool.Num() ; ++v )
{
FGeomVertex& gv = go->VertexPool[v];
if( FMath::PointBoxIntersection( ActorToWorld.TransformPosition( gv.GetMid() ), InBox ) )
{
gv.Select( InSelect );
bResult = true;
}
}
}
}
return bResult;
}
void EditorExit()
{
GLevelEditorModeTools().SetDefaultMode(FBuiltinEditorModes::EM_Default);
GLevelEditorModeTools().DeactivateAllModes(); // this also activates the default mode
// Save out any config settings for the editor so they don't get lost
GEditor->SaveConfig();
GLevelEditorModeTools().SaveConfig();
// Clean up the actor folders singleton
FActorFolders::Cleanup();
// Save out default file directories
FEditorDirectories::Get().SaveLastDirectories();
// Allow the game thread to finish processing any latent tasks.
// Some editor functions may queue tasks that need to be run before the editor is finished.
FTaskGraphInterface::Get().ProcessThreadUntilIdle(ENamedThreads::GameThread);
// Cleanup the misc editor
FUnrealEdMisc::Get().OnExit();
if( GLogConsole )
{
GLogConsole->Show( false );
}
delete GDebugToolExec;
GDebugToolExec = NULL;
}
void SLevelEditorModeContent::HandleParentClosed( TSharedRef<SDockTab> TabBeingClosed )
{
if ( GLevelEditorModeTools().IsModeActive(EditorMode->GetID()) )
{
GLevelEditorModeTools().DeactivateMode(EditorMode->GetID());
}
}
bool FModeTool_InterpEdit::InputDelta(FEditorViewportClient* InViewportClient, FViewport* InViewport, FVector& InDrag, FRotator& InRot, FVector& InScale)
{
check( GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_InterpEdit) );
FEdModeInterpEdit* mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_InterpEdit);
check(mode->InterpEd);
bool bShiftDown = InViewport->KeyState(EKeys::LeftShift) || InViewport->KeyState(EKeys::RightShift);
FVector InputDeltaDrag( InDrag );
// If we are grabbing a 'handle' on the movement curve, pass that info to Matinee
if(bMovingHandle)
{
mode->InterpEd->Move3DHandle( DragGroup, DragTrackIndex, DragKeyIndex, bDragArriving, InputDeltaDrag * (1.f/CurveHandleScale) );
return 1;
}
// If shift is downOnly do 'move initial position' if dragging the widget
else if(bShiftDown && InViewportClient->GetCurrentWidgetAxis() != EAxisList::None)
{
mode->InterpEd->MoveInitialPosition( InputDeltaDrag, InRot );
return 1;
}
InViewportClient->Viewport->Invalidate();
return 0;
}
bool FCreateLandscapeCommand::Update()
{
//Switch to the Landscape tool
GLevelEditorModeTools().ActivateMode(FBuiltinEditorModes::EM_Landscape);
FEdModeLandscape* LandscapeEdMode = (FEdModeLandscape*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_Landscape);
//Modify the "Section size"
LandscapeEdMode->UISettings->NewLandscape_QuadsPerSection = 7;
LandscapeEdMode->UISettings->NewLandscape_ClampSize();
//Create the landscape
TSharedPtr<FLandscapeEditorDetailCustomization_NewLandscape> Customization_NewLandscape = MakeShareable(new FLandscapeEditorDetailCustomization_NewLandscape);
Customization_NewLandscape->OnCreateButtonClicked();
if (LandscapeEdMode->CurrentToolTarget.LandscapeInfo.IsValid())
{
UE_LOG(LogLandscapeAutomationTests, Display, TEXT("Created a new landscape"));
}
else
{
UE_LOG(LogLandscapeAutomationTests, Error, TEXT("Failed to create a new landscape"));
}
return true;
}
void SToolkitDisplay::Construct( const FArguments& InArgs, const TSharedRef< class ILevelEditor >& OwningLevelEditor )
{
OnInlineContentChangedDelegate = InArgs._OnInlineContentChanged;
ChildSlot
[
SAssignNew( VBox, SVerticalBox )
];
// Register with the mode system to find out when a mode is entered or exited
GLevelEditorModeTools().OnEditorModeChanged().AddSP( SharedThis( this ), &SToolkitDisplay::OnEditorModeChanged );
// Find all of the current active modes and toolkits and add those right away. This widget could have been created "late"!
{
TArray< FEdMode* > ActiveModes;
GLevelEditorModeTools().GetActiveModes( ActiveModes );
for( auto EdModeIt = ActiveModes.CreateConstIterator(); EdModeIt; ++EdModeIt )
{
// We don't care about the default editor mode. Just ignore it.
if( (*EdModeIt)->GetID() != FBuiltinEditorModes::EM_Default && !(*EdModeIt)->UsesToolkits() )
{
AddEditorMode( *EdModeIt );
}
}
const TArray< TSharedPtr< IToolkit > >& HostedToolkits = OwningLevelEditor->GetHostedToolkits();
for( auto HostedToolkitIt = HostedToolkits.CreateConstIterator(); HostedToolkitIt; ++HostedToolkitIt )
{
OnToolkitHostingStarted( ( *HostedToolkitIt ).ToSharedRef() );
}
}
}
void EditorExit()
{
GLevelEditorModeTools().SetDefaultMode(FBuiltinEditorModes::EM_Default);
GLevelEditorModeTools().DeactivateAllModes(); // this also activates the default mode
// Save out any config settings for the editor so they don't get lost
GEditor->SaveConfig();
GLevelEditorModeTools().SaveConfig();
// Clean up the actor folders singleton
FActorFolders::Cleanup();
// Save out default file directories
FEditorDirectories::Get().SaveLastDirectories();
// Cleanup the misc editor
FUnrealEdMisc::Get().OnExit();
if( GLogConsole )
{
GLogConsole->Show( false );
}
delete GDebugToolExec;
GDebugToolExec = NULL;
}
const FGeomObjectPtr FGeomBase::GetParentObject() const
{
check( GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_Geometry) );
check( ParentObjectIndex > INDEX_NONE );
const FEdModeGeometry* mode = (FEdModeGeometry*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_Geometry);
return mode->GetGeomObject( ParentObjectIndex );
}
bool FModeTool_InterpEdit::MouseMove(FEditorViewportClient* ViewportClient,FViewport* Viewport,int32 x, int32 y)
{
check( GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_InterpEdit) );
FEdModeInterpEdit* mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_InterpEdit);
return 0;
}
void FEdModeTexture::Enter()
{
FEdMode::Enter();
const bool bGetRawValue = true;
SaveCoordSystem = GLevelEditorModeTools().GetCoordSystem(bGetRawValue);
GLevelEditorModeTools().SetCoordSystem(COORD_Local);
}
void FLevelCollectionModel::UnloadLevels(const FLevelModelList& InLevelList)
{
if (InLevelList.Num() == 0)
{
return;
}
// If matinee is opened, and if it belongs to the level being removed, close it
if (GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_InterpEdit))
{
TArray<ULevel*> LevelsToRemove = GetLevelObjectList(InLevelList);
const FEdModeInterpEdit* InterpEditMode = (const FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_InterpEdit);
if (InterpEditMode && InterpEditMode->MatineeActor && LevelsToRemove.Contains(InterpEditMode->MatineeActor->GetLevel()))
{
GLevelEditorModeTools().ActivateDefaultMode();
}
}
else if(GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_Landscape))
{
GLevelEditorModeTools().ActivateDefaultMode();
}
// Remove each level!
// Take a copy of the list rather than using a reference to the selected levels list, as this will be modified in the loop below
const FLevelModelList LevelListCopy = InLevelList;
for (auto It = LevelListCopy.CreateConstIterator(); It; ++It)
{
TSharedPtr<FLevelModel> LevelModel = (*It);
ULevel* Level = LevelModel->GetLevelObject();
if (Level != NULL && !LevelModel->IsPersistent())
{
// Unselect all actors before removing the level
// This avoids crashing in areas that rely on getting a selected actors level. The level will be invalid after its removed.
for (auto ActorIt = Level->Actors.CreateIterator(); ActorIt; ++ActorIt)
{
Editor->SelectActor((*ActorIt), /*bInSelected=*/ false, /*bSelectEvenIfHidden=*/ false);
}
{
FUnmodifiableObject ImmuneWorld(CurrentWorld.Get());
EditorLevelUtils::RemoveLevelFromWorld(Level);
}
}
}
Editor->ResetTransaction( LOCTEXT("RemoveLevelTransReset", "Removing Levels from World") );
// Collect garbage to clear out the destroyed level
CollectGarbage( GARBAGE_COLLECTION_KEEPFLAGS );
PopulateLevelsList();
}
bool ALandscapePlaceholder::TeleportTo(const FVector& DestLocation, const FRotator& DestRotation, bool bIsATest /*= false*/, bool bNoCheck /*= false*/)
{
bool bResult = Super::TeleportTo(DestLocation, DestRotation, bIsATest, bNoCheck);
GLevelEditorModeTools().ActivateMode(FBuiltinEditorModes::EM_Landscape);
FEdModeLandscape* EdMode = (FEdModeLandscape*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_Landscape);
EdMode->UISettings->NewLandscape_Location = GetActorLocation();
EdMode->UISettings->NewLandscape_Rotation = GetActorRotation();
EdMode->SetCurrentTool("NewLandscape");
return bResult;
}
void UVREditorMode::CycleTransformGizmoHandleType()
{
EGizmoHandleTypes NewGizmoType = (EGizmoHandleTypes)( (uint8)WorldInteraction->GetCurrentGizmoType() + 1 );
if( NewGizmoType > EGizmoHandleTypes::Scale )
{
NewGizmoType = EGizmoHandleTypes::All;
}
// Set coordinate system to local if the next gizmo will be for non-uniform scaling
if ( NewGizmoType == EGizmoHandleTypes::Scale )
{
const ECoordSystem CurrentCoordSystem = WorldInteraction->GetTransformGizmoCoordinateSpace();
if ( CurrentCoordSystem == COORD_World )
{
GLevelEditorModeTools().SetCoordSystem( COORD_Local );
// Remember if coordinate system was in world space before scaling
bWasInWorldSpaceBeforeScaleMode = true;
}
else if ( CurrentCoordSystem == COORD_Local )
{
bWasInWorldSpaceBeforeScaleMode = false;
}
}
else if ( WorldInteraction->GetCurrentGizmoType() == EGizmoHandleTypes::Scale && bWasInWorldSpaceBeforeScaleMode )
{
// Set the coordinate system to world space if the coordinate system was world before scaling
WorldInteraction->SetTransformGizmoCoordinateSpace( COORD_World );
}
WorldInteraction->SetGizmoHandleType( NewGizmoType );
}
void UUnrealEdEngine::NoteSelectionChange()
{
// The selection changed, so make sure the pivot (widget) is located in the right place
UpdatePivotLocationForSelection( true );
// Clear active editing visualizer on selection change
GUnrealEd->ComponentVisManager.ClearActiveComponentVis();
TArray<FEdMode*> ActiveModes;
GLevelEditorModeTools().GetActiveModes( ActiveModes );
for( int32 ModeIndex = 0; ModeIndex < ActiveModes.Num(); ++ModeIndex )
{
ActiveModes[ModeIndex]->ActorSelectionChangeNotify();
}
const bool bComponentSelectionChanged = GetSelectedComponentCount() > 0;
USelection* Selection = bComponentSelectionChanged ? GetSelectedComponents() : GetSelectedActors();
USelection::SelectionChangedEvent.Broadcast(Selection);
if (!bComponentSelectionChanged)
{
//whenever selection changes, recompute whether the selection contains a locked actor
bCheckForLockActors = true;
//whenever selection changes, recompute whether the selection contains a world info actor
bCheckForWorldSettingsActors = true;
UpdateFloatingPropertyWindows();
}
RedrawLevelEditingViewports();
}
void SLevelEditorModeContent::Construct( const FArguments& InArgs, const TSharedRef< class ILevelEditor >& InOwningLevelEditor, const TSharedRef< class SDockTab >& InOwningDocTab, FEdMode* InEditorMode )
{
LevelEditor = InOwningLevelEditor;
DocTab = InOwningDocTab;
EditorMode = InEditorMode;
InOwningDocTab->SetOnTabClosed( SDockTab::FOnTabClosedCallback::CreateSP(this, &SLevelEditorModeContent::HandleParentClosed ) );
GLevelEditorModeTools().OnEditorModeChanged().AddSP( this, &SLevelEditorModeContent::HandleEditorModeChanged );
GEditor->AccessEditorUserSettings().OnUserSettingChanged().AddSP( this, &SLevelEditorModeContent::HandleUserSettingsChange );
ChildSlot
[
SNew( SHorizontalBox )
// The Current Creation Tool
+ SHorizontalBox::Slot()
.FillWidth( 1.0 )
.Padding( 2, 0, 0, 0 )
[
SNew( SVerticalBox )
+ SVerticalBox::Slot()
[
SAssignNew(InlineContentHolder, SBorder)
.BorderImage( FEditorStyle::GetBrush("NoBorder") )
.Padding(0.f)
.Visibility( this, &SLevelEditorModeContent::GetInlineContentHolderVisibility )
]
]
];
UpdateModeToolBar();
}
bool UMatineeTrackVectorPropHelper::PreCreateTrack( UInterpGroup* Group, const UInterpTrack *TrackDef, bool bDuplicatingTrack, bool bAllowPrompts ) const
{
bool bResult = true;
if( bAllowPrompts && bDuplicatingTrack == false )
{
bResult = false;
// For Property tracks - pop up a dialog to choose property name.
TrackAddPropName = NAME_None;
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
check(Mode != NULL);
IMatineeBase* InterpEd = Mode->InterpEd;
check(InterpEd != NULL);
UInterpGroupInst* GrInst = InterpEd->GetMatineeActor()->FindFirstGroupInst(Group);
check(GrInst);
AActor* Actor = GrInst->GetGroupActor();
if ( Actor != NULL )
{
TArray<FName> PropNames;
FMatineeUtils::GetInterpVectorPropertyNames(Actor, PropNames);
bResult = ChooseProperty(PropNames);
}
}
return bResult;
}
bool UMatineeTrackEventHelper::PreCreateKeyframe( UInterpTrack *Track, float KeyTime ) const
{
KeyframeAddDataName = NAME_None;
// Prompt user for name of new event.
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode( FBuiltinEditorModes::EM_InterpEdit );
check(Mode != NULL);
check(Mode->InterpEd != NULL);
TSharedRef<STextEntryPopup> TextEntryPopup =
SNew(STextEntryPopup)
.Label(NSLOCTEXT("Matinee.Popups", "NewEventName", "New Event Name"))
.DefaultText(FText::FromString(TEXT("Event")))
.OnTextCommitted_UObject(this, &UMatineeTrackEventHelper::OnAddKeyTextEntry, (IMatineeBase*)Mode->InterpEd, Track)
.SelectAllTextWhenFocused(true)
.ClearKeyboardFocusOnCommit(false)
.MaxWidth(1024.0f)
;
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if ( Parent.IsValid() )
{
EntryMenu = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
FWidgetPath(),
TextEntryPopup,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::TypeInPopup)
);
}
return false;
}
bool FEdModeTexture::GetCustomDrawingCoordinateSystem( FMatrix& InMatrix, void* InData )
{
// Texture mode is ALWAYS in local space
GLevelEditorModeTools().SetCoordSystem(COORD_Local);
FPoly* poly = NULL;
for ( TSelectedSurfaceIterator<> It(GetWorld()) ; It ; ++It )
{
FBspSurf* Surf = *It;
ABrush* BrushActor = ( ABrush* )Surf->Actor;
if( BrushActor )
{
poly = &BrushActor->Brush->Polys->Element[ Surf->iBrushPoly ];
break;
}
}
if( !poly )
{
return false;
}
InMatrix = FMatrix::Identity;
InMatrix.SetAxis( 2, poly->Normal );
InMatrix.SetAxis( 0, poly->TextureU );
InMatrix.SetAxis( 1, poly->TextureV );
InMatrix.RemoveScaling();
return true;
}
bool FPackageAutoSaver::CanAutoSave() const
{
// Don't allow auto-saving if the auto-save wouldn't save anything
const bool bPackagesNeedAutoSave = DoPackagesNeedAutoSave();
static FName EditableText("SEditableText");
double LastInteractionTime = FSlateApplication::Get().GetLastUserInteractionTime();
const float EditableTextDelay = 15.0f;
TSharedPtr<SWidget> KeyboardFocusedWidget = FSlateApplication::Get().GetKeyboardFocusedWidget();
bool bDidTypeInATextBlockRecently = KeyboardFocusedWidget.IsValid() && KeyboardFocusedWidget->GetType() == EditableText && (FApp::GetCurrentTime() - LastInteractionTime) < EditableTextDelay;
const bool bAutosaveEnabled = GetDefault<UEditorLoadingSavingSettings>()->bAutoSaveEnable && bPackagesNeedAutoSave;
const bool bSlowTask = GIsSlowTask;
const bool bInterpEditMode = GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_InterpEdit);
const bool bPlayWorldValid = GUnrealEd->PlayWorld != nullptr;
const bool bAnyMenusVisible = FSlateApplication::Get().AnyMenusVisible();
const bool bAutomationTesting = GIsAutomationTesting;
const bool bIsInteratcting = FSlateApplication::Get().HasAnyMouseCaptor() || GUnrealEd->IsUserInteracting() || bDidTypeInATextBlockRecently;
const bool bHasGameOrProjectLoaded = FApp::HasGameName();
return (bAutosaveEnabled && !bSlowTask && !bInterpEditMode && !bPlayWorldValid && !bAnyMenusVisible && !bAutomationTesting && !bIsInteratcting && !GIsDemoMode && bHasGameOrProjectLoaded);
}
bool UInterpTrackAkAudioEventHelper::PreCreateKeyframe(UInterpTrack * Track, float KeyTime) const
{
bool bResult = false;
FEdModeInterpEdit* Mode = (FEdModeInterpEdit*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_InterpEdit);
check(Mode != NULL);
IMatineeBase* InterpEd = Mode->InterpEd;
check(InterpEd != NULL);
UAkAudioEvent* SelectedEvent = GEditor->GetSelectedObjects()->GetTop<UAkAudioEvent>();
TSharedRef<SWidget> PropWidget = SNew(SMatineeAkEventKeyFrameAdder)
.SelectedAkEvent(SelectedEvent)
.OnAkEventSet(FOnAkEventSet::CreateUObject(this,&UInterpTrackAkAudioEventHelper::OnAkEventSet, InterpEd, Track));
TSharedPtr< SWindow > Parent = FSlateApplication::Get().GetActiveTopLevelWindow();
if (Parent.IsValid())
{
EntryMenu = FSlateApplication::Get().PushMenu(
Parent.ToSharedRef(),
FWidgetPath(),
PropWidget,
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect(FPopupTransitionEffect::None)
);
}
return bResult;
}
void ULandscapeEditorObject::SetbSnapGizmo(bool InbSnapGizmo)
{
bSnapGizmo = InbSnapGizmo;
FEdModeLandscape* EdMode = (FEdModeLandscape*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_Landscape);
if (EdMode && EdMode->CurrentGizmoActor.IsValid())
{
EdMode->CurrentGizmoActor->bSnapToLandscapeGrid = bSnapGizmo;
}
if (bSnapGizmo)
{
if (EdMode && EdMode->CurrentGizmoActor.IsValid())
{
check(EdMode->CurrentGizmoActor->TargetLandscapeInfo);
const FVector WidgetLocation = EdMode->CurrentGizmoActor->GetActorLocation();
const FRotator WidgetRotation = EdMode->CurrentGizmoActor->GetActorRotation();
const FVector SnappedWidgetLocation = EdMode->CurrentGizmoActor->SnapToLandscapeGrid(WidgetLocation);
const FRotator SnappedWidgetRotation = EdMode->CurrentGizmoActor->SnapToLandscapeGrid(WidgetRotation);
EdMode->CurrentGizmoActor->SetActorLocation(SnappedWidgetLocation, false);
EdMode->CurrentGizmoActor->SetActorRotation(SnappedWidgetRotation);
}
}
}
void FGeomObject::UpdateFromSelectionArray(TArray<struct FGeomSelection>& SelectionArray)
{
FEditorModeTools& Tools = GLevelEditorModeTools();
for (const auto& Selection : SelectionArray)
{
switch (Selection.Type)
{
case GS_Poly:
PolyPool[Selection.Index].ForceSelectionIndex(Selection.SelectionIndex);
break;
case GS_Edge:
EdgePool[Selection.Index].ForceSelectionIndex(Selection.SelectionIndex);
break;
case GS_Vertex:
VertexPool[Selection.Index].ForceSelectionIndex(Selection.SelectionIndex);
break;
}
}
DirtySelectionOrder();
CompileSelectionOrder();
}
bool FBeginModifyLandscapeCommand::Update()
{
//Find the landscape
FEdModeLandscape* LandscapeEdMode = (FEdModeLandscape*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_Landscape);
//Find a location on the edge of the landscape along the x axis so the default camera can see it in the distance.
FVector LandscapeSizePerComponent = LandscapeEdMode->UISettings->NewLandscape_QuadsPerSection * LandscapeEdMode->UISettings->NewLandscape_SectionsPerComponent * LandscapeEdMode->UISettings->NewLandscape_Scale;
FVector TargetLoctaion(0);
TargetLoctaion.X = -LandscapeSizePerComponent.X * (LandscapeEdMode->UISettings->NewLandscape_ComponentCount.X / 2.f);
ALandscapeProxy* Proxy = LandscapeEdMode->CurrentToolTarget.LandscapeInfo.Get()->GetCurrentLevelLandscapeProxy(true);
if (Proxy)
{
TargetLoctaion = Proxy->LandscapeActorToWorld().InverseTransformPosition(TargetLoctaion);
}
//Begin using the sculpting tool
FLevelEditorViewportClient* SelectedViewport = LandscapeTestUtils::FindSelectedViewport();
LandscapeEdMode->CurrentTool->BeginTool(SelectedViewport, LandscapeEdMode->CurrentToolTarget, TargetLoctaion);
SelectedViewport->Invalidate();
UE_LOG(LogLandscapeAutomationTests, Display, TEXT("Modified the landscape using the sculpt tool"));
return true;
}
void UEditorEngine::mapBrushPut()
{
TArray<FEdMode*> ActiveModes;
GLevelEditorModeTools().GetActiveModes( ActiveModes );
for ( FSelectionIterator It( GEditor->GetSelectedActorIterator() ) ; It ; ++It )
{
AActor* Actor = static_cast<AActor*>( *It );
checkSlow( Actor->IsA(AActor::StaticClass()) );
ABrush* BrushActor = Cast< ABrush >( Actor );
if( BrushActor && !FActorEditorUtils::IsABuilderBrush(Actor) )
{
check( BrushActor->GetWorld() );
ABrush* WorldBrush = BrushActor->GetWorld()->GetDefaultBrush();
check( WorldBrush );
BrushActor->Modify();
BrushActor->Brush->Polys->Element = WorldBrush->Brush->Polys->Element;
BrushActor->CopyPosRotScaleFrom( WorldBrush );
BrushActor->SetNeedRebuild(BrushActor->GetLevel());
WorldBrush->ReregisterAllComponents();
for( int32 ModeIndex = 0; ModeIndex < ActiveModes.Num(); ++ModeIndex )
{
ActiveModes[ModeIndex]->UpdateInternalData();
}
}
}
}
AActor* UActorFactoryLandscape::SpawnActor(UObject* Asset, ULevel* InLevel, const FVector& Location, const FRotator& Rotation, EObjectFlags ObjectFlags, const FName& Name)
{
GLevelEditorModeTools().ActivateMode(FBuiltinEditorModes::EM_Landscape);
FEdModeLandscape* EdMode = (FEdModeLandscape*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_Landscape);
EdMode->UISettings->NewLandscape_Location = Location;
EdMode->UISettings->NewLandscape_Rotation = Rotation;
EdMode->SetCurrentTool("NewLandscape");
FActorSpawnParameters SpawnInfo;
SpawnInfo.OverrideLevel = InLevel;
SpawnInfo.ObjectFlags = ObjectFlags;
SpawnInfo.Name = Name;
return InLevel->OwningWorld->SpawnActor(ALandscapePlaceholder::StaticClass(), &Location, &Rotation, SpawnInfo);
}
bool UUnrealEdEngine::CanSelectActor(AActor* Actor, bool bInSelected, bool bSelectEvenIfHidden, bool bWarnIfLevelLocked ) const
{
// If selections are globally locked, leave.
if( !Actor || GEdSelectionLock || !Actor->IsEditable() )
{
return false;
}
// Only abort from hidden actors if we are selecting. You can deselect hidden actors without a problem.
if ( bInSelected )
{
// If the actor is NULL or hidden, leave.
if ( !bSelectEvenIfHidden && ( Actor->IsHiddenEd() || !FLevelUtils::IsLevelVisible( Actor->GetLevel() ) ) )
{
return false;
}
// Ensure that neither the level nor the actor is being destroyed or is unreachable
EObjectFlags InvalidSelectableFlags = RF_PendingKill|RF_BeginDestroyed|RF_Unreachable;
if( Actor->GetLevel()->HasAnyFlags(InvalidSelectableFlags) )
{
UE_LOG(LogEditorSelectUtils, Warning, TEXT("SelectActor: %s (%s)"), TEXT("The requested operation could not be completed because the level has invalid flags."),*Actor->GetActorLabel());
return false;
}
if( Actor->HasAnyFlags(InvalidSelectableFlags) )
{
UE_LOG(LogEditorSelectUtils, Warning, TEXT("SelectActor: %s (%s)"), TEXT("The requested operation could not be completed because the actor has invalid flags."),*Actor->GetActorLabel());
return false;
}
if ( !Actor->IsTemplate() && FLevelUtils::IsLevelLocked(Actor->GetLevel()) )
{
if( bWarnIfLevelLocked )
{
UE_LOG(LogEditorSelectUtils, Warning, TEXT("SelectActor: %s (%s)"), TEXT("The requested operation could not be completed because the level is locked."),*Actor->GetActorLabel());
}
return false;
}
}
// If grouping operations are not currently allowed, don't select groups.
AGroupActor* SelectedGroupActor = Cast<AGroupActor>(Actor);
if( SelectedGroupActor && !GEditor->bGroupingActive )
{
return false;
}
// Allow active modes to determine whether the selection is allowed. If there are no active modes, allow selection anyway.
TArray<FEdMode*> ActiveModes;
GLevelEditorModeTools().GetActiveModes( ActiveModes );
bool bSelectionAllowed = (ActiveModes.Num() == 0);
for( int32 ModeIndex = 0; ModeIndex < ActiveModes.Num(); ++ModeIndex )
{
bSelectionAllowed |= ActiveModes[ModeIndex]->IsSelectionAllowed( Actor, bInSelected );
}
return bSelectionAllowed;
}
bool FEndModifyLandscapeCommand::Update()
{
//Find the landscape
FEdModeLandscape* LandscapeEdMode = (FEdModeLandscape*)GLevelEditorModeTools().GetActiveMode(FBuiltinEditorModes::EM_Landscape);
//End using the sculpting tool
FLevelEditorViewportClient* SelectedViewport = LandscapeTestUtils::FindSelectedViewport();
LandscapeEdMode->CurrentTool->EndTool(SelectedViewport);
return true;
}
void UUnrealEdEngine::NotifyPostChange( const FPropertyChangedEvent& PropertyChangedEvent, UProperty* PropertyThatChanged )
{
// Notify all active modes of actor property changes.
TArray<FEdMode*> ActiveModes;
GLevelEditorModeTools().GetActiveModes( ActiveModes );
for( int32 ModeIndex = 0; ModeIndex < ActiveModes.Num(); ++ModeIndex )
{
ActiveModes[ModeIndex]->ActorPropChangeNotify();
}
}
bool FLevelCollectionModel::IsValidMoveFoliageToLevel() const
{
if (IsOneLevelSelected() &&
AreAllSelectedLevelsEditableAndVisible() &&
GLevelEditorModeTools().IsModeActive(FBuiltinEditorModes::EM_Foliage))
{
return true;
}
return false;
}
