1148 lines
37 KiB
C++
1148 lines
37 KiB
C++
// Copyright Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "AnimGraphNode_LinkedAnimLayer.h"
|
|
#include "Components/SkeletalMeshComponent.h"
|
|
#include "Widgets/Text/STextBlock.h"
|
|
#include "Widgets/Input/SCheckBox.h"
|
|
#include "EdGraphSchema_K2.h"
|
|
#include "Kismet2/CompilerResultsLog.h"
|
|
#include "Kismet2/BlueprintEditorUtils.h"
|
|
#include "PropertyHandle.h"
|
|
#include "DetailLayoutBuilder.h"
|
|
#include "DetailCategoryBuilder.h"
|
|
#include "Animation/AnimNode_LinkedInputPose.h"
|
|
#include "PropertyCustomizationHelpers.h"
|
|
#include "ScopedTransaction.h"
|
|
#include "AnimationGraphSchema.h"
|
|
#include "Widgets/Layout/SBox.h"
|
|
#include "UObject/CoreRedirects.h"
|
|
#include "Kismet2/KismetEditorUtilities.h"
|
|
#include "AnimationStateGraph.h"
|
|
#include "BlueprintNodeSpawner.h"
|
|
#include "UObject/FortniteMainBranchObjectVersion.h"
|
|
#include "BlueprintActionDatabaseRegistrar.h"
|
|
#include "ObjectEditorUtils.h"
|
|
#include "AssetRegistry/AssetRegistryModule.h"
|
|
#include "EditorClassUtils.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "LinkedAnimLayerNode"
|
|
|
|
namespace LinkedAnimLayerGraphNodeConstants
|
|
{
|
|
FLinearColor TitleColorSelfLayer(0.2f, 0.07f, 0.6f);
|
|
FLinearColor TitleColorLinkedLayer(0.45f, 0.f, 0.7f);
|
|
}
|
|
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::Serialize(FArchive& Ar)
|
|
{
|
|
Super::Serialize(Ar);
|
|
|
|
Ar.UsingCustomVersion(FFortniteMainBranchObjectVersion::GUID);
|
|
|
|
if (Ar.IsLoading())
|
|
{
|
|
if (Ar.CustomVer(FFortniteMainBranchObjectVersion::GUID) < FFortniteMainBranchObjectVersion::AnimLayerGuidConformation)
|
|
{
|
|
if (!InterfaceGuid.IsValid())
|
|
{
|
|
InterfaceGuid = GetGuidForLayer();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::ReconstructNode()
|
|
{
|
|
if(SetObjectBeingDebuggedHandle.IsValid())
|
|
{
|
|
GetBlueprint()->OnSetObjectBeingDebugged().Remove(SetObjectBeingDebuggedHandle);
|
|
}
|
|
|
|
SetObjectBeingDebuggedHandle = GetBlueprint()->OnSetObjectBeingDebugged().AddUObject(this, &UAnimGraphNode_LinkedAnimLayer::HandleSetObjectBeingDebugged);
|
|
|
|
Super::ReconstructNode();
|
|
}
|
|
|
|
FSlateIcon UAnimGraphNode_LinkedAnimLayer::GetIconAndTint(FLinearColor& OutColor) const
|
|
{
|
|
return FSlateIcon(FAppStyle::GetAppStyleSetName(), "ClassIcon.AnimLayerInterface");
|
|
}
|
|
|
|
FText UAnimGraphNode_LinkedAnimLayer::GetTooltipText() const
|
|
{
|
|
return LOCTEXT("ToolTip", "Runs another linked animation layer graph to process animation");
|
|
}
|
|
|
|
FAnimNode_LinkedAnimLayer* UAnimGraphNode_LinkedAnimLayer::GetPreviewNode() const
|
|
{
|
|
FAnimNode_LinkedAnimLayer* PreviewNode = nullptr;
|
|
USkeletalMeshComponent* Component = nullptr;
|
|
|
|
// look for a valid component in the object being debugged,
|
|
// we might be set to something other than the preview.
|
|
UObject* ObjectBeingDebugged = GetAnimBlueprint()->GetObjectBeingDebugged();
|
|
if (ObjectBeingDebugged)
|
|
{
|
|
UAnimInstance* InstanceBeingDebugged = Cast<UAnimInstance>(ObjectBeingDebugged);
|
|
if (InstanceBeingDebugged)
|
|
{
|
|
Component = InstanceBeingDebugged->GetSkelMeshComponent();
|
|
}
|
|
}
|
|
|
|
if (Component != nullptr && Component->GetAnimInstance() != nullptr)
|
|
{
|
|
PreviewNode = static_cast<FAnimNode_LinkedAnimLayer*>(FindDebugAnimNode(Component));
|
|
}
|
|
|
|
return PreviewNode;
|
|
}
|
|
|
|
FText UAnimGraphNode_LinkedAnimLayer::GetNodeTitle(ENodeTitleType::Type TitleType) const
|
|
{
|
|
UClass* TargetClass = *Node.Interface;
|
|
UAnimBlueprint* TargetAnimBlueprintInterface = TargetClass ? CastChecked<UAnimBlueprint>(TargetClass->ClassGeneratedBy) : nullptr;
|
|
|
|
const FText DefaultNodeTitle = LOCTEXT("NodeTitle", "Linked Anim Layer");
|
|
if(TitleType == ENodeTitleType::MenuTitle)
|
|
{
|
|
return DefaultNodeTitle;
|
|
}
|
|
else
|
|
{
|
|
bool bIsSelf = TargetAnimBlueprintInterface == nullptr;
|
|
|
|
FFormatNamedArguments Args;
|
|
Args.Add(TEXT("NodeType"), bIsSelf ? LOCTEXT("SelfLayerNodeTitle", "Anim Layer (self)") : DefaultNodeTitle);
|
|
Args.Add(TEXT("TargetClass"), bIsSelf ? LOCTEXT("ClassSelf", "Self") : FText::FromString(TargetAnimBlueprintInterface->GetName()));
|
|
Args.Add(TEXT("Layer"), (GetLayerName() == NAME_None) ? LOCTEXT("LayerNone", "None") : FText::FromName(GetLayerName()));
|
|
|
|
if (TitleType == ENodeTitleType::ListView)
|
|
{
|
|
if(bIsSelf)
|
|
{
|
|
return FText::Format(LOCTEXT("TitleListViewFormatSelf", "{Layer}"), Args);
|
|
}
|
|
else
|
|
{
|
|
return FText::Format(LOCTEXT("TitleListViewFormat", "{TargetClass} - {Layer}"), Args);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (FAnimNode_LinkedAnimLayer* PreviewNode = GetPreviewNode())
|
|
{
|
|
if (UAnimInstance* PreviewAnimInstance = PreviewNode->GetTargetInstance<UAnimInstance>())
|
|
{
|
|
if (UClass* PreviewTargetClass = PreviewAnimInstance->GetClass())
|
|
{
|
|
bIsSelf = PreviewTargetClass == GetAnimBlueprint()->GeneratedClass;
|
|
Args.Add(TEXT("TargetClass"), PreviewTargetClass == GetAnimBlueprint()->GeneratedClass ? LOCTEXT("ClassSelf", "Self") : FText::FromName(PreviewTargetClass->GetFName()));
|
|
}
|
|
}
|
|
}
|
|
|
|
if(bIsSelf)
|
|
{
|
|
return FText::Format(LOCTEXT("TitleOtherFormatSelf", "{Layer}\n{NodeType}"), Args);
|
|
}
|
|
else
|
|
{
|
|
return FText::Format(LOCTEXT("TitleOtherFormat", "{TargetClass} - {Layer}\n{NodeType}"), Args);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::ValidateAnimNodeDuringCompilation(USkeleton* ForSkeleton, FCompilerResultsLog& MessageLog)
|
|
{
|
|
Super::ValidateAnimNodeDuringCompilation(ForSkeleton, MessageLog);
|
|
|
|
if(GetLayerName() == NAME_None)
|
|
{
|
|
MessageLog.Error(*LOCTEXT("NoLayerError", "Linked anim layer node @@ does not specify a layer.").ToString(), this);
|
|
}
|
|
else
|
|
{
|
|
UAnimBlueprint* CurrentBlueprint = Cast<UAnimBlueprint>(GetBlueprint());
|
|
|
|
// check layer actually exists in the interface
|
|
UClass* TargetClass = *Node.Interface;
|
|
if(TargetClass == nullptr)
|
|
{
|
|
// If no interface specified, use this class
|
|
if (CurrentBlueprint)
|
|
{
|
|
TargetClass = *CurrentBlueprint->SkeletonGeneratedClass;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// check we implement this interface
|
|
bool bImplementsInterface = false;
|
|
|
|
if (CurrentBlueprint)
|
|
{
|
|
for (FBPInterfaceDescription& InterfaceDesc : CurrentBlueprint->ImplementedInterfaces)
|
|
{
|
|
if (InterfaceDesc.Interface.Get() == TargetClass)
|
|
{
|
|
bImplementsInterface = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!bImplementsInterface)
|
|
{
|
|
// Its possible we have a left-over interface referenced here that needs clearing now we are a 'self' layer
|
|
if(GetInterfaceForLayer() == nullptr)
|
|
{
|
|
Node.Interface = nullptr;
|
|
|
|
// No interface any more, use this class
|
|
if (CurrentBlueprint)
|
|
{
|
|
TargetClass = *CurrentBlueprint->SkeletonGeneratedClass;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MessageLog.Error(*LOCTEXT("MissingInterfaceError", "Linked anim layer node @@ uses interface @@ that this blueprint does not implement.").ToString(), this, Node.Interface.Get());
|
|
}
|
|
}
|
|
}
|
|
|
|
if(TargetClass)
|
|
{
|
|
bool bFoundFunction = false;
|
|
IAnimClassInterface* AnimClassInterface = IAnimClassInterface::GetFromClass(TargetClass);
|
|
for(const FAnimBlueprintFunction& AnimBlueprintFunction : AnimClassInterface->GetAnimBlueprintFunctions())
|
|
{
|
|
if(AnimBlueprintFunction.Name == GetLayerName())
|
|
{
|
|
bFoundFunction = true;
|
|
}
|
|
}
|
|
|
|
if(!bFoundFunction)
|
|
{
|
|
MessageLog.Error(*FText::Format(LOCTEXT("MissingLayerError", "Linked anim layer node @@ uses invalid layer '{0}'."), FText::FromName(GetLayerName())).ToString(), this);
|
|
}
|
|
}
|
|
|
|
if(CurrentBlueprint)
|
|
{
|
|
UAnimGraphNode_LinkedAnimLayer* OriginalThis = Cast<UAnimGraphNode_LinkedAnimLayer>(MessageLog.FindSourceObject(this));
|
|
|
|
TArray<UEdGraph*> Graphs;
|
|
CurrentBlueprint->GetAllGraphs(Graphs);
|
|
|
|
auto ValidateOuterGraph = [this, OriginalThis, &MessageLog](const UEdGraph* InGraph)
|
|
{
|
|
static const FName DefaultAnimGraphName("AnimGraph");
|
|
if (!InGraph->IsA<UAnimationStateGraph>() && InGraph->GetFName() != DefaultAnimGraphName && InGraph->InterfaceGuid.IsValid() && OriginalThis->InterfaceGuid.IsValid())
|
|
{
|
|
MessageLog.Error(*FText::Format(LOCTEXT("NestedLayer", "Linked anim layer node @@ is part of Animation Layer Graph '{0}', linked layers cannot be nested."), FText::FromName(InGraph->GetFName())).ToString(), this);
|
|
}
|
|
};
|
|
|
|
// Gather all linked anim layer node instances in this blueprint
|
|
TArray<UAnimGraphNode_LinkedAnimLayer*> AllLayerNodes;
|
|
for (const UEdGraph* Graph : Graphs)
|
|
{
|
|
Graph->GetNodesOfClass(AllLayerNodes);
|
|
}
|
|
|
|
// Check for duplicates
|
|
for (const UAnimGraphNode_LinkedAnimLayer* LayerNode : AllLayerNodes)
|
|
{
|
|
if (LayerNode != OriginalThis)
|
|
{
|
|
if (LayerNode->GetLayerName() == GetLayerName())
|
|
{
|
|
MessageLog.Error(*FText::Format(LOCTEXT("DuplicateLayerError", "Linked anim layer node @@ is also used by graph '{0}', layers can be used only once in an animation blueprint."), FText::FromName(LayerNode->GetGraph()->GetFName())).ToString(), this);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for circular references and indirect nesting
|
|
for (const UEdGraph* Graph : Graphs)
|
|
{
|
|
if (Graph->GetFName() == OriginalThis->Node.Layer)
|
|
{
|
|
TArray<const UEdGraph*> GraphStack;
|
|
bool bWithinLinkedAnimLayer = OriginalThis->InterfaceGuid.IsValid();
|
|
|
|
UEdGraph* OuterGraph = OriginalThis->GetGraph();
|
|
// If our outer graph is a linked layer interface function that has no instance in the blueprint, we need to validate it for nesting as it can still be instanciated through the application of a linked layer
|
|
if (OuterGraph->InterfaceGuid.IsValid())
|
|
{
|
|
bool bCheckOuter = false;
|
|
for (const UAnimGraphNode_LinkedAnimLayer* LayerNode : AllLayerNodes)
|
|
{
|
|
if (LayerNode->Node.Layer == OuterGraph->GetFName())
|
|
{
|
|
bCheckOuter = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Check outer graph for nested linked layers
|
|
if (bCheckOuter)
|
|
{
|
|
static const FName DefaultAnimGraphName("AnimGraph");
|
|
if (OuterGraph->GetFName() != DefaultAnimGraphName)
|
|
{
|
|
ValidateOuterGraph(OuterGraph);
|
|
|
|
// Add outer graph to graph stack
|
|
GraphStack.Add(OuterGraph);
|
|
// If outer graph is a linked layer interface, account for it to properly detect nesting
|
|
bWithinLinkedAnimLayer = bWithinLinkedAnimLayer || OuterGraph->InterfaceGuid.IsValid();
|
|
}
|
|
}
|
|
}
|
|
|
|
ValidateCircularRefAndNesting(Graph, Graphs, GraphStack, bWithinLinkedAnimLayer, MessageLog);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::ValidateCircularRefAndNesting(const UEdGraph* CurrentGraph, const TArray<UEdGraph*>& AllGraphs, TArray<const UEdGraph*> GraphStack, bool bWithinLinkedLayerGraph, FCompilerResultsLog& MessageLog)
|
|
{
|
|
// Build graph chain string
|
|
auto BuildGraphChainString = [](const TArray<const UEdGraph*>& GraphStack) -> FString
|
|
{
|
|
TStringBuilder<1024> GraphChain;
|
|
bool bFirst = true;
|
|
for (const UEdGraph* Graph : GraphStack)
|
|
{
|
|
if (!bFirst)
|
|
{
|
|
GraphChain << TEXT("->");
|
|
}
|
|
GraphChain << *Graph->GetName();
|
|
bFirst = false;
|
|
}
|
|
return FString(GraphChain);
|
|
};
|
|
|
|
// If a graph is already in the stack we have a circular reference
|
|
if (GraphStack.Contains(CurrentGraph))
|
|
{
|
|
// Add the redundant graph so the error is easier to understand
|
|
GraphStack.Add(CurrentGraph);
|
|
MessageLog.Error(*FText::Format(LOCTEXT("CircularLayerReference", "Anim layer node @@ in Graph '{0}' has a circular dependency '{1}'."), FText::FromName(Node.Layer), FText::FromString(BuildGraphChainString(GraphStack))).ToString(), this);
|
|
return;
|
|
}
|
|
|
|
GraphStack.Add(CurrentGraph);
|
|
|
|
// Find layer nodes and recursively check their graphs
|
|
TArray<UAnimGraphNode_LinkedAnimLayer*> LayerNodes;
|
|
CurrentGraph->GetNodesOfClass(LayerNodes);
|
|
for (const UAnimGraphNode_LinkedAnimLayer* LayerNode : LayerNodes)
|
|
{
|
|
// Check for linked anim layer nesting
|
|
if (bWithinLinkedLayerGraph && LayerNode->InterfaceGuid.IsValid())
|
|
{
|
|
if (GraphStack.Num() == 1)
|
|
{
|
|
MessageLog.Error(*FText::Format(LOCTEXT("NestedLayer", "Linked anim layer node @@ is part of Animation Layer Graph '{0}', linked layers cannot be nested."), FText::FromName(CurrentGraph->GetFName())).ToString(), LayerNode);
|
|
}
|
|
else
|
|
{
|
|
MessageLog.Error(*FText::Format(LOCTEXT("IndirectlyNestedLayer", "Linked anim layer node @@ is indirectly nested inside another Linked Anim Layer Graph '{0}', linked layers cannot be nested."), FText::FromString(BuildGraphChainString(GraphStack))).ToString(), LayerNode);
|
|
}
|
|
}
|
|
for (const UEdGraph* Graph : AllGraphs)
|
|
{
|
|
if (Graph->GetFName() == LayerNode->Node.Layer)
|
|
{
|
|
ValidateCircularRefAndNesting(Graph, AllGraphs, GraphStack, bWithinLinkedLayerGraph || LayerNode->InterfaceGuid.IsValid(), MessageLog);
|
|
}
|
|
|
|
}
|
|
}
|
|
};
|
|
void UAnimGraphNode_LinkedAnimLayer::GetLinkTarget(UObject*& OutTargetGraph, UBlueprint*& OutTargetBlueprint) const
|
|
{
|
|
OutTargetGraph = nullptr;
|
|
OutTargetBlueprint = nullptr;
|
|
|
|
auto JumpTargetFromClass = [this](UClass* InClass, UObject*& OutTargetGraph, UBlueprint*& OutTargetBlueprint)
|
|
{
|
|
UAnimBlueprint* TargetAnimBlueprint = InClass ? CastChecked<UAnimBlueprint>(InClass->ClassGeneratedBy) : nullptr;
|
|
|
|
while (TargetAnimBlueprint != nullptr)
|
|
{
|
|
// jump to graph in other BP, going up the parent BP hierarchy until we find it
|
|
TArray<UEdGraph*> Graphs;
|
|
TargetAnimBlueprint->GetAllGraphs(Graphs);
|
|
|
|
UEdGraph** FoundGraph = Graphs.FindByPredicate([this](UEdGraph* InGraph) { return InGraph->GetFName() == GetLayerName(); });
|
|
if (FoundGraph)
|
|
{
|
|
OutTargetBlueprint = TargetAnimBlueprint;
|
|
OutTargetGraph = *FoundGraph;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
TargetAnimBlueprint = UAnimBlueprint::GetParentAnimBlueprint(TargetAnimBlueprint);
|
|
}
|
|
}
|
|
|
|
// jump to graph in self
|
|
TArray<UEdGraph*> Graphs;
|
|
GetBlueprint()->GetAllGraphs(Graphs);
|
|
|
|
UEdGraph** FoundGraph = Graphs.FindByPredicate([this](UEdGraph* InGraph) { return InGraph->GetFName() == GetLayerName(); });
|
|
if (FoundGraph)
|
|
{
|
|
OutTargetBlueprint = nullptr;
|
|
OutTargetGraph = *FoundGraph;
|
|
return;
|
|
}
|
|
};
|
|
|
|
// First try a concrete class, if any
|
|
|
|
const FAnimNode_LinkedAnimGraph* RuntimeNode = GetLinkedAnimGraphNode();
|
|
|
|
if (UObject* TargetInstance = RuntimeNode->GetTargetInstance<UObject>())
|
|
{
|
|
JumpTargetFromClass(TargetInstance->GetClass(), OutTargetGraph, OutTargetBlueprint);
|
|
}
|
|
if (OutTargetGraph == nullptr)
|
|
{
|
|
JumpTargetFromClass(RuntimeNode->InstanceClass, OutTargetGraph, OutTargetBlueprint);
|
|
}
|
|
if (OutTargetGraph == nullptr)
|
|
{
|
|
// then try the interface
|
|
JumpTargetFromClass(*Node.Interface, OutTargetGraph, OutTargetBlueprint);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
UObject* UAnimGraphNode_LinkedAnimLayer::GetJumpTargetForDoubleClick() const
|
|
{
|
|
UObject* TargetGraph;
|
|
UBlueprint* TargetBlueprint;
|
|
|
|
GetLinkTarget(TargetGraph, TargetBlueprint);
|
|
return TargetGraph;
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::JumpToDefinition() const
|
|
{
|
|
|
|
UObject* TargetGraph;
|
|
UBlueprint* TargetBlueprint;
|
|
|
|
GetLinkTarget(TargetGraph, TargetBlueprint);
|
|
|
|
if (UAnimationGraph* HyperlinkTarget = Cast<UAnimationGraph>(TargetGraph))
|
|
{
|
|
FKismetEditorUtilities::BringKismetToFocusAttentionOnObject(HyperlinkTarget);
|
|
|
|
if (TargetBlueprint != nullptr)
|
|
{
|
|
const FAnimNode_LinkedAnimGraph* RuntimeNode = GetLinkedAnimGraphNode();
|
|
|
|
if (UObject* TargetInstance = RuntimeNode->GetTargetInstance<UObject>())
|
|
{
|
|
TargetBlueprint->SetObjectBeingDebugged(TargetInstance);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Super::JumpToDefinition();
|
|
}
|
|
}
|
|
|
|
bool UAnimGraphNode_LinkedAnimLayer::HasExternalDependencies(TArray<class UStruct*>* OptionalOutput /*= NULL*/) const
|
|
{
|
|
UClass* InterfaceClassToUse = *Node.Interface;
|
|
|
|
// Add our interface class. If that changes we need a recompile
|
|
if(InterfaceClassToUse && OptionalOutput)
|
|
{
|
|
OptionalOutput->AddUnique(InterfaceClassToUse);
|
|
}
|
|
|
|
bool bSuperResult = Super::HasExternalDependencies(OptionalOutput);
|
|
return InterfaceClassToUse || bSuperResult;
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::CustomizeDetails(IDetailLayoutBuilder& DetailBuilder)
|
|
{
|
|
// We dont allow multi-select here
|
|
if(DetailBuilder.GetSelectedObjects().Num() > 1)
|
|
{
|
|
DetailBuilder.HideCategory(TEXT("Settings"));
|
|
return;
|
|
}
|
|
|
|
IDetailCategoryBuilder& CategoryBuilder = DetailBuilder.EditCategory(TEXT("Settings"));
|
|
|
|
// Hide Tag
|
|
TSharedRef<IPropertyHandle> TagHandle = DetailBuilder.GetProperty(TEXT("Node.Tag"), GetClass());
|
|
TagHandle->MarkHiddenByCustomization();
|
|
|
|
// Customize Layer
|
|
{
|
|
TSharedRef<IPropertyHandle> LayerHandle = DetailBuilder.GetProperty(TEXT("Node.Layer"), GetClass());
|
|
if(LayerHandle->IsValidHandle())
|
|
{
|
|
LayerHandle->SetOnPropertyValueChanged(FSimpleDelegate::CreateUObject(this, &UAnimGraphNode_LinkedAnimLayer::OnLayerChanged, &DetailBuilder));
|
|
}
|
|
|
|
LayerHandle->MarkHiddenByCustomization();
|
|
|
|
// Check layers available in this BP
|
|
FDetailWidgetRow& LayerWidgetRow = CategoryBuilder.AddCustomRow(LOCTEXT("FilterStringLayer", "Layer"));
|
|
LayerWidgetRow.NameContent()
|
|
[
|
|
LayerHandle->CreatePropertyNameWidget()
|
|
]
|
|
.ValueContent()
|
|
.MinDesiredWidth(150.0f)
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+SHorizontalBox::Slot()
|
|
.VAlign(VAlign_Center)
|
|
[
|
|
SNew(SBox)
|
|
.Visibility_Lambda([this](){ return HasAvailableLayers() ? EVisibility::Visible : EVisibility::Collapsed; })
|
|
[
|
|
PropertyCustomizationHelpers::MakePropertyComboBox(
|
|
LayerHandle,
|
|
FOnGetPropertyComboBoxStrings::CreateUObject(this, &UAnimGraphNode_LinkedAnimLayer::GetLayerNames),
|
|
FOnGetPropertyComboBoxValue::CreateUObject(this, &UAnimGraphNode_LinkedAnimLayer::GetLayerNameString)
|
|
)
|
|
]
|
|
]
|
|
+SHorizontalBox::Slot()
|
|
.VAlign(VAlign_Center)
|
|
[
|
|
SNew(STextBlock)
|
|
.Visibility_Lambda([this](){ return !HasAvailableLayers() ? EVisibility::Visible : EVisibility::Collapsed; })
|
|
.Font(IDetailLayoutBuilder::GetDetailFont())
|
|
.Text(LOCTEXT("NoLayersWarning", "No available layers."))
|
|
.ToolTipText(LOCTEXT("NoLayersWarningTooltip", "This Animation Blueprint has no layers to choose from.\nTo add some, either implement an Animation Layer Interface via the Class Settings, or add an animation layer in the My Blueprint tab."))
|
|
]
|
|
];
|
|
}
|
|
|
|
GenerateExposedPinsDetails(DetailBuilder);
|
|
UAnimGraphNode_CustomProperty::CustomizeDetails(DetailBuilder);
|
|
|
|
// Customize InstanceClass with unique visibility (identical to parent class apart from this)
|
|
{
|
|
TSharedRef<IPropertyHandle> ClassHandle = DetailBuilder.GetProperty(TEXT("Node.InstanceClass"), GetClass());
|
|
ClassHandle->MarkHiddenByCustomization();
|
|
|
|
FDetailWidgetRow& ClassWidgetRow = CategoryBuilder.AddCustomRow(LOCTEXT("FilterStringInstanceClass", "Instance Class"));
|
|
ClassWidgetRow.NameContent()
|
|
[
|
|
ClassHandle->CreatePropertyNameWidget()
|
|
]
|
|
.ValueContent()
|
|
.MinDesiredWidth(250.0f)
|
|
[
|
|
SNew(SHorizontalBox)
|
|
+SHorizontalBox::Slot()
|
|
.VAlign(VAlign_Center)
|
|
[
|
|
SNew(SObjectPropertyEntryBox)
|
|
.Visibility_Lambda([this](){ return HasValidNonSelfLayer() ? EVisibility::Visible : EVisibility::Collapsed; })
|
|
.ObjectPath_UObject(this, &UAnimGraphNode_LinkedAnimLayer::GetCurrentInstanceBlueprintPath)
|
|
.AllowedClass(UAnimBlueprint::StaticClass())
|
|
.NewAssetFactories(TArray<UFactory*>())
|
|
.OnShouldFilterAsset(FOnShouldFilterAsset::CreateUObject(this, &UAnimGraphNode_LinkedAnimLayer::OnShouldFilterInstanceBlueprint))
|
|
.OnObjectChanged(FOnSetObject::CreateUObject(this, &UAnimGraphNode_LinkedAnimLayer::OnSetInstanceBlueprint, &DetailBuilder))
|
|
]
|
|
+SHorizontalBox::Slot()
|
|
.VAlign(VAlign_Center)
|
|
[
|
|
SNew(STextBlock)
|
|
.Visibility_Lambda([this](){ return !HasValidNonSelfLayer() ? EVisibility::Visible : EVisibility::Collapsed; })
|
|
.Font(IDetailLayoutBuilder::GetDetailFont())
|
|
.Text(LOCTEXT("SelfLayersWarning", "Uses layer in this Blueprint."))
|
|
.ToolTipText(LOCTEXT("SelfLayersWarningTooltip", "This linked anim layer node refers to a layer only in this blueprint, so cannot be overriden by an external blueprint implementation.\nChange to use a layer from an implemented interface to allow this override."))
|
|
]
|
|
];
|
|
}
|
|
}
|
|
|
|
bool UAnimGraphNode_LinkedAnimLayer::OnShouldFilterInstanceBlueprint(const FAssetData& InAssetData) const
|
|
{
|
|
if(Super::OnShouldFilterInstanceBlueprint(InAssetData))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
if (UAnimBlueprint* CurrentBlueprint = Cast<UAnimBlueprint>(GetBlueprint()))
|
|
{
|
|
TArray<TSubclassOf<UInterface>> AnimInterfaces;
|
|
for(const FBPInterfaceDescription& InterfaceDesc : CurrentBlueprint->ImplementedInterfaces)
|
|
{
|
|
if(InterfaceDesc.Interface && InterfaceDesc.Interface->IsChildOf<UAnimLayerInterface>())
|
|
{
|
|
if(GetLayerName() == NAME_None || InterfaceDesc.Interface->FindFunctionByName(GetLayerName()))
|
|
{
|
|
AnimInterfaces.Add(InterfaceDesc.Interface);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check interface compatibility
|
|
if(AnimInterfaces.Num() > 0)
|
|
{
|
|
const FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
|
|
FAssetData CurrentAssetData = InAssetData;
|
|
bool bMatchesInterface = false;
|
|
|
|
do
|
|
{
|
|
TArray<FString> InterfacePaths;
|
|
FEditorClassUtils::GetImplementedInterfaceClassPathsFromAsset(CurrentAssetData, InterfacePaths);
|
|
|
|
for (const FString& InterfacePath : InterfacePaths)
|
|
{
|
|
FTopLevelAssetPath AssetPath(InterfacePath);
|
|
FCoreRedirectObjectName ResolvedInterfaceName = FCoreRedirects::GetRedirectedName(ECoreRedirectFlags::Type_Class, FCoreRedirectObjectName(AssetPath));
|
|
|
|
// Verify against all interfaces we currently implement
|
|
for (TSubclassOf<UInterface> AnimInterface : AnimInterfaces)
|
|
{
|
|
bMatchesInterface |= ResolvedInterfaceName.ObjectName == AnimInterface->GetFName();
|
|
}
|
|
}
|
|
|
|
// If we didn't find a matching interface, check the parent class
|
|
if (!bMatchesInterface)
|
|
{
|
|
const FString ParentClassFromData = CurrentAssetData.GetTagValueRef<FString>(FBlueprintTags::ParentClassPath);
|
|
const FString ClassObjectPath = FPackageName::ExportTextPathToObjectPath(ParentClassFromData);
|
|
const FString BlueprintPath = ClassObjectPath.LeftChop(2); // Chop off _C
|
|
CurrentAssetData = AssetRegistryModule.Get().GetAssetByObjectPath(FSoftObjectPath(BlueprintPath));
|
|
}
|
|
// Only continue checking if the parent is an anim blueprint
|
|
} while (!bMatchesInterface && (CurrentAssetData.AssetClassPath == UAnimBlueprint::StaticClass()->GetClassPathName()));
|
|
|
|
if(!bMatchesInterface)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No interfaces, so no compatible BPs
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
FString UAnimGraphNode_LinkedAnimLayer::GetCurrentInstanceBlueprintPath() const
|
|
{
|
|
UClass* InterfaceClass = *Node.InstanceClass;
|
|
|
|
if(InterfaceClass)
|
|
{
|
|
UBlueprint* ActualBlueprint = UBlueprint::GetBlueprintFromClass(InterfaceClass);
|
|
|
|
if(ActualBlueprint)
|
|
{
|
|
return ActualBlueprint->GetPathName();
|
|
}
|
|
}
|
|
|
|
return FString();
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::CreateCustomPins(TArray<UEdGraphPin*>* OldPins)
|
|
{
|
|
if(UClass* TargetSkeletonClass = GetTargetSkeletonClass())
|
|
{
|
|
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
|
|
|
|
TArray<FOptionalPinFromProperty> OldCustomPinProperties = CustomPinProperties;
|
|
CustomPinProperties.Empty();
|
|
|
|
// add only sub-input properties
|
|
IAnimClassInterface* AnimClassInterface = IAnimClassInterface::GetFromClass(TargetSkeletonClass);
|
|
for(const FAnimBlueprintFunction& AnimBlueprintFunction : AnimClassInterface->GetAnimBlueprintFunctions())
|
|
{
|
|
// Check name matches.
|
|
if(AnimBlueprintFunction.Name == Node.GetDynamicLinkFunctionName())
|
|
{
|
|
for(const FAnimBlueprintFunction::FInputPropertyData& PropertyData : AnimBlueprintFunction.InputPropertyData)
|
|
{
|
|
// Use function property here as during compilation (especially compile-on-load) the class property may not be available
|
|
if(FProperty* Property = PropertyData.FunctionProperty)
|
|
{
|
|
const FName PinName = Property->GetFName();
|
|
|
|
FOptionalPinFromProperty OptionalPin;
|
|
OptionalPin.PropertyName = PinName;
|
|
OptionalPin.PropertyFriendlyName = UEditorEngine::GetFriendlyName(Property);
|
|
OptionalPin.bShowPin = OldCustomPinProperties.ContainsByPredicate([PinName](const FOptionalPinFromProperty& InOptionalPin){ return InOptionalPin.bShowPin && InOptionalPin.PropertyName == PinName; });
|
|
OptionalPin.PropertyTooltip = Property->GetToolTipText();
|
|
OptionalPin.CategoryName = FObjectEditorUtils::GetCategoryFName(Property);
|
|
OptionalPin.bCanToggleVisibility = true;
|
|
OptionalPin.bIsOverrideEnabled = false;
|
|
|
|
CustomPinProperties.Add(OptionalPin);
|
|
|
|
if(OptionalPin.bShowPin)
|
|
{
|
|
FEdGraphPinType PinType;
|
|
if (K2Schema->ConvertPropertyToPinType(Property, /*out*/ PinType))
|
|
{
|
|
UEdGraphPin* NewPin = CreatePin(EGPD_Input, PinType, PinName);
|
|
NewPin->PinFriendlyName = FText::FromString(OptionalPin.PropertyFriendlyName.IsEmpty() ? PinName.ToString() : OptionalPin.PropertyFriendlyName);
|
|
K2Schema->ConstructBasicPinTooltip(*NewPin, OptionalPin.PropertyTooltip, NewPin->PinToolTip);
|
|
K2Schema->SetPinAutogeneratedDefaultValueBasedOnType(NewPin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FProperty* UAnimGraphNode_LinkedAnimLayer::GetPinProperty(FName InPinName) const
|
|
{
|
|
if(UClass* TargetSkeletonClass = GetTargetSkeletonClass())
|
|
{
|
|
// add only sub-input properties
|
|
IAnimClassInterface* AnimClassInterface = IAnimClassInterface::GetFromClass(TargetSkeletonClass);
|
|
for(const FAnimBlueprintFunction& AnimBlueprintFunction : AnimClassInterface->GetAnimBlueprintFunctions())
|
|
{
|
|
// Check name matches.
|
|
if(AnimBlueprintFunction.Name == Node.GetDynamicLinkFunctionName())
|
|
{
|
|
for(const FAnimBlueprintFunction::FInputPropertyData& PropertyData : AnimBlueprintFunction.InputPropertyData)
|
|
{
|
|
FProperty* Property = PropertyData.FunctionProperty;
|
|
if(Property && Property->GetFName() == InPinName)
|
|
{
|
|
return Property;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return Super::GetPinProperty(InPinName);
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::GetLayerNames(TArray<TSharedPtr<FString>>& OutStrings, TArray<TSharedPtr<SToolTip>>& OutToolTips, TArray<bool>& OutRestrictedItems)
|
|
{
|
|
// If no interface specified, use this class
|
|
if (UAnimBlueprint* CurrentBlueprint = Cast<UAnimBlueprint>(GetBlueprint()))
|
|
{
|
|
UClass* TargetClass = *CurrentBlueprint->SkeletonGeneratedClass;
|
|
if(TargetClass)
|
|
{
|
|
IAnimClassInterface* AnimClassInterface = IAnimClassInterface::GetFromClass(TargetClass);
|
|
for(const FAnimBlueprintFunction& AnimBlueprintFunction : AnimClassInterface->GetAnimBlueprintFunctions())
|
|
{
|
|
if(AnimBlueprintFunction.Name != UEdGraphSchema_K2::GN_AnimGraph)
|
|
{
|
|
OutStrings.Add(MakeShared<FString>(AnimBlueprintFunction.Name.ToString()));
|
|
OutToolTips.Add(nullptr);
|
|
OutRestrictedItems.Add(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FString UAnimGraphNode_LinkedAnimLayer::GetLayerNameString() const
|
|
{
|
|
return FunctionReference.GetMemberName().ToString();
|
|
}
|
|
|
|
bool UAnimGraphNode_LinkedAnimLayer::IsStructuralProperty(FProperty* InProperty) const
|
|
{
|
|
return Super::IsStructuralProperty(InProperty) ||
|
|
InProperty->GetFName() == GET_MEMBER_NAME_CHECKED(FAnimNode_LinkedAnimLayer, Layer);
|
|
}
|
|
|
|
FLinearColor UAnimGraphNode_LinkedAnimLayer::GetDefaultNodeTitleColor() const
|
|
{
|
|
if (HasValidNonSelfLayer())
|
|
{
|
|
return LinkedAnimLayerGraphNodeConstants::TitleColorLinkedLayer;
|
|
}
|
|
else
|
|
{
|
|
return LinkedAnimLayerGraphNodeConstants::TitleColorSelfLayer;
|
|
}
|
|
}
|
|
|
|
UClass* UAnimGraphNode_LinkedAnimLayer::GetTargetSkeletonClass() const
|
|
{
|
|
UClass* SuperTargetSkeletonClass = Super::GetTargetSkeletonClass();
|
|
if(SuperTargetSkeletonClass == nullptr)
|
|
{
|
|
// If no concrete class specified, use this class
|
|
if (UAnimBlueprint* CurrentBlueprint = Cast<UAnimBlueprint>(GetBlueprint()))
|
|
{
|
|
SuperTargetSkeletonClass = *CurrentBlueprint->SkeletonGeneratedClass;
|
|
}
|
|
}
|
|
return SuperTargetSkeletonClass;
|
|
}
|
|
|
|
TSubclassOf<UInterface> UAnimGraphNode_LinkedAnimLayer::GetInterfaceForLayer() const
|
|
{
|
|
if (UAnimBlueprint* CurrentBlueprint = Cast<UAnimBlueprint>(GetBlueprint()))
|
|
{
|
|
// Find layer with this name in interfaces
|
|
for(FBPInterfaceDescription& InterfaceDesc : CurrentBlueprint->ImplementedInterfaces)
|
|
{
|
|
for(UEdGraph* InterfaceGraph : InterfaceDesc.Graphs)
|
|
{
|
|
if(InterfaceGraph->GetFName() == GetLayerName())
|
|
{
|
|
return InterfaceDesc.Interface;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::UpdateGuidForLayer()
|
|
{
|
|
if (!InterfaceGuid.IsValid())
|
|
{
|
|
InterfaceGuid = GetGuidForLayer();
|
|
}
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::SetLayerName(FName InName)
|
|
{
|
|
Node.Layer = InName;
|
|
|
|
if(UClass* TargetClass = GetTargetClass())
|
|
{
|
|
FGuid FunctionGuid;
|
|
FBlueprintEditorUtils::GetFunctionGuidFromClassByFieldName(FBlueprintEditorUtils::GetMostUpToDateClass(TargetClass), InName, FunctionGuid);
|
|
FunctionReference.SetExternalMember(InName, TargetClass, FunctionGuid);
|
|
}
|
|
else
|
|
{
|
|
FunctionReference.SetSelfMember(InName);
|
|
}
|
|
}
|
|
|
|
FName UAnimGraphNode_LinkedAnimLayer::GetLayerName() const
|
|
{
|
|
ensure(FunctionReference.GetMemberName() == Node.Layer);
|
|
return FunctionReference.GetMemberName();
|
|
}
|
|
|
|
FGuid UAnimGraphNode_LinkedAnimLayer::GetGuidForLayer() const
|
|
{
|
|
if (UAnimBlueprint* CurrentBlueprint = Cast<UAnimBlueprint>(GetBlueprint()))
|
|
{
|
|
// Find layer with this name in interfaces
|
|
for (FBPInterfaceDescription& InterfaceDesc : CurrentBlueprint->ImplementedInterfaces)
|
|
{
|
|
for (UEdGraph* InterfaceGraph : InterfaceDesc.Graphs)
|
|
{
|
|
if (InterfaceGraph->GetFName() == GetLayerName())
|
|
{
|
|
return InterfaceGraph->InterfaceGuid;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return FGuid();
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::OnLayerChanged(IDetailLayoutBuilder* DetailBuilder)
|
|
{
|
|
OnStructuralPropertyChanged(DetailBuilder);
|
|
|
|
UClass* TargetClass = GetTargetClass();
|
|
if(TargetClass)
|
|
{
|
|
FGuid FunctionGuid;
|
|
FBlueprintEditorUtils::GetFunctionGuidFromClassByFieldName(FBlueprintEditorUtils::GetMostUpToDateClass(TargetClass), Node.Layer, FunctionGuid);
|
|
FunctionReference.SetExternalMember(Node.Layer, TargetClass, FunctionGuid);
|
|
}
|
|
else
|
|
{
|
|
FunctionReference.SetSelfMember(Node.Layer);
|
|
}
|
|
|
|
// Get the interface for this layer. If null, then we are using a 'self' layer.
|
|
Node.Interface = GetInterfaceForLayer();
|
|
|
|
// Update the Guid for conforming
|
|
InterfaceGuid = GetGuidForLayer();
|
|
|
|
if(Node.Interface.Get() == nullptr)
|
|
{
|
|
// Self layers cannot have override implementations
|
|
Node.InstanceClass = nullptr;
|
|
}
|
|
}
|
|
|
|
bool UAnimGraphNode_LinkedAnimLayer::HasAvailableLayers() const
|
|
{
|
|
if (UAnimBlueprint* CurrentBlueprint = Cast<UAnimBlueprint>(GetBlueprint()))
|
|
{
|
|
UClass* TargetClass = *CurrentBlueprint->SkeletonGeneratedClass;
|
|
if(TargetClass)
|
|
{
|
|
IAnimClassInterface* AnimClassInterface = IAnimClassInterface::GetFromClass(TargetClass);
|
|
for(const FAnimBlueprintFunction& AnimBlueprintFunction : AnimClassInterface->GetAnimBlueprintFunctions())
|
|
{
|
|
if(AnimBlueprintFunction.Name != UEdGraphSchema_K2::GN_AnimGraph)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool UAnimGraphNode_LinkedAnimLayer::HasValidNonSelfLayer() const
|
|
{
|
|
if (UAnimBlueprint* CurrentBlueprint = Cast<UAnimBlueprint>(GetBlueprint()))
|
|
{
|
|
if(Node.Interface.Get())
|
|
{
|
|
for(const FBPInterfaceDescription& InterfaceDesc : CurrentBlueprint->ImplementedInterfaces)
|
|
{
|
|
if(InterfaceDesc.Interface && InterfaceDesc.Interface->IsChildOf<UAnimLayerInterface>())
|
|
{
|
|
if(InterfaceDesc.Interface->FindFunctionByName(GetLayerName()))
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::HandleSetObjectBeingDebugged(UObject* InDebugObj)
|
|
{
|
|
if(HasValidBlueprint())
|
|
{
|
|
NodeTitleChangedEvent.Broadcast();
|
|
|
|
FAnimNode_LinkedAnimLayer* PreviewNode = GetPreviewNode();
|
|
if(PreviewNode)
|
|
{
|
|
PreviewNode->OnInstanceChanged().AddUObject(this, &UAnimGraphNode_LinkedAnimLayer::HandleInstanceChanged);
|
|
}
|
|
}
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::HandleInstanceChanged()
|
|
{
|
|
NodeTitleChangedEvent.Broadcast();
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::SetupFromLayerId(FName InLayer)
|
|
{
|
|
Node.Layer = InLayer;
|
|
|
|
// Set to self member first, so we have a valid name in the member reference (otherwise GetInterfaceForLayer will fail)
|
|
// We will override this below
|
|
FunctionReference.SetSelfMember(InLayer);
|
|
|
|
// Get the interface for this layer. If null, then we are using a 'self' layer.
|
|
Node.Interface = GetInterfaceForLayer();
|
|
|
|
// Update the Guid for conforming
|
|
InterfaceGuid = GetGuidForLayer();
|
|
|
|
if(Node.Interface.Get() == nullptr)
|
|
{
|
|
// Self layers cannot have override implementations
|
|
Node.InstanceClass = nullptr;
|
|
}
|
|
|
|
// Set up function reference
|
|
UClass* TargetClass = GetTargetClass();
|
|
if(TargetClass)
|
|
{
|
|
FGuid FunctionGuid;
|
|
FBlueprintEditorUtils::GetFunctionGuidFromClassByFieldName(FBlueprintEditorUtils::GetMostUpToDateClass(TargetClass), InLayer, FunctionGuid);
|
|
FunctionReference.SetExternalMember(InLayer, TargetClass, FunctionGuid);
|
|
}
|
|
else
|
|
{
|
|
FunctionReference.SetSelfMember(InLayer);
|
|
}
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::GetMenuActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const
|
|
{
|
|
// Anim graph node base class will allow us to spawn an 'empty' node
|
|
UAnimGraphNode_Base::GetMenuActions(ActionRegistrar);
|
|
|
|
auto MakeAnimBlueprintAction = [](TSubclassOf<UEdGraphNode> const NodeClass, const FName& InLayerId)
|
|
{
|
|
auto SetNodeLayerId = [](UEdGraphNode* NewNode, bool bIsTemplateNode, FName InLayerId)
|
|
{
|
|
UAnimGraphNode_LinkedAnimLayer* LinkedAnimGraphNode = CastChecked<UAnimGraphNode_LinkedAnimLayer>(NewNode);
|
|
LinkedAnimGraphNode->SetupFromLayerId(InLayerId);
|
|
};
|
|
|
|
UBlueprintNodeSpawner* NodeSpawner = UBlueprintNodeSpawner::Create(NodeClass);
|
|
check(NodeSpawner != nullptr);
|
|
NodeSpawner->CustomizeNodeDelegate = UBlueprintNodeSpawner::FCustomizeNodeDelegate::CreateStatic(SetNodeLayerId, InLayerId);
|
|
NodeSpawner->DefaultMenuSignature.Category = LOCTEXT("LinkedAnimLayerCategory", "Linked Anim Layers");
|
|
NodeSpawner->DefaultMenuSignature.MenuName = NodeSpawner->DefaultMenuSignature.Tooltip = FText::Format(LOCTEXT("LinkedAnimGraphMenuFormat", "{0} - Linked Anim Layer"), FText::FromName(InLayerId));
|
|
return NodeSpawner;
|
|
};
|
|
|
|
if (const UObject* RegistrarTarget = ActionRegistrar.GetActionKeyFilter())
|
|
{
|
|
if (const UAnimBlueprint* TargetAnimBlueprint = Cast<UAnimBlueprint>(RegistrarTarget))
|
|
{
|
|
UClass* TargetClass = *TargetAnimBlueprint->SkeletonGeneratedClass;
|
|
if(TargetClass)
|
|
{
|
|
// Accept interfaces
|
|
if(TargetAnimBlueprint->BlueprintType == BPTYPE_Interface)
|
|
{
|
|
IAnimClassInterface* AnimClassInterface = IAnimClassInterface::GetFromClass(TargetClass);
|
|
for(const FAnimBlueprintFunction& AnimBlueprintFunction : AnimClassInterface->GetAnimBlueprintFunctions())
|
|
{
|
|
if(AnimBlueprintFunction.Name != UEdGraphSchema_K2::GN_AnimGraph)
|
|
{
|
|
if(UFunction* Function = TargetClass->FindFunctionByName(AnimBlueprintFunction.Name))
|
|
{
|
|
if (UBlueprintNodeSpawner* NodeSpawner = MakeAnimBlueprintAction(GetClass(), AnimBlueprintFunction.Name))
|
|
{
|
|
ActionRegistrar.AddBlueprintAction(Function, NodeSpawner);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Accept 'self' layers
|
|
IAnimClassInterface* AnimClassInterface = IAnimClassInterface::GetFromClass(TargetClass);
|
|
for(const FAnimBlueprintFunction& AnimBlueprintFunction : AnimClassInterface->GetAnimBlueprintFunctions())
|
|
{
|
|
if(AnimBlueprintFunction.Name != UEdGraphSchema_K2::GN_AnimGraph)
|
|
{
|
|
const bool bIsSelfLayer = [TargetAnimBlueprint, &AnimBlueprintFunction]()
|
|
{
|
|
for(const FBPInterfaceDescription& InterfaceDesc : TargetAnimBlueprint->ImplementedInterfaces)
|
|
{
|
|
for(UEdGraph* InterfaceGraph : InterfaceDesc.Graphs)
|
|
{
|
|
if(InterfaceGraph->GetFName() == AnimBlueprintFunction.Name)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}();
|
|
|
|
if(bIsSelfLayer)
|
|
{
|
|
if(UFunction* Function = TargetClass->FindFunctionByName(AnimBlueprintFunction.Name))
|
|
{
|
|
if (UBlueprintNodeSpawner* NodeSpawner = MakeAnimBlueprintAction(GetClass(), AnimBlueprintFunction.Name))
|
|
{
|
|
ActionRegistrar.AddBlueprintAction(Function, NodeSpawner);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool UAnimGraphNode_LinkedAnimLayer::IsActionFilteredOut(class FBlueprintActionFilter const& Filter)
|
|
{
|
|
bool bIsFilteredOut = false;
|
|
|
|
FBlueprintActionContext const& FilterContext = Filter.Context;
|
|
|
|
for (UBlueprint* Blueprint : FilterContext.Blueprints)
|
|
{
|
|
if (UAnimBlueprint* AnimBlueprint = Cast<UAnimBlueprint>(Blueprint))
|
|
{
|
|
if(UClass* TargetClass = *AnimBlueprint->SkeletonGeneratedClass)
|
|
{
|
|
// Accept only functions contained in this BP
|
|
bool bImplemented = false;
|
|
IAnimClassInterface* AnimClassInterface = IAnimClassInterface::GetFromClass(TargetClass);
|
|
for(const FAnimBlueprintFunction& AnimBlueprintFunction : AnimClassInterface->GetAnimBlueprintFunctions())
|
|
{
|
|
if(GetLayerName() == AnimBlueprintFunction.Name)
|
|
{
|
|
bImplemented = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!bImplemented)
|
|
{
|
|
bIsFilteredOut = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return bIsFilteredOut;
|
|
}
|
|
|
|
FAnimNode_LinkedAnimGraph* UAnimGraphNode_LinkedAnimLayer::GetLinkedAnimGraphNode()
|
|
{
|
|
FAnimNode_LinkedAnimLayer* const RuntimeLinkedAnimGraphNode = GetDebuggedAnimNode<FAnimNode_LinkedAnimLayer>();
|
|
return RuntimeLinkedAnimGraphNode ? RuntimeLinkedAnimGraphNode : &Node;
|
|
}
|
|
|
|
const FAnimNode_LinkedAnimGraph* UAnimGraphNode_LinkedAnimLayer::GetLinkedAnimGraphNode() const
|
|
{
|
|
const FAnimNode_LinkedAnimGraph* const RuntimeLinkedAnimGraphNode = GetDebuggedAnimNode<FAnimNode_LinkedAnimLayer>();
|
|
return RuntimeLinkedAnimGraphNode ? RuntimeLinkedAnimGraphNode : &Node;
|
|
}
|
|
|
|
void UAnimGraphNode_LinkedAnimLayer::HandleFunctionReferenceChanged(FName InNewName)
|
|
{
|
|
Node.Layer = InNewName;
|
|
ensure(FunctionReference.GetMemberName() == Node.Layer);
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|