886 lines
30 KiB
C++
886 lines
30 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "CoreMinimal.h"
|
|
#include "Misc/FeedbackContext.h"
|
|
#include "Modules/ModuleManager.h"
|
|
#include "Components/ActorComponent.h"
|
|
#include "Components/SceneComponent.h"
|
|
#include "GameFramework/Actor.h"
|
|
#include "Components/PrimitiveComponent.h"
|
|
#include "Editor/UnrealEdEngine.h"
|
|
#include "Editor/GroupActor.h"
|
|
#include "Components/ChildActorComponent.h"
|
|
#include "Components/DecalComponent.h"
|
|
#include "Kismet2/ComponentEditorUtils.h"
|
|
#include "Engine/Selection.h"
|
|
#include "EdMode.h"
|
|
#include "EditorModeManager.h"
|
|
#include "EditorModes.h"
|
|
#include "Dialogs/Dialogs.h"
|
|
#include "UnrealEdGlobals.h"
|
|
#include "ScopedTransaction.h"
|
|
#include "Engine/LevelStreaming.h"
|
|
#include "LevelUtils.h"
|
|
#include "StatsViewerModule.h"
|
|
#include "SnappingUtils.h"
|
|
#include "Logging/MessageLog.h"
|
|
#include "ActorGroupingUtils.h"
|
|
#include "Subsystems/BrushEditingSubsystem.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "EditorSelectUtils"
|
|
|
|
DEFINE_LOG_CATEGORY_STATIC(LogEditorSelectUtils, Log, All);
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
Globals.
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
// Click flags.
|
|
enum EViewportClick
|
|
{
|
|
CF_MOVE_ACTOR = 1, // Set if the actors have been moved since first click
|
|
CF_MOVE_TEXTURE = 2, // Set if textures have been adjusted since first click
|
|
CF_MOVE_ALL = (CF_MOVE_ACTOR | CF_MOVE_TEXTURE),
|
|
};
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
Change transacting.
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
void UUnrealEdEngine::NoteActorMovement()
|
|
{
|
|
if (!GUndo && !(GEditor->ClickFlags & CF_MOVE_ACTOR))
|
|
{
|
|
GEditor->ClickFlags |= CF_MOVE_ACTOR;
|
|
|
|
const FScopedTransaction Transaction(NSLOCTEXT("UnrealEd", "ActorMovement", "Actor Movement"));
|
|
GLevelEditorModeTools().Snapping = 0;
|
|
|
|
AActor* SelectedActor = NULL;
|
|
for (FSelectionIterator It(GetSelectedActorIterator()); It; ++It)
|
|
{
|
|
AActor* Actor = static_cast<AActor*>(*It);
|
|
checkSlow(Actor->IsA(AActor::StaticClass()));
|
|
|
|
SelectedActor = Actor;
|
|
break;
|
|
}
|
|
|
|
if (SelectedActor == NULL)
|
|
{
|
|
USelection* SelectedActors = GetSelectedActors();
|
|
SelectedActors->Modify();
|
|
SelectActor(GWorld->GetDefaultBrush(), true, true);
|
|
}
|
|
|
|
// Look for an actor that requires snapping.
|
|
for (FSelectionIterator It(GetSelectedActorIterator()); It; ++It)
|
|
{
|
|
AActor* Actor = static_cast<AActor*>(*It);
|
|
checkSlow(Actor->IsA(AActor::StaticClass()));
|
|
|
|
GLevelEditorModeTools().Snapping = 1;
|
|
break;
|
|
}
|
|
|
|
TSet<AGroupActor*> GroupActors;
|
|
|
|
// Modify selected actors.
|
|
for (FSelectionIterator It(GetSelectedActorIterator()); It; ++It)
|
|
{
|
|
AActor* Actor = static_cast<AActor*>(*It);
|
|
checkSlow(Actor->IsA(AActor::StaticClass()));
|
|
|
|
Actor->Modify();
|
|
|
|
if (UActorGroupingUtils::IsGroupingActive())
|
|
{
|
|
// if this actor is in a group, add the GroupActor into a list to be modified shortly
|
|
AGroupActor* ActorLockedRootGroup = AGroupActor::GetRootForActor(Actor, true);
|
|
if (ActorLockedRootGroup != nullptr)
|
|
{
|
|
GroupActors.Add(ActorLockedRootGroup);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Modify unique group actors
|
|
for (auto* GroupActor: GroupActors)
|
|
{
|
|
GroupActor->Modify();
|
|
}
|
|
}
|
|
}
|
|
|
|
void UUnrealEdEngine::FinishAllSnaps()
|
|
{
|
|
if (!IsRunningCommandlet())
|
|
{
|
|
if (ClickFlags & CF_MOVE_ACTOR)
|
|
{
|
|
ClickFlags &= ~CF_MOVE_ACTOR;
|
|
|
|
for (FSelectionIterator It(GetSelectedActorIterator()); It; ++It)
|
|
{
|
|
AActor* Actor = static_cast<AActor*>(*It);
|
|
checkSlow(Actor->IsA(AActor::StaticClass()));
|
|
|
|
Actor->Modify();
|
|
Actor->InvalidateLightingCache();
|
|
Actor->PostEditMove(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UUnrealEdEngine::Cleanse(bool ClearSelection, bool Redraw, const FText& Reason)
|
|
{
|
|
if (GIsRunning)
|
|
{
|
|
FMessageLog("MapCheck").NewPage(LOCTEXT("MapCheck", "Map Check"));
|
|
|
|
FMessageLog("LightingResults").NewPage(LOCTEXT("LightingBuildNewLogPage", "Lighting Build"));
|
|
|
|
FStatsViewerModule& StatsViewerModule = FModuleManager::Get().LoadModuleChecked<FStatsViewerModule>(TEXT("StatsViewer"));
|
|
StatsViewerModule.Clear();
|
|
}
|
|
|
|
Super::Cleanse(ClearSelection, Redraw, Reason);
|
|
}
|
|
|
|
FVector UUnrealEdEngine::GetPivotLocation()
|
|
{
|
|
return GLevelEditorModeTools().PivotLocation;
|
|
}
|
|
|
|
void UUnrealEdEngine::SetPivot(FVector NewPivot, bool bSnapPivotToGrid, bool bIgnoreAxis, bool bAssignPivot /*=false*/)
|
|
{
|
|
FEditorModeTools& EditorModeTools = GLevelEditorModeTools();
|
|
|
|
if (!bIgnoreAxis)
|
|
{
|
|
// Don't stomp on orthonormal axis.
|
|
// TODO: this breaks if there is genuinely a need to set the pivot to a coordinate containing a zero component
|
|
if (NewPivot.X == 0)
|
|
NewPivot.X = EditorModeTools.PivotLocation.X;
|
|
if (NewPivot.Y == 0)
|
|
NewPivot.Y = EditorModeTools.PivotLocation.Y;
|
|
if (NewPivot.Z == 0)
|
|
NewPivot.Z = EditorModeTools.PivotLocation.Z;
|
|
}
|
|
|
|
// Set the pivot.
|
|
EditorModeTools.SetPivotLocation(NewPivot, false);
|
|
|
|
if (bSnapPivotToGrid)
|
|
{
|
|
FRotator DummyRotator(0, 0, 0);
|
|
FSnappingUtils::SnapToBSPVertex(EditorModeTools.SnappedLocation, EditorModeTools.GridBase, DummyRotator);
|
|
EditorModeTools.PivotLocation = EditorModeTools.SnappedLocation;
|
|
}
|
|
|
|
// Check all actors.
|
|
int32 Count = 0, SnapCount = 0;
|
|
|
|
// default to using the x axis for the translate rotate widget
|
|
EditorModeTools.TranslateRotateXAxisAngle = 0.0f;
|
|
EditorModeTools.TranslateRotate2DAngle = 0.0f;
|
|
FVector TranslateRotateWidgetWorldXAxis;
|
|
|
|
FVector Widget2DWorldXAxis;
|
|
|
|
AActor* LastSelectedActor = NULL;
|
|
for (FSelectionIterator It(GetSelectedActorIterator()); It; ++It)
|
|
{
|
|
AActor* Actor = static_cast<AActor*>(*It);
|
|
checkSlow(Actor->IsA(AActor::StaticClass()));
|
|
|
|
if (Count == 0)
|
|
{
|
|
TranslateRotateWidgetWorldXAxis = Actor->ActorToWorld().TransformVector(FVector(1.0f, 0.0f, 0.0f));
|
|
// get the xy plane project of this vector
|
|
TranslateRotateWidgetWorldXAxis.Z = 0.0f;
|
|
if (!TranslateRotateWidgetWorldXAxis.Normalize())
|
|
{
|
|
TranslateRotateWidgetWorldXAxis = FVector(1.0f, 0.0f, 0.0f);
|
|
}
|
|
|
|
Widget2DWorldXAxis = Actor->ActorToWorld().TransformVector(FVector(1, 0, 0));
|
|
Widget2DWorldXAxis.Y = 0;
|
|
if (!Widget2DWorldXAxis.Normalize())
|
|
{
|
|
Widget2DWorldXAxis = FVector(1, 0, 0);
|
|
}
|
|
}
|
|
|
|
LastSelectedActor = Actor;
|
|
++Count;
|
|
++SnapCount;
|
|
}
|
|
|
|
if (bAssignPivot && LastSelectedActor && UActorGroupingUtils::IsGroupingActive())
|
|
{
|
|
// set group pivot for the root-most group
|
|
AGroupActor* ActorGroupRoot = AGroupActor::GetRootForActor(LastSelectedActor, true, true);
|
|
if (ActorGroupRoot)
|
|
{
|
|
ActorGroupRoot->SetActorLocation(EditorModeTools.PivotLocation, false);
|
|
}
|
|
}
|
|
|
|
// if there are multiple actors selected, just use the x-axis for the "translate/rotate" or 2D widgets
|
|
if (Count == 1)
|
|
{
|
|
EditorModeTools.TranslateRotateXAxisAngle = TranslateRotateWidgetWorldXAxis.Rotation().Yaw;
|
|
EditorModeTools.TranslateRotate2DAngle = FMath::RadiansToDegrees(FMath::Atan2(Widget2DWorldXAxis.Z, Widget2DWorldXAxis.X));
|
|
}
|
|
|
|
// Update showing.
|
|
EditorModeTools.PivotShown = SnapCount > 0 || Count > 1;
|
|
}
|
|
|
|
void UUnrealEdEngine::ResetPivot()
|
|
{
|
|
GLevelEditorModeTools().PivotShown = 0;
|
|
GLevelEditorModeTools().Snapping = 0;
|
|
GLevelEditorModeTools().SnappedActor = 0;
|
|
}
|
|
|
|
/*-----------------------------------------------------------------------------
|
|
Selection.
|
|
-----------------------------------------------------------------------------*/
|
|
|
|
void UUnrealEdEngine::SetActorSelectionFlags(AActor* InActor)
|
|
{
|
|
TInlineComponentArray<UActorComponent*> Components;
|
|
InActor->GetComponents(Components);
|
|
|
|
// for every component in the actor
|
|
for (int32 ComponentIndex = 0; ComponentIndex < Components.Num(); ComponentIndex++)
|
|
{
|
|
UActorComponent* Component = Components[ComponentIndex];
|
|
if (Component->IsRegistered())
|
|
{
|
|
// If we have a 'child actor' component, want to update its visible selection state
|
|
UChildActorComponent* ChildActorComponent = Cast<UChildActorComponent>(Component);
|
|
if (ChildActorComponent != NULL && ChildActorComponent->GetChildActor() != NULL)
|
|
{
|
|
SetActorSelectionFlags(ChildActorComponent->GetChildActor());
|
|
}
|
|
|
|
UPrimitiveComponent* PrimComponent = Cast<UPrimitiveComponent>(Component);
|
|
if (PrimComponent != NULL && PrimComponent->IsRegistered())
|
|
{
|
|
PrimComponent->PushSelectionToProxy();
|
|
}
|
|
|
|
UDecalComponent* DecalComponent = Cast<UDecalComponent>(Component);
|
|
if (DecalComponent != NULL) // && DecalComponent->IsRegistered())
|
|
{
|
|
DecalComponent->PushSelectionToProxy();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UUnrealEdEngine::SetPivotMovedIndependently(bool bMovedIndependently)
|
|
{
|
|
bPivotMovedIndependently = bMovedIndependently;
|
|
}
|
|
|
|
bool UUnrealEdEngine::IsPivotMovedIndependently() const
|
|
{
|
|
return bPivotMovedIndependently;
|
|
}
|
|
|
|
void UUnrealEdEngine::UpdatePivotLocationForSelection(bool bOnChange)
|
|
{
|
|
// Pick a new common pivot, or not.
|
|
AActor* SingleActor = nullptr;
|
|
USceneComponent* SingleComponent = nullptr;
|
|
|
|
if (GetSelectedComponentCount() > 0)
|
|
{
|
|
for (FSelectedEditableComponentIterator It(*GetSelectedComponents()); It; ++It)
|
|
{
|
|
UActorComponent* Component = CastChecked<UActorComponent>(*It);
|
|
AActor* ComponentOwner = Component->GetOwner();
|
|
|
|
if (ComponentOwner != nullptr)
|
|
{
|
|
USelection* SelectedActors = GetSelectedActors();
|
|
const bool bIsOwnerSelected = SelectedActors->IsSelected(ComponentOwner);
|
|
ensureMsgf(bIsOwnerSelected, TEXT("Owner(%s) of %s is not selected"), *ComponentOwner->GetFullName(), *Component->GetFullName());
|
|
|
|
if (ComponentOwner->GetWorld() == GWorld)
|
|
{
|
|
SingleActor = ComponentOwner;
|
|
if (Component->IsA<USceneComponent>())
|
|
{
|
|
SingleComponent = CastChecked<USceneComponent>(Component);
|
|
}
|
|
|
|
const bool IsTemplate = ComponentOwner->IsTemplate();
|
|
const bool LevelLocked = !FLevelUtils::IsLevelLocked(ComponentOwner->GetLevel());
|
|
check(IsTemplate || LevelLocked);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (FSelectionIterator It(GetSelectedActorIterator()); It; ++It)
|
|
{
|
|
AActor* Actor = static_cast<AActor*>(*It);
|
|
checkSlow(Actor->IsA(AActor::StaticClass()));
|
|
|
|
const bool IsTemplate = Actor->IsTemplate();
|
|
const bool LevelLocked = !FLevelUtils::IsLevelLocked(Actor->GetLevel());
|
|
check(IsTemplate || LevelLocked);
|
|
|
|
SingleActor = Actor;
|
|
}
|
|
}
|
|
|
|
if (SingleComponent != NULL)
|
|
{
|
|
SetPivot(SingleComponent->GetComponentLocation(), false, true);
|
|
}
|
|
else if (SingleActor != NULL)
|
|
{
|
|
UBrushEditingSubsystem* BrushSubsystem = GEditor->GetEditorSubsystem<UBrushEditingSubsystem>();
|
|
const bool bGeometryMode = BrushSubsystem ? BrushSubsystem->IsGeometryEditorModeActive() : false;
|
|
|
|
// For geometry mode use current pivot location as it's set to selected face, not actor
|
|
if (!bGeometryMode || bOnChange == true)
|
|
{
|
|
// Set pivot point to the actor's location, accounting for any set pivot offset
|
|
FVector PivotPoint = SingleActor->GetTransform().TransformPosition(SingleActor->GetPivotOffset());
|
|
|
|
// If grouping is active, see if this actor is part of a locked group and use that pivot instead
|
|
if (UActorGroupingUtils::IsGroupingActive())
|
|
{
|
|
AGroupActor* ActorGroupRoot = AGroupActor::GetRootForActor(SingleActor, true, true);
|
|
if (ActorGroupRoot)
|
|
{
|
|
PivotPoint = ActorGroupRoot->GetActorLocation();
|
|
}
|
|
}
|
|
SetPivot(PivotPoint, false, true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ResetPivot();
|
|
}
|
|
|
|
SetPivotMovedIndependently(false);
|
|
}
|
|
|
|
void UUnrealEdEngine::NoteSelectionChange(bool bNotify)
|
|
{
|
|
// The selection changed, so make sure the pivot (widget) is located in the right place
|
|
UpdatePivotLocationForSelection(true);
|
|
|
|
// Clear active editing visualizer on selection change
|
|
ComponentVisManager.ClearActiveComponentVis();
|
|
|
|
GLevelEditorModeTools().ActorSelectionChangeNotify();
|
|
|
|
const bool bComponentSelectionChanged = GetSelectedComponentCount() > 0;
|
|
if (bNotify)
|
|
{
|
|
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 UUnrealEdEngine::SelectGroup(AGroupActor* InGroupActor, bool bForceSelection /*=false*/, bool bInSelected /*=true*/, bool bNotify /*=true*/)
|
|
{
|
|
USelection* SelectedActors = GetSelectedActors();
|
|
bool bStartedBatchSelect = false;
|
|
if (!SelectedActors->IsBatchSelecting())
|
|
{
|
|
bStartedBatchSelect = true;
|
|
// These will have already been called when batch selecting
|
|
SelectedActors->BeginBatchSelectOperation();
|
|
SelectedActors->Modify();
|
|
}
|
|
|
|
static bool bIteratingGroups = false;
|
|
|
|
if (!bIteratingGroups)
|
|
{
|
|
bIteratingGroups = true;
|
|
// Select all actors within the group (if locked or forced)
|
|
if (bForceSelection || InGroupActor->IsLocked())
|
|
{
|
|
TArray<AActor*> GroupActors;
|
|
InGroupActor->GetGroupActors(GroupActors);
|
|
for (int32 ActorIndex = 0; ActorIndex < GroupActors.Num(); ++ActorIndex)
|
|
{
|
|
SelectActor(GroupActors[ActorIndex], bInSelected, false);
|
|
}
|
|
bForceSelection = true;
|
|
|
|
// Recursively select any subgroups
|
|
TArray<AGroupActor*> SubGroups;
|
|
InGroupActor->GetSubGroups(SubGroups);
|
|
for (int32 GroupIndex = 0; GroupIndex < SubGroups.Num(); ++GroupIndex)
|
|
{
|
|
SelectGroup(SubGroups[GroupIndex], bForceSelection, bInSelected, false);
|
|
}
|
|
}
|
|
|
|
if (bStartedBatchSelect)
|
|
{
|
|
SelectedActors->EndBatchSelectOperation(bNotify);
|
|
}
|
|
if (bNotify)
|
|
{
|
|
NoteSelectionChange();
|
|
}
|
|
|
|
// 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;
|
|
|
|
bIteratingGroups = false;
|
|
}
|
|
}
|
|
|
|
bool UUnrealEdEngine::CanSelectActor(AActor* Actor, bool bInSelected, bool bSelectEvenIfHidden, bool bWarnIfLevelLocked) const
|
|
{
|
|
// If selections are globally locked, leave.
|
|
if (!Actor || !Actor->GetLevel() || 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;
|
|
}
|
|
|
|
// If the actor explicitly makes itself unselectable, leave.
|
|
if (!Actor->IsSelectable())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Ensure that neither the level nor the actor is being destroyed or is unreachable
|
|
const EObjectFlags InvalidSelectableFlags = RF_BeginDestroyed;
|
|
if (Actor->GetLevel()->HasAnyFlags(InvalidSelectableFlags) || Actor->GetLevel()->IsPendingKillOrUnreachable())
|
|
{
|
|
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) || Actor->IsPendingKillOrUnreachable())
|
|
{
|
|
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 && !UActorGroupingUtils::IsGroupingActive())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Allow active modes to determine whether the selection is allowed.
|
|
return GLevelEditorModeTools().IsSelectionAllowed(Actor, bInSelected);
|
|
}
|
|
|
|
void UUnrealEdEngine::SelectActor(AActor* Actor, bool bInSelected, bool bNotify, bool bSelectEvenIfHidden, bool bForceRefresh)
|
|
{
|
|
const bool bWarnIfLevelLocked = true;
|
|
if (!CanSelectActor(Actor, bInSelected, bSelectEvenIfHidden, bWarnIfLevelLocked))
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool bSelectionHandled = GLevelEditorModeTools().IsSelectionHandled(Actor, bInSelected);
|
|
|
|
// Select the actor and update its internals.
|
|
if (!bSelectionHandled)
|
|
{
|
|
if (bInSelected)
|
|
{
|
|
// If trying to select an Actor spawned by a ChildActorComponent, instead iterate up the hierarchy until we find a valid actor to select
|
|
while (Actor->IsChildActor())
|
|
{
|
|
Actor = Actor->GetParentComponent()->GetOwner();
|
|
}
|
|
}
|
|
|
|
if (UActorGroupingUtils::IsGroupingActive())
|
|
{
|
|
// if this actor is a group, do a group select/deselect
|
|
AGroupActor* SelectedGroupActor = Cast<AGroupActor>(Actor);
|
|
if (SelectedGroupActor)
|
|
{
|
|
SelectGroup(SelectedGroupActor, true, bInSelected, bNotify);
|
|
}
|
|
else
|
|
{
|
|
// Select/Deselect this actor's entire group, starting from the top locked group.
|
|
// If none is found, just use the actor.
|
|
AGroupActor* ActorLockedRootGroup = AGroupActor::GetRootForActor(Actor, true);
|
|
if (ActorLockedRootGroup)
|
|
{
|
|
SelectGroup(ActorLockedRootGroup, false, bInSelected, bNotify);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Don't do any work if the actor's selection state is already the selected state.
|
|
const bool bActorSelected = Actor->IsSelected();
|
|
if (bActorSelected != bInSelected)
|
|
{
|
|
if (bInSelected)
|
|
{
|
|
UE_LOG(LogEditorSelectUtils, Verbose, TEXT("Selected Actor: %s"), *Actor->GetClass()->GetName());
|
|
}
|
|
else
|
|
{
|
|
UE_LOG(LogEditorSelectUtils, Verbose, TEXT("Deselected Actor: %s"), *Actor->GetClass()->GetName());
|
|
}
|
|
|
|
GetSelectedActors()->Select(Actor, bInSelected);
|
|
if (!bInSelected)
|
|
{
|
|
if (GetSelectedComponentCount() > 0)
|
|
{
|
|
GetSelectedComponents()->Modify();
|
|
}
|
|
|
|
GetSelectedComponents()->BeginBatchSelectOperation();
|
|
for (UActorComponent* Component: Actor->GetComponents())
|
|
{
|
|
if (Component)
|
|
{
|
|
GetSelectedComponents()->Deselect(Component);
|
|
|
|
// Remove the selection override delegates from the deselected components
|
|
if (USceneComponent* SceneComponent = Cast<USceneComponent>(Component))
|
|
{
|
|
FComponentEditorUtils::BindComponentSelectionOverride(SceneComponent, false);
|
|
}
|
|
}
|
|
}
|
|
GetSelectedComponents()->EndBatchSelectOperation(false);
|
|
}
|
|
else
|
|
{
|
|
// Bind the override delegates for the components in the selected actor
|
|
for (UActorComponent* Component: Actor->GetComponents())
|
|
{
|
|
if (USceneComponent* SceneComponent = Cast<USceneComponent>(Component))
|
|
{
|
|
FComponentEditorUtils::BindComponentSelectionOverride(SceneComponent, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bNotify)
|
|
{
|
|
NoteSelectionChange();
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
else
|
|
{
|
|
if (bNotify || bForceRefresh)
|
|
{
|
|
// reset the property windows. In case something has changed since previous selection
|
|
UpdateFloatingPropertyWindows(bForceRefresh);
|
|
}
|
|
}
|
|
|
|
// A fast path to mark selection rather than reconnecting ALL components for ALL actors that have changed state
|
|
SetActorSelectionFlags(Actor);
|
|
}
|
|
}
|
|
|
|
void UUnrealEdEngine::SelectComponent(UActorComponent* Component, bool bInSelected, bool bNotify, bool bSelectEvenIfHidden)
|
|
{
|
|
// Don't do any work if the component's selection state matches the target selection state
|
|
const bool bComponentSelected = GetSelectedComponents()->IsSelected(Component);
|
|
if ((bComponentSelected && !bInSelected) || (!bComponentSelected && bInSelected))
|
|
{
|
|
if (bInSelected)
|
|
{
|
|
UE_LOG(LogEditorSelectUtils, Verbose, TEXT("Selected Component: %s"), *Component->GetClass()->GetName());
|
|
}
|
|
else
|
|
{
|
|
UE_LOG(LogEditorSelectUtils, Verbose, TEXT("Deselected Component: %s"), *Component->GetClass()->GetName());
|
|
}
|
|
|
|
GetSelectedComponents()->Select(Component, bInSelected);
|
|
|
|
// Make sure the override delegate is bound properly
|
|
USceneComponent* SceneComponent = Cast<USceneComponent>(Component);
|
|
if (SceneComponent)
|
|
{
|
|
FComponentEditorUtils::BindComponentSelectionOverride(SceneComponent, true);
|
|
}
|
|
|
|
// Update the selection visualization
|
|
AActor* ComponentOwner = Component->GetOwner();
|
|
if (ComponentOwner != nullptr)
|
|
{
|
|
TInlineComponentArray<UPrimitiveComponent*> PrimitiveComponents;
|
|
ComponentOwner->GetComponents(PrimitiveComponents);
|
|
|
|
for (int32 Idx = 0; Idx < PrimitiveComponents.Num(); ++Idx)
|
|
{
|
|
PrimitiveComponents[Idx]->PushSelectionToProxy();
|
|
}
|
|
}
|
|
|
|
if (bNotify)
|
|
{
|
|
NoteSelectionChange();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool UUnrealEdEngine::IsComponentSelected(const UPrimitiveComponent* PrimComponent)
|
|
{
|
|
bool bIsSelected = false;
|
|
if (GetSelectedComponentCount() > 0)
|
|
{
|
|
const UActorComponent* PotentiallySelectedComponent = nullptr;
|
|
|
|
AActor* ComponentOwner = PrimComponent->GetOwner();
|
|
if (ComponentOwner->IsChildActor())
|
|
{
|
|
do
|
|
{
|
|
PotentiallySelectedComponent = ComponentOwner->GetParentComponent();
|
|
ComponentOwner = ComponentOwner->GetParentActor();
|
|
} while (ComponentOwner->IsChildActor());
|
|
}
|
|
else
|
|
{
|
|
PotentiallySelectedComponent = (PrimComponent->IsVisualizationComponent() ? PrimComponent->GetAttachParent() : PrimComponent);
|
|
}
|
|
|
|
bIsSelected = GetSelectedComponents()->IsSelected(PotentiallySelectedComponent);
|
|
}
|
|
|
|
return bIsSelected;
|
|
}
|
|
|
|
void UUnrealEdEngine::SelectBSPSurf(UModel* InModel, int32 iSurf, bool bSelected, bool bNoteSelectionChange)
|
|
{
|
|
if (GEdSelectionLock)
|
|
{
|
|
return;
|
|
}
|
|
|
|
FBspSurf& Surf = InModel->Surfs[iSurf];
|
|
InModel->ModifySurf(iSurf, false);
|
|
|
|
if (bSelected)
|
|
{
|
|
Surf.PolyFlags |= PF_Selected;
|
|
}
|
|
else
|
|
{
|
|
Surf.PolyFlags &= ~PF_Selected;
|
|
}
|
|
|
|
if (bNoteSelectionChange)
|
|
{
|
|
NoteSelectionChange();
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
/**
|
|
* Deselects all BSP surfaces in the specified level.
|
|
*
|
|
* @param Level The level for which to deselect all levels.
|
|
* @return The number of surfaces that were deselected
|
|
*/
|
|
static uint32 DeselectAllSurfacesForLevel(ULevel* Level)
|
|
{
|
|
uint32 NumSurfacesDeselected = 0;
|
|
if (Level)
|
|
{
|
|
UModel* Model = Level->Model;
|
|
for (int32 SurfaceIndex = 0; SurfaceIndex < Model->Surfs.Num(); ++SurfaceIndex)
|
|
{
|
|
FBspSurf& Surf = Model->Surfs[SurfaceIndex];
|
|
if (Surf.PolyFlags & PF_Selected)
|
|
{
|
|
Model->ModifySurf(SurfaceIndex, false);
|
|
Surf.PolyFlags &= ~PF_Selected;
|
|
++NumSurfacesDeselected;
|
|
}
|
|
}
|
|
}
|
|
return NumSurfacesDeselected;
|
|
}
|
|
|
|
void UUnrealEdEngine::DeselectAllSurfaces()
|
|
{
|
|
UWorld* World = GWorld;
|
|
if (World)
|
|
{
|
|
DeselectAllSurfacesForLevel(World->PersistentLevel);
|
|
for (ULevelStreaming* StreamingLevel: World->GetStreamingLevels())
|
|
{
|
|
if (StreamingLevel)
|
|
{
|
|
if (ULevel* Level = StreamingLevel->GetLoadedLevel())
|
|
{
|
|
DeselectAllSurfacesForLevel(Level);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UUnrealEdEngine::SelectNone(bool bNoteSelectionChange, bool bDeselectBSPSurfs, bool WarnAboutManyActors)
|
|
{
|
|
if (GEdSelectionLock)
|
|
{
|
|
return;
|
|
}
|
|
|
|
bool bShowProgress = false;
|
|
|
|
// If there are a lot of actors to process, pop up a warning "are you sure?" box
|
|
if (WarnAboutManyActors)
|
|
{
|
|
int32 NumSelectedActors = GEditor->GetSelectedActorCount();
|
|
if (NumSelectedActors >= EditorActorSelectionDefs::MaxActorsToSelectBeforeWarning)
|
|
{
|
|
bShowProgress = true;
|
|
|
|
const FText ConfirmText = FText::Format(NSLOCTEXT("UnrealEd", "Warning_ManyActorsForDeselect", "There are {0} selected actors. Are you sure you want to deselect them all?"), FText::AsNumber(NumSelectedActors));
|
|
|
|
FSuppressableWarningDialog::FSetupInfo Info(ConfirmText, NSLOCTEXT("UnrealEd", "Warning_ManyActors", "Warning: Many Actors"), "Warning_ManyActors");
|
|
Info.ConfirmText = NSLOCTEXT("ModalDialogs", "ManyActorsForDeselectConfirm", "Continue Deselection");
|
|
Info.CancelText = NSLOCTEXT("ModalDialogs", "ManyActorsForDeselectCancel", "Keep Current Selection");
|
|
|
|
FSuppressableWarningDialog ManyActorsWarning(Info);
|
|
if (ManyActorsWarning.ShowModal() == FSuppressableWarningDialog::Cancel)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bShowProgress)
|
|
{
|
|
GWarn->BeginSlowTask(LOCTEXT("BeginDeselectingActorsTaskMessage", "Deselecting Actors"), true);
|
|
}
|
|
|
|
// Make a list of selected actors . . .
|
|
TArray<AActor*> ActorsToDeselect;
|
|
for (FSelectionIterator It(GetSelectedActorIterator()); It; ++It)
|
|
{
|
|
AActor* Actor = static_cast<AActor*>(*It);
|
|
checkSlow(Actor->IsA(AActor::StaticClass()));
|
|
|
|
ActorsToDeselect.Add(Actor);
|
|
}
|
|
|
|
USelection* SelectedActors = GetSelectedActors();
|
|
SelectedActors->BeginBatchSelectOperation();
|
|
SelectedActors->Modify();
|
|
|
|
// . . . and deselect them.
|
|
for (int32 ActorIndex = 0; ActorIndex < ActorsToDeselect.Num(); ++ActorIndex)
|
|
{
|
|
AActor* Actor = ActorsToDeselect[ActorIndex];
|
|
SelectActor(Actor, false, false);
|
|
}
|
|
|
|
uint32 NumDeselectSurfaces = 0;
|
|
UWorld* World = GWorld;
|
|
if (bDeselectBSPSurfs && World)
|
|
{
|
|
// Unselect all surfaces in all levels.
|
|
NumDeselectSurfaces += DeselectAllSurfacesForLevel(World->PersistentLevel);
|
|
for (ULevelStreaming* StreamingLevel: World->GetStreamingLevels())
|
|
{
|
|
if (StreamingLevel)
|
|
{
|
|
if (ULevel* Level = StreamingLevel->GetLoadedLevel())
|
|
{
|
|
NumDeselectSurfaces += DeselectAllSurfacesForLevel(Level);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
SelectedActors->EndBatchSelectOperation(bNoteSelectionChange);
|
|
|
|
// prevents clicking on background multiple times spamming selection changes
|
|
if (ActorsToDeselect.Num() || NumDeselectSurfaces)
|
|
{
|
|
if (bNoteSelectionChange)
|
|
{
|
|
NoteSelectionChange();
|
|
}
|
|
|
|
// 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;
|
|
}
|
|
|
|
if (bShowProgress)
|
|
{
|
|
GWarn->EndSlowTask();
|
|
}
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|