You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
b608402db7
[FYI] mikko.mononen Original CL Desc ----------------------------------------------------------------- State Tree: Copy and paste State Tree states. - Refactored State Tree style to follow more recent style pattern - Added code to ensure that State Tree states outers are always the parent state (fixes issues with FCustomizableTextObjectFactory) - Added support for Cut/Copy/Paste of state tree states (across State Trees) - Improved reporting of bad bindings and state links (compiler & UI) #rb Mieszko.Zielinski #preflight 63ff52bef43e53f68119073e [CL 24469431 by marc audy in ue5-main branch]
596 lines
14 KiB
C++
596 lines
14 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "StateTreeViewModel.h"
|
|
#include "StateTree.h"
|
|
#include "StateTreeEditorData.h"
|
|
#include "StateTreeDelegates.h"
|
|
#include "Editor.h"
|
|
#include "ScopedTransaction.h"
|
|
|
|
|
|
#define LOCTEXT_NAMESPACE "StateTreeEditor"
|
|
|
|
|
|
namespace UE::StateTree::Editor
|
|
{
|
|
// Removes states from the array which are children of any other state.
|
|
void RemoveContainedChildren(TArray<UStateTreeState*>& States)
|
|
{
|
|
TSet<UStateTreeState*> UniqueStates;
|
|
for (UStateTreeState* State : States)
|
|
{
|
|
UniqueStates.Add(State);
|
|
}
|
|
|
|
for (int32 i = 0; i < States.Num(); )
|
|
{
|
|
UStateTreeState* State = States[i];
|
|
|
|
// Walk up the parent state sand if the current state
|
|
// exists in any of them, remove it.
|
|
UStateTreeState* StateParent = State->Parent;
|
|
bool bShouldRemove = false;
|
|
while (StateParent)
|
|
{
|
|
if (UniqueStates.Contains(StateParent))
|
|
{
|
|
bShouldRemove = true;
|
|
break;
|
|
}
|
|
StateParent = StateParent->Parent;
|
|
}
|
|
|
|
if (bShouldRemove)
|
|
{
|
|
States.RemoveAt(i);
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Returns true if the state is child of parent state.
|
|
bool IsChildOf(const UStateTreeState* ParentState, const UStateTreeState* State)
|
|
{
|
|
for (const UStateTreeState* Child : ParentState->Children)
|
|
{
|
|
if (Child == State)
|
|
{
|
|
return true;
|
|
}
|
|
if (IsChildOf(Child, State))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
};
|
|
|
|
|
|
FStateTreeViewModel::FStateTreeViewModel()
|
|
: TreeDataWeak(nullptr)
|
|
{
|
|
}
|
|
|
|
FStateTreeViewModel::~FStateTreeViewModel()
|
|
{
|
|
GEditor->UnregisterForUndo(this);
|
|
|
|
UE::StateTree::Delegates::OnIdentifierChanged.RemoveAll(this);
|
|
}
|
|
|
|
void FStateTreeViewModel::Init(UStateTreeEditorData* InTreeData)
|
|
{
|
|
TreeDataWeak = InTreeData;
|
|
|
|
GEditor->RegisterForUndo(this);
|
|
|
|
UE::StateTree::Delegates::OnIdentifierChanged.AddSP(this, &FStateTreeViewModel::HandleIdentifierChanged);
|
|
}
|
|
|
|
void FStateTreeViewModel::HandleIdentifierChanged(const UStateTree& StateTree) const
|
|
{
|
|
UStateTreeEditorData* TreeData = TreeDataWeak.Get();
|
|
const UStateTree* OuterStateTree = TreeData ? Cast<UStateTree>(TreeData->GetOuter()) : nullptr;
|
|
if (OuterStateTree == &StateTree)
|
|
{
|
|
OnAssetChanged.Broadcast();
|
|
}
|
|
}
|
|
|
|
void FStateTreeViewModel::NotifyAssetChangedExternally() const
|
|
{
|
|
OnAssetChanged.Broadcast();
|
|
}
|
|
|
|
void FStateTreeViewModel::NotifyStatesChangedExternally(const TSet<UStateTreeState*>& ChangedStates, const FPropertyChangedEvent& PropertyChangedEvent) const
|
|
{
|
|
OnStatesChanged.Broadcast(ChangedStates, PropertyChangedEvent);
|
|
}
|
|
|
|
TArray<UStateTreeState*>* FStateTreeViewModel::GetSubTrees() const
|
|
{
|
|
UStateTreeEditorData* TreeData = TreeDataWeak.Get();
|
|
return TreeData != nullptr ? &ToRawPtrTArrayUnsafe(TreeData->SubTrees) : nullptr;
|
|
}
|
|
|
|
int32 FStateTreeViewModel::GetSubTreeCount() const
|
|
{
|
|
UStateTreeEditorData* TreeData = TreeDataWeak.Get();
|
|
return TreeData != nullptr ? TreeData->SubTrees.Num() : 0;
|
|
}
|
|
|
|
void FStateTreeViewModel::GetSubTrees(TArray<TWeakObjectPtr<UStateTreeState>>& OutSubtrees) const
|
|
{
|
|
OutSubtrees.Reset();
|
|
if (UStateTreeEditorData* TreeData = TreeDataWeak.Get())
|
|
{
|
|
for (UStateTreeState* Subtree : TreeData->SubTrees)
|
|
{
|
|
OutSubtrees.Add(Subtree);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FStateTreeViewModel::PostUndo(bool bSuccess)
|
|
{
|
|
// TODO: see if we can narrow this down.
|
|
OnAssetChanged.Broadcast();
|
|
}
|
|
|
|
void FStateTreeViewModel::PostRedo(bool bSuccess)
|
|
{
|
|
OnAssetChanged.Broadcast();
|
|
}
|
|
|
|
void FStateTreeViewModel::ClearSelection()
|
|
{
|
|
SelectedStates.Reset();
|
|
|
|
const TArray<TWeakObjectPtr<UStateTreeState>> SelectedStatesArr;
|
|
OnSelectionChanged.Broadcast(SelectedStatesArr);
|
|
}
|
|
|
|
void FStateTreeViewModel::SetSelection(UStateTreeState* Selected)
|
|
{
|
|
SelectedStates.Reset();
|
|
|
|
SelectedStates.Add(Selected);
|
|
|
|
TArray<TWeakObjectPtr<UStateTreeState>> SelectedStatesArr;
|
|
SelectedStatesArr.Add(Selected);
|
|
OnSelectionChanged.Broadcast(SelectedStatesArr);
|
|
}
|
|
|
|
void FStateTreeViewModel::SetSelection(const TArray<TWeakObjectPtr<UStateTreeState>>& InSelectedStates)
|
|
{
|
|
SelectedStates.Reset();
|
|
|
|
for (const TWeakObjectPtr<UStateTreeState>& State : InSelectedStates)
|
|
{
|
|
if (State.Get())
|
|
{
|
|
SelectedStates.Add(State);
|
|
}
|
|
}
|
|
|
|
TArray<FGuid> SelectedTaskIDArr;
|
|
OnSelectionChanged.Broadcast(InSelectedStates);
|
|
}
|
|
|
|
bool FStateTreeViewModel::IsSelected(const UStateTreeState* State) const
|
|
{
|
|
const TWeakObjectPtr<UStateTreeState> WeakState = const_cast<UStateTreeState*>(State);
|
|
return SelectedStates.Contains(WeakState);
|
|
}
|
|
|
|
bool FStateTreeViewModel::IsChildOfSelection(const UStateTreeState* State) const
|
|
{
|
|
for (const TWeakObjectPtr<UStateTreeState>& WeakSelectedState : SelectedStates)
|
|
{
|
|
if (const UStateTreeState* SelectedState = Cast<UStateTreeState>(WeakSelectedState.Get()))
|
|
{
|
|
if (SelectedState == State)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (UE::StateTree::Editor::IsChildOf(SelectedState, State))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void FStateTreeViewModel::GetSelectedStates(TArray<UStateTreeState*>& OutSelectedStates)
|
|
{
|
|
OutSelectedStates.Reset();
|
|
for (TWeakObjectPtr<UStateTreeState>& WeakState : SelectedStates)
|
|
{
|
|
if (UStateTreeState* State = WeakState.Get())
|
|
{
|
|
OutSelectedStates.Add(State);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FStateTreeViewModel::GetSelectedStates(TArray<TWeakObjectPtr<UStateTreeState>>& OutSelectedStates)
|
|
{
|
|
OutSelectedStates.Reset();
|
|
for (TWeakObjectPtr<UStateTreeState>& WeakState : SelectedStates)
|
|
{
|
|
if (WeakState.Get())
|
|
{
|
|
OutSelectedStates.Add(WeakState);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool FStateTreeViewModel::HasSelection() const
|
|
{
|
|
return SelectedStates.Num() > 0;
|
|
}
|
|
|
|
void FStateTreeViewModel::GetPersistentExpandedStates(TSet<TWeakObjectPtr<UStateTreeState>>& OutExpandedStates)
|
|
{
|
|
OutExpandedStates.Reset();
|
|
if (UStateTreeEditorData* TreeData = TreeDataWeak.Get())
|
|
{
|
|
for (UStateTreeState* SubTree : TreeData->SubTrees)
|
|
{
|
|
GetExpandedStatesRecursive(SubTree, OutExpandedStates);
|
|
}
|
|
}
|
|
}
|
|
|
|
void FStateTreeViewModel::GetExpandedStatesRecursive(UStateTreeState* State, TSet<TWeakObjectPtr<UStateTreeState>>& OutExpandedStates)
|
|
{
|
|
if (State->bExpanded)
|
|
{
|
|
OutExpandedStates.Add(State);
|
|
}
|
|
for (UStateTreeState* Child : State->Children)
|
|
{
|
|
GetExpandedStatesRecursive(Child, OutExpandedStates);
|
|
}
|
|
}
|
|
|
|
|
|
void FStateTreeViewModel::SetPersistentExpandedStates(TSet<TWeakObjectPtr<UStateTreeState>>& InExpandedStates)
|
|
{
|
|
UStateTreeEditorData* TreeData = TreeDataWeak.Get();
|
|
if (TreeData == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TreeData->Modify();
|
|
|
|
for (TWeakObjectPtr<UStateTreeState>& WeakState : InExpandedStates)
|
|
{
|
|
if (UStateTreeState* State = WeakState.Get())
|
|
{
|
|
State->bExpanded = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FStateTreeViewModel::AddState(UStateTreeState* AfterState)
|
|
{
|
|
UStateTreeEditorData* TreeData = TreeDataWeak.Get();
|
|
if (TreeData == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const FScopedTransaction Transaction(LOCTEXT("AddStateTransaction", "Add State"));
|
|
|
|
UStateTreeState* NewState = NewObject<UStateTreeState>(TreeData, FName(), RF_Transactional);
|
|
UStateTreeState* ParentState = nullptr;
|
|
|
|
if (AfterState == nullptr)
|
|
{
|
|
// If no subtrees, add a subtree, or add to the root state.
|
|
if (TreeData->SubTrees.IsEmpty())
|
|
{
|
|
TreeData->Modify();
|
|
TreeData->SubTrees.Add(NewState);
|
|
}
|
|
else
|
|
{
|
|
UStateTreeState* RootState = TreeData->SubTrees[0];
|
|
if (ensureMsgf(RootState, TEXT("%s: Root state is empty."), *GetNameSafe(TreeData->GetOuter())))
|
|
{
|
|
RootState->Modify();
|
|
RootState->Children.Add(NewState);
|
|
NewState->Parent = RootState;
|
|
ParentState = RootState;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ParentState = AfterState->Parent;
|
|
if (ParentState != nullptr)
|
|
{
|
|
ParentState->Modify();
|
|
}
|
|
else
|
|
{
|
|
TreeData->Modify();
|
|
}
|
|
|
|
TArray<UStateTreeState*>& ParentArray = ParentState ? ParentState->Children : TreeData->SubTrees;
|
|
|
|
const int32 TargetIndex = ParentArray.Find(AfterState);
|
|
if (TargetIndex != INDEX_NONE)
|
|
{
|
|
// Insert After
|
|
ParentArray.Insert(NewState, TargetIndex + 1);
|
|
NewState->Parent = ParentState;
|
|
}
|
|
else
|
|
{
|
|
// Fallback, should never happen.
|
|
ensureMsgf(false, TEXT("%s: Failed to find specified target state %s on state %s while adding new state."), *GetNameSafe(TreeData->GetOuter()), *GetNameSafe(AfterState), *GetNameSafe(ParentState));
|
|
ParentArray.Add(NewState);
|
|
NewState->Parent = ParentState;
|
|
}
|
|
}
|
|
|
|
OnStateAdded.Broadcast(ParentState, NewState);
|
|
}
|
|
|
|
void FStateTreeViewModel::AddChildState(UStateTreeState* ParentState)
|
|
{
|
|
UStateTreeEditorData* TreeData = TreeDataWeak.Get();
|
|
if (TreeData == nullptr || ParentState == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const FScopedTransaction Transaction(LOCTEXT("AddChildStateTransaction", "Add Child State"));
|
|
|
|
UStateTreeState* NewState = NewObject<UStateTreeState>(ParentState, FName(), RF_Transactional);
|
|
|
|
ParentState->Modify();
|
|
|
|
ParentState->Children.Add(NewState);
|
|
NewState->Parent = ParentState;
|
|
|
|
OnStateAdded.Broadcast(ParentState, NewState);
|
|
}
|
|
|
|
void FStateTreeViewModel::RenameState(UStateTreeState* State, FName NewName)
|
|
{
|
|
if (State == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
const FScopedTransaction Transaction(LOCTEXT("RenameTransaction", "Rename"));
|
|
State->Modify();
|
|
State->Name = NewName;
|
|
|
|
TSet<UStateTreeState*> AffectedStates;
|
|
AffectedStates.Add(State);
|
|
|
|
FProperty* NameProperty = FindFProperty<FProperty>(UStateTreeState::StaticClass(), GET_MEMBER_NAME_CHECKED(UStateTreeState, Name));
|
|
FPropertyChangedEvent PropertyChangedEvent(NameProperty, EPropertyChangeType::ValueSet);
|
|
OnStatesChanged.Broadcast(AffectedStates, PropertyChangedEvent);
|
|
}
|
|
|
|
void FStateTreeViewModel::RemoveSelectedStates()
|
|
{
|
|
UStateTreeEditorData* TreeData = TreeDataWeak.Get();
|
|
if (TreeData == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TArray<UStateTreeState*> States;
|
|
GetSelectedStates(States);
|
|
|
|
// Remove items whose parent also exists in the selection.
|
|
UE::StateTree::Editor::RemoveContainedChildren(States);
|
|
|
|
if (States.Num() > 0)
|
|
{
|
|
const FScopedTransaction Transaction(LOCTEXT("DeleteStateTransaction", "Delete State"));
|
|
|
|
TSet<UStateTreeState*> AffectedParents;
|
|
|
|
for (UStateTreeState* StateToRemove : States)
|
|
{
|
|
if (StateToRemove)
|
|
{
|
|
StateToRemove->Modify();
|
|
|
|
UStateTreeState* ParentState = StateToRemove->Parent;
|
|
if (ParentState != nullptr)
|
|
{
|
|
AffectedParents.Add(ParentState);
|
|
ParentState->Modify();
|
|
}
|
|
else
|
|
{
|
|
AffectedParents.Add(nullptr);
|
|
TreeData->Modify();
|
|
}
|
|
|
|
TArray<UStateTreeState*>& ArrayToRemoveFrom = ParentState ? ParentState->Children : TreeData->SubTrees;
|
|
const int32 ItemIndex = ArrayToRemoveFrom.Find(StateToRemove);
|
|
if (ItemIndex != INDEX_NONE)
|
|
{
|
|
ArrayToRemoveFrom.RemoveAt(ItemIndex);
|
|
StateToRemove->Parent = nullptr;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
OnStatesRemoved.Broadcast(AffectedParents);
|
|
|
|
ClearSelection();
|
|
}
|
|
}
|
|
|
|
void FStateTreeViewModel::MoveSelectedStatesBefore(UStateTreeState* TargetState)
|
|
{
|
|
MoveSelectedStates(TargetState, FStateTreeViewModelInsert::Before);
|
|
}
|
|
|
|
void FStateTreeViewModel::MoveSelectedStatesAfter(UStateTreeState* TargetState)
|
|
{
|
|
MoveSelectedStates(TargetState, FStateTreeViewModelInsert::After);
|
|
}
|
|
|
|
void FStateTreeViewModel::MoveSelectedStatesInto(UStateTreeState* TargetState)
|
|
{
|
|
MoveSelectedStates(TargetState, FStateTreeViewModelInsert::Into);
|
|
}
|
|
|
|
void FStateTreeViewModel::MoveSelectedStates(UStateTreeState* TargetState, const FStateTreeViewModelInsert RelativeLocation)
|
|
{
|
|
UStateTreeEditorData* TreeData = TreeDataWeak.Get();
|
|
if (TreeData == nullptr || TargetState == nullptr)
|
|
{
|
|
return;
|
|
}
|
|
|
|
TArray<UStateTreeState*> States;
|
|
GetSelectedStates(States);
|
|
|
|
// Remove child items whose parent also exists in the selection.
|
|
UE::StateTree::Editor::RemoveContainedChildren(States);
|
|
|
|
// Remove states which contain target state as child.
|
|
States.RemoveAll([TargetState](const UStateTreeState* State)
|
|
{
|
|
return UE::StateTree::Editor::IsChildOf(State, TargetState);
|
|
});
|
|
|
|
if (States.Num() > 0 && TargetState != nullptr)
|
|
{
|
|
const FScopedTransaction Transaction(LOCTEXT("MoveTransaction", "Move"));
|
|
|
|
TSet<UStateTreeState*> AffectedParents;
|
|
TSet<UStateTreeState*> AffectedStates;
|
|
|
|
UStateTreeState* TargetParent = TargetState->Parent;
|
|
if (RelativeLocation == FStateTreeViewModelInsert::Into)
|
|
{
|
|
AffectedParents.Add(TargetState);
|
|
}
|
|
else
|
|
{
|
|
AffectedParents.Add(TargetParent);
|
|
}
|
|
|
|
for (int32 i = States.Num() - 1; i >= 0; i--)
|
|
{
|
|
if (UStateTreeState* State = States[i])
|
|
{
|
|
State->Modify();
|
|
if (State->Parent)
|
|
{
|
|
AffectedParents.Add(State->Parent);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (RelativeLocation == FStateTreeViewModelInsert::Into)
|
|
{
|
|
// Move into
|
|
TargetState->Modify();
|
|
}
|
|
|
|
for (UStateTreeState* Parent : AffectedParents)
|
|
{
|
|
if (Parent)
|
|
{
|
|
Parent->Modify();
|
|
}
|
|
else
|
|
{
|
|
TreeData->Modify();
|
|
}
|
|
}
|
|
|
|
// Add in reverse order to keep the original order.
|
|
for (int32 i = States.Num() - 1; i >= 0; i--)
|
|
{
|
|
if (UStateTreeState* SelectedState = States[i])
|
|
{
|
|
AffectedStates.Add(SelectedState);
|
|
|
|
UStateTreeState* SelectedParent = SelectedState->Parent;
|
|
|
|
// Remove from current parent
|
|
TArray<UStateTreeState*>& ArrayToRemoveFrom = SelectedParent ? SelectedParent->Children : TreeData->SubTrees;
|
|
const int32 ItemIndex = ArrayToRemoveFrom.Find(SelectedState);
|
|
if (ItemIndex != INDEX_NONE)
|
|
{
|
|
ArrayToRemoveFrom.RemoveAt(ItemIndex);
|
|
SelectedState->Parent = nullptr;
|
|
}
|
|
|
|
// Insert to new parent
|
|
if (RelativeLocation == FStateTreeViewModelInsert::Into)
|
|
{
|
|
// Into
|
|
TargetState->Children.Insert(SelectedState, /*Index*/0);
|
|
SelectedState->Parent = TargetState;
|
|
}
|
|
else
|
|
{
|
|
TArray<UStateTreeState*>& ArrayToMoveTo = TargetParent ? TargetParent->Children : TreeData->SubTrees;
|
|
const int32 TargetIndex = ArrayToMoveTo.Find(TargetState);
|
|
if (TargetIndex != INDEX_NONE)
|
|
{
|
|
if (RelativeLocation == FStateTreeViewModelInsert::Before)
|
|
{
|
|
// Before
|
|
ArrayToMoveTo.Insert(SelectedState, TargetIndex);
|
|
SelectedState->Parent = TargetParent;
|
|
}
|
|
else if (RelativeLocation == FStateTreeViewModelInsert::After)
|
|
{
|
|
// After
|
|
ArrayToMoveTo.Insert(SelectedState, TargetIndex + 1);
|
|
SelectedState->Parent = TargetParent;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fallback, should never happen.
|
|
ensureMsgf(false, TEXT("%s: Failed to find specified target state %s on state %s while moving a state."), *GetNameSafe(TreeData->GetOuter()), *GetNameSafe(TargetState), *GetNameSafe(SelectedParent));
|
|
ArrayToMoveTo.Add(SelectedState);
|
|
SelectedState->Parent = TargetParent;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
OnStatesMoved.Broadcast(AffectedParents, AffectedStates);
|
|
|
|
TArray<TWeakObjectPtr<UStateTreeState>> WeakStates;
|
|
for (UStateTreeState* State : States)
|
|
{
|
|
WeakStates.Add(State);
|
|
}
|
|
|
|
SetSelection(WeakStates);
|
|
}
|
|
}
|
|
|
|
|
|
#undef LOCTEXT_NAMESPACE
|