You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
1066 lines
30 KiB
C++
1066 lines
30 KiB
C++
// Copyright 1998-2019 Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "Graph/ControlRigGraphNode.h"
|
|
#include "EdGraph/EdGraphPin.h"
|
|
#include "Graph/ControlRigGraph.h"
|
|
#include "Graph/ControlRigGraphSchema.h"
|
|
#include "Kismet2/BlueprintEditorUtils.h"
|
|
#include "KismetCompiler.h"
|
|
#include "BlueprintNodeSpawner.h"
|
|
#include "EditorCategoryUtils.h"
|
|
#include "BlueprintActionDatabaseRegistrar.h"
|
|
#include "ControlRig.h"
|
|
#include "Textures/SlateIcon.h"
|
|
#include "Units/RigUnit.h"
|
|
#include "ControlRigBlueprint.h"
|
|
#include "PropertyPathHelpers.h"
|
|
#include "Kismet2/Kismet2NameValidators.h"
|
|
#include "ScopedTransaction.h"
|
|
#include "StructReference.h"
|
|
#include "UObject/PropertyPortFlags.h"
|
|
#include "ControlRigBlueprintUtils.h"
|
|
#include "Curves/CurveFloat.h"
|
|
|
|
#if WITH_EDITOR
|
|
#include "IControlRigEditorModule.h"
|
|
#endif //WITH_EDITOR
|
|
|
|
#define LOCTEXT_NAMESPACE "ControlRigGraphNode"
|
|
|
|
UControlRigGraphNode::UControlRigGraphNode()
|
|
: Dimensions(0.0f, 0.0f)
|
|
, NodeTitleFull(FText::GetEmpty())
|
|
, NodeTitle(FText::GetEmpty())
|
|
, CachedTitleColor(FLinearColor(0.f, 0.f, 0.f, 0.f))
|
|
, CachedNodeColor(FLinearColor(0.f, 0.f, 0.f, 0.f))
|
|
{
|
|
bHasCompilerMessage = false;
|
|
ErrorType = (int32)EMessageSeverity::Info + 1;
|
|
ParameterType = (int32)EControlRigModelParameterType::None;
|
|
}
|
|
|
|
FText UControlRigGraphNode::GetNodeTitle(ENodeTitleType::Type TitleType) const
|
|
{
|
|
if(NodeTitle.IsEmpty() || NodeTitleFull.IsEmpty())
|
|
{
|
|
UScriptStruct* ScriptStruct = GetUnitScriptStruct();
|
|
if(ScriptStruct && ScriptStruct->HasMetaData(UControlRig::DisplayNameMetaName))
|
|
{
|
|
if(ScriptStruct->HasMetaData(UControlRig::ShowVariableNameInTitleMetaName))
|
|
{
|
|
NodeTitleFull = FText::Format(LOCTEXT("NodeFullTitleFormat", "{0}\n{1}"), FText::FromName(PropertyName), FText::FromString(ScriptStruct->GetMetaData(UControlRig::DisplayNameMetaName)));
|
|
NodeTitle = FText::FromName(PropertyName);
|
|
}
|
|
else
|
|
{
|
|
NodeTitle = NodeTitleFull = FText::FromString(ScriptStruct->GetMetaData(UControlRig::DisplayNameMetaName));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NodeTitle = NodeTitleFull = FText::FromName(PropertyName);
|
|
}
|
|
}
|
|
|
|
if(TitleType == ENodeTitleType::FullTitle)
|
|
{
|
|
return NodeTitleFull;
|
|
}
|
|
else
|
|
{
|
|
return NodeTitle;
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::ReconstructNode()
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
UControlRigGraph* RigGraph = Cast<UControlRigGraph>(GetGraph());
|
|
if (RigGraph)
|
|
{
|
|
if (RigGraph->bIsTemporaryGraphForCopyPaste)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Clear previously set messages
|
|
ErrorMsg.Reset();
|
|
|
|
// @TODO: support pin orphaning/conversions for upgrades/deprecations?
|
|
|
|
// Move the existing pins to a saved array
|
|
TArray<UEdGraphPin*> OldPins(Pins);
|
|
Pins.Reset();
|
|
|
|
// Recreate the new pins
|
|
ReallocatePinsDuringReconstruction(OldPins);
|
|
RewireOldPinsToNewPins(OldPins, Pins);
|
|
|
|
// Let subclasses do any additional work
|
|
PostReconstructNode();
|
|
|
|
GetGraph()->NotifyGraphChanged();
|
|
|
|
UScriptStruct* ScriptStruct = GetUnitScriptStruct();
|
|
if (ScriptStruct)
|
|
{
|
|
StructPath = ScriptStruct->GetPathName();
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::CacheHierarchyRefConnectionsOnPostLoad()
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
if (HierarchyRefOutputConnections.Num() > 0)
|
|
{
|
|
return;
|
|
}
|
|
for (UEdGraphPin* Pin : Pins)
|
|
{
|
|
if (Pin->PinType.PinCategory != UEdGraphSchema_K2::PC_Struct)
|
|
{
|
|
continue;
|
|
}
|
|
if (Pin->PinType.PinSubCategoryObject != FRigHierarchyRef::StaticStruct())
|
|
{
|
|
continue;
|
|
}
|
|
if (Pin->Direction == EEdGraphPinDirection::EGPD_Output)
|
|
{
|
|
for (UEdGraphPin* LinkedPin : Pin->LinkedTo)
|
|
{
|
|
HierarchyRefOutputConnections.Add(LinkedPin->GetOwningNode());
|
|
}
|
|
}
|
|
else if (Pin->Direction == EEdGraphPinDirection::EGPD_Input)
|
|
{
|
|
for (UEdGraphPin* LinkedPin : Pin->LinkedTo)
|
|
{
|
|
UControlRigGraphNode* LinkedNode = Cast<UControlRigGraphNode>(LinkedPin->GetOwningNode());
|
|
if (LinkedNode)
|
|
{
|
|
LinkedNode->HierarchyRefOutputConnections.Add(this);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::PrepareForCopying()
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
// cache the data we need for paste to work
|
|
// we fill up struct for rig unit
|
|
UScriptStruct* ScriptStruct = GetUnitScriptStruct();
|
|
if (ScriptStruct)
|
|
{
|
|
StructPath = ScriptStruct->GetPathName();
|
|
}
|
|
// or property
|
|
UProperty* Property = GetProperty();
|
|
if (Property)
|
|
{
|
|
FString PropertyPath = Property->GetPathName();
|
|
|
|
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
|
|
Schema->ConvertPropertyToPinType(Property, PinType);
|
|
}
|
|
}
|
|
|
|
bool UControlRigGraphNode::IsDeprecated() const
|
|
{
|
|
UScriptStruct* ScriptStruct = GetUnitScriptStruct();
|
|
if (ScriptStruct)
|
|
{
|
|
FString DeprecatedMetadata;
|
|
ScriptStruct->GetStringMetaDataHierarchical(UControlRig::DeprecatedMetaName, &DeprecatedMetadata);
|
|
if (!DeprecatedMetadata.IsEmpty())
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return Super::IsDeprecated();
|
|
}
|
|
|
|
FEdGraphNodeDeprecationResponse UControlRigGraphNode::GetDeprecationResponse(EEdGraphNodeDeprecationType DeprecationType) const
|
|
{
|
|
FEdGraphNodeDeprecationResponse Response = Super::GetDeprecationResponse(DeprecationType);
|
|
|
|
UScriptStruct* ScriptStruct = GetUnitScriptStruct();
|
|
if (ScriptStruct)
|
|
{
|
|
FString DeprecatedMetadata;
|
|
ScriptStruct->GetStringMetaDataHierarchical(UControlRig::DeprecatedMetaName, &DeprecatedMetadata);
|
|
if (!DeprecatedMetadata.IsEmpty())
|
|
{
|
|
FFormatNamedArguments Args;
|
|
Args.Add(TEXT("DeprecatedMetadata"), FText::FromString(DeprecatedMetadata));
|
|
Response.MessageText = FText::Format(LOCTEXT("ControlRigGraphNodeDeprecationMessage", "Warning: This node is deprecated from: {DeprecatedMetadata}"), Args);
|
|
}
|
|
}
|
|
|
|
return Response;
|
|
}
|
|
|
|
void UControlRigGraphNode::ReallocatePinsDuringReconstruction(const TArray<UEdGraphPin*>& OldPins)
|
|
{
|
|
AllocateDefaultPins();
|
|
}
|
|
|
|
void UControlRigGraphNode::RewireOldPinsToNewPins(TArray<UEdGraphPin*>& InOldPins, TArray<UEdGraphPin*>& InNewPins)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
// @TODO: we should account for redirectors, orphaning etc. here too!
|
|
|
|
for(UEdGraphPin* OldPin : InOldPins)
|
|
{
|
|
for(UEdGraphPin* NewPin : InNewPins)
|
|
{
|
|
if(OldPin->PinName == NewPin->PinName && OldPin->PinType == NewPin->PinType && OldPin->Direction == NewPin->Direction)
|
|
{
|
|
NewPin->MovePersistentDataFromOldPin(*OldPin);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
DestroyPinList(InOldPins);
|
|
}
|
|
|
|
void UControlRigGraphNode::DestroyPinList(TArray<UEdGraphPin*>& InPins)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
UBlueprint* Blueprint = GetBlueprint();
|
|
bool bNotify = false;
|
|
if (Blueprint != nullptr)
|
|
{
|
|
bNotify = !Blueprint->bIsRegeneratingOnLoad;
|
|
}
|
|
|
|
// Throw away the original pins
|
|
for (UEdGraphPin* Pin : InPins)
|
|
{
|
|
Pin->BreakAllPinLinks(bNotify);
|
|
|
|
UEdGraphNode::DestroyPin(Pin);
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::PostReconstructNode()
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
for (UEdGraphPin* Pin : Pins)
|
|
{
|
|
SetupPinDefaultsFromCDO(Pin);
|
|
}
|
|
|
|
bCanRenameNode = false;
|
|
|
|
UControlRigBlueprint* Blueprint = Cast<UControlRigBlueprint>(GetOuter()->GetOuter());
|
|
if (Blueprint)
|
|
{
|
|
if (Blueprint->Model)
|
|
{
|
|
if (const FControlRigModelNode* ModelNode = Blueprint->Model->FindNode(PropertyName))
|
|
{
|
|
SetColorFromModel(ModelNode->Color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::SetColorFromModel(const FLinearColor& InColor)
|
|
{
|
|
static const FLinearColor TitleToNodeColor(0.35f, 0.35f, 0.35f, 1.f);
|
|
CachedNodeColor = InColor * TitleToNodeColor;
|
|
CachedTitleColor = InColor;
|
|
}
|
|
|
|
#if WITH_EDITORONLY_DATA
|
|
void UControlRigGraphNode::PostLoad()
|
|
{
|
|
Super::PostLoad();
|
|
HierarchyRefOutputConnections.Reset();
|
|
}
|
|
#endif
|
|
|
|
void UControlRigGraphNode::CreateVariablePins(bool bAlwaysCreatePins)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
CacheVariableInfo();
|
|
CreateExecutionPins(bAlwaysCreatePins);
|
|
CreateInputPins(bAlwaysCreatePins);
|
|
CreateInputOutputPins(bAlwaysCreatePins);
|
|
CreateOutputPins(bAlwaysCreatePins);
|
|
}
|
|
|
|
void UControlRigGraphNode::HandleClearArray(FString InPropertyPath)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
UControlRigBlueprint* Blueprint = Cast<UControlRigBlueprint>(GetOuter()->GetOuter());
|
|
if (Blueprint)
|
|
{
|
|
if (Blueprint->ModelController && Blueprint->Model)
|
|
{
|
|
FString Left, Right;
|
|
Blueprint->Model->SplitPinPath(InPropertyPath, Left, Right);
|
|
Blueprint->ModelController->ClearArrayPin(*Left, *Right);
|
|
}
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::HandleAddArrayElement(FString InPropertyPath)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
UControlRigBlueprint* Blueprint = Cast<UControlRigBlueprint>(GetOuter()->GetOuter());
|
|
if (Blueprint)
|
|
{
|
|
if (Blueprint->ModelController && Blueprint->Model)
|
|
{
|
|
FString Left, Right;
|
|
Blueprint->Model->SplitPinPath(InPropertyPath, Left, Right);
|
|
Blueprint->ModelController->AddArrayPin(*Left, *Right, FString());
|
|
}
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::HandleRemoveArrayElement(FString InPropertyPath)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
UControlRigBlueprint* Blueprint = Cast<UControlRigBlueprint>(GetOuter()->GetOuter());
|
|
if (Blueprint)
|
|
{
|
|
if (Blueprint->ModelController && Blueprint->Model)
|
|
{
|
|
const FControlRigModelPin* ChildPin = Blueprint->Model->FindPinFromPath(*InPropertyPath);
|
|
if (ChildPin)
|
|
{
|
|
const FControlRigModelPin* ParentPin = Blueprint->Model->GetParentPin(ChildPin->GetPair());
|
|
if (ParentPin)
|
|
{
|
|
FString ParentPinPath = Blueprint->Model->GetPinPath(ParentPin->GetPair());
|
|
FString Left, Right;
|
|
Blueprint->Model->SplitPinPath(ParentPinPath, Left, Right);
|
|
// todo: really should be remove at index
|
|
Blueprint->ModelController->PopArrayPin(*Left, *Right);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::HandleInsertArrayElement(FString InPropertyPath)
|
|
{
|
|
// todo: really should be insert
|
|
HandleAddArrayElement(InPropertyPath);
|
|
}
|
|
|
|
void UControlRigGraphNode::AllocateDefaultPins()
|
|
{
|
|
CreateVariablePins(true);
|
|
}
|
|
|
|
/** Helper function to check whether this is a struct reference pin */
|
|
static bool IsStructReference(const TSharedPtr<FControlRigField>& InputInfo)
|
|
{
|
|
if(UStructProperty* StructProperty = Cast<UStructProperty>(InputInfo->GetField()))
|
|
{
|
|
return StructProperty->Struct->IsChildOf(FStructReference::StaticStruct());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void UControlRigGraphNode::CreateExecutionPins(bool bAlwaysCreatePins)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
const TArray<TSharedRef<FControlRigField>>& LocalExecutionInfos = GetExecutionVariableInfo();
|
|
|
|
for (const TSharedRef<FControlRigField>& ExecutionInfo : LocalExecutionInfos)
|
|
{
|
|
if (bAlwaysCreatePins || ExecutionInfo->InputPin == nullptr)
|
|
{
|
|
ExecutionInfo->InputPin = CreatePin(EGPD_Input, ExecutionInfo->GetPinType(), FName(*ExecutionInfo->GetPinPath()));
|
|
ExecutionInfo->InputPin->PinFriendlyName = ExecutionInfo->GetDisplayNameText();
|
|
ExecutionInfo->InputPin->PinType.bIsReference = IsStructReference(ExecutionInfo);
|
|
ExecutionInfo->InputPin->DefaultValue = ExecutionInfo->GetPin()->DefaultValue;
|
|
}
|
|
|
|
if (bAlwaysCreatePins || ExecutionInfo->OutputPin == nullptr)
|
|
{
|
|
ExecutionInfo->OutputPin = CreatePin(EGPD_Output, ExecutionInfo->GetPinType(), FName(*ExecutionInfo->GetPinPath()));
|
|
}
|
|
|
|
// note: no recursion for execution pins
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::CreateInputPins_Recursive(const TSharedPtr<FControlRigField>& InputInfo, bool bAlwaysCreatePins)
|
|
{
|
|
for (const TSharedPtr<FControlRigField>& ChildInfo : InputInfo->Children)
|
|
{
|
|
if (bAlwaysCreatePins || ChildInfo->InputPin == nullptr)
|
|
{
|
|
ChildInfo->InputPin = CreatePin(EGPD_Input, ChildInfo->GetPinType(), FName(*ChildInfo->GetPinPath()));
|
|
ChildInfo->InputPin->PinFriendlyName = ChildInfo->GetDisplayNameText();
|
|
ChildInfo->InputPin->PinType.bIsReference = IsStructReference(ChildInfo);
|
|
ChildInfo->InputPin->ParentPin = InputInfo->InputPin;
|
|
ChildInfo->InputPin->DefaultValue = ChildInfo->GetPin()->DefaultValue;
|
|
ChildInfo->OutputPin = nullptr;
|
|
InputInfo->InputPin->SubPins.Add(ChildInfo->InputPin);
|
|
}
|
|
}
|
|
|
|
for (const TSharedPtr<FControlRigField>& ChildInfo : InputInfo->Children)
|
|
{
|
|
CreateInputPins_Recursive(ChildInfo, bAlwaysCreatePins);
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::CreateInputPins(bool bAlwaysCreatePins)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
const TArray<TSharedRef<FControlRigField>>& LocalInputInfos = GetInputVariableInfo();
|
|
|
|
for (const TSharedRef<FControlRigField>& InputInfo : LocalInputInfos)
|
|
{
|
|
if (bAlwaysCreatePins || InputInfo->InputPin == nullptr)
|
|
{
|
|
InputInfo->InputPin = CreatePin(EGPD_Input, InputInfo->GetPinType(), FName(*InputInfo->GetPinPath()));
|
|
InputInfo->InputPin->PinFriendlyName = InputInfo->GetDisplayNameText();
|
|
InputInfo->InputPin->PinType.bIsReference = IsStructReference(InputInfo);
|
|
InputInfo->InputPin->DefaultValue = InputInfo->GetPin()->DefaultValue;
|
|
InputInfo->OutputPin = nullptr;
|
|
}
|
|
else
|
|
{
|
|
InputInfo->InputPin->DefaultValue = InputInfo->GetPin()->DefaultValue;
|
|
}
|
|
|
|
CreateInputPins_Recursive(InputInfo, bAlwaysCreatePins);
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::CreateInputOutputPins_Recursive(const TSharedPtr<FControlRigField>& InputOutputInfo, bool bAlwaysCreatePins)
|
|
{
|
|
for (const TSharedPtr<FControlRigField>& ChildInfo : InputOutputInfo->Children)
|
|
{
|
|
if (bAlwaysCreatePins || ChildInfo->InputPin == nullptr)
|
|
{
|
|
ChildInfo->InputPin = CreatePin(EGPD_Input, ChildInfo->GetPinType(), FName(*ChildInfo->GetPinPath()));
|
|
ChildInfo->InputPin->PinFriendlyName = ChildInfo->GetDisplayNameText();
|
|
ChildInfo->InputPin->PinType.bIsReference = IsStructReference(ChildInfo);
|
|
ChildInfo->InputPin->DefaultValue = ChildInfo->GetPin()->DefaultValue;
|
|
ChildInfo->InputPin->ParentPin = InputOutputInfo->InputPin;
|
|
InputOutputInfo->InputPin->SubPins.Add(ChildInfo->InputPin);
|
|
}
|
|
else
|
|
{
|
|
ChildInfo->InputPin->DefaultValue = ChildInfo->GetPin()->DefaultValue;
|
|
}
|
|
|
|
if (bAlwaysCreatePins || ChildInfo->OutputPin == nullptr)
|
|
{
|
|
ChildInfo->OutputPin = CreatePin(EGPD_Output, ChildInfo->GetPinType(), FName(*ChildInfo->GetPinPath()));
|
|
ChildInfo->OutputPin->PinFriendlyName = ChildInfo->GetDisplayNameText();
|
|
ChildInfo->OutputPin->ParentPin = InputOutputInfo->OutputPin;
|
|
ChildInfo->OutputPin->PinType.bIsReference = IsStructReference(ChildInfo);
|
|
InputOutputInfo->OutputPin->SubPins.Add(ChildInfo->OutputPin);
|
|
}
|
|
}
|
|
|
|
for (const TSharedPtr<FControlRigField>& ChildInfo : InputOutputInfo->Children)
|
|
{
|
|
CreateInputOutputPins_Recursive(ChildInfo, bAlwaysCreatePins);
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::CreateInputOutputPins(bool bAlwaysCreatePins)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
const TArray<TSharedRef<FControlRigField>>& LocalInputOutputInfos = GetInputOutputVariableInfo();
|
|
|
|
for (const TSharedRef<FControlRigField>& InputOutputInfo : LocalInputOutputInfos)
|
|
{
|
|
if (bAlwaysCreatePins || InputOutputInfo->InputPin == nullptr)
|
|
{
|
|
InputOutputInfo->InputPin = CreatePin(EGPD_Input, InputOutputInfo->GetPinType(), FName(*InputOutputInfo->GetPinPath()));
|
|
InputOutputInfo->InputPin->PinFriendlyName = InputOutputInfo->GetDisplayNameText();
|
|
InputOutputInfo->InputPin->PinType.bIsReference = IsStructReference(InputOutputInfo);
|
|
InputOutputInfo->InputPin->DefaultValue = InputOutputInfo->GetPin()->DefaultValue;
|
|
}
|
|
|
|
if (bAlwaysCreatePins || InputOutputInfo->OutputPin == nullptr)
|
|
{
|
|
InputOutputInfo->OutputPin = CreatePin(EGPD_Output, InputOutputInfo->GetPinType(), FName(*InputOutputInfo->GetPinPath()));
|
|
}
|
|
|
|
CreateInputOutputPins_Recursive(InputOutputInfo, bAlwaysCreatePins);
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::CreateOutputPins_Recursive(const TSharedPtr<FControlRigField>& OutputInfo, bool bAlwaysCreatePins)
|
|
{
|
|
for (const TSharedPtr<FControlRigField>& ChildInfo : OutputInfo->Children)
|
|
{
|
|
if (bAlwaysCreatePins || ChildInfo->OutputPin == nullptr)
|
|
{
|
|
ChildInfo->OutputPin = CreatePin(EGPD_Output, ChildInfo->GetPinType(), FName(*ChildInfo->GetPinPath()));
|
|
ChildInfo->OutputPin->PinFriendlyName = ChildInfo->GetDisplayNameText();
|
|
ChildInfo->OutputPin->PinType.bIsReference = IsStructReference(ChildInfo);
|
|
ChildInfo->OutputPin->ParentPin = OutputInfo->OutputPin;
|
|
ChildInfo->InputPin = nullptr;
|
|
OutputInfo->OutputPin->SubPins.Add(ChildInfo->OutputPin);
|
|
}
|
|
}
|
|
|
|
for (const TSharedPtr<FControlRigField>& ChildInfo : OutputInfo->Children)
|
|
{
|
|
CreateOutputPins_Recursive(ChildInfo, bAlwaysCreatePins);
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::CreateOutputPins(bool bAlwaysCreatePins)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
const TArray<TSharedRef<FControlRigField>>& LocalOutputInfos = GetOutputVariableInfo();
|
|
|
|
for (const TSharedRef<FControlRigField>& OutputInfo : LocalOutputInfos)
|
|
{
|
|
if (bAlwaysCreatePins || OutputInfo->OutputPin == nullptr)
|
|
{
|
|
OutputInfo->OutputPin = CreatePin(EGPD_Output, OutputInfo->GetPinType(), FName(*OutputInfo->GetPinPath()));
|
|
OutputInfo->OutputPin->PinFriendlyName = OutputInfo->GetDisplayNameText();
|
|
OutputInfo->OutputPin->PinType.bIsReference = IsStructReference(OutputInfo);
|
|
OutputInfo->InputPin = nullptr;
|
|
}
|
|
|
|
CreateOutputPins_Recursive(OutputInfo, bAlwaysCreatePins);
|
|
}
|
|
}
|
|
|
|
void UControlRigGraphNode::CacheVariableInfo()
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
ExecutionInfos.Reset();
|
|
GetExecutionFields(ExecutionInfos);
|
|
|
|
InputInfos.Reset();
|
|
GetInputFields(InputInfos);
|
|
|
|
OutputInfos.Reset();
|
|
GetOutputFields(OutputInfos);
|
|
|
|
InputOutputInfos.Reset();
|
|
GetInputOutputFields(InputOutputInfos);
|
|
}
|
|
|
|
UClass* UControlRigGraphNode::GetControlRigGeneratedClass() const
|
|
{
|
|
UControlRigBlueprint* Blueprint = Cast<UControlRigBlueprint>(GetOuter()->GetOuter());
|
|
if(Blueprint)
|
|
{
|
|
if (Blueprint->GeneratedClass)
|
|
{
|
|
check(Blueprint->GeneratedClass->IsChildOf(UControlRig::StaticClass()));
|
|
return Blueprint->GeneratedClass;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
UClass* UControlRigGraphNode::GetControlRigSkeletonGeneratedClass() const
|
|
{
|
|
UControlRigBlueprint* Blueprint = Cast<UControlRigBlueprint>(GetOuter()->GetOuter());
|
|
if(Blueprint)
|
|
{
|
|
if (Blueprint->SkeletonGeneratedClass)
|
|
{
|
|
check(Blueprint->SkeletonGeneratedClass->IsChildOf(UControlRig::StaticClass()));
|
|
return Blueprint->SkeletonGeneratedClass;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
FLinearColor UControlRigGraphNode::GetNodeTitleColor() const
|
|
{
|
|
// return a darkened version of the default node's color
|
|
return CachedTitleColor;
|
|
}
|
|
|
|
FLinearColor UControlRigGraphNode::GetNodeBodyTintColor() const
|
|
{
|
|
return CachedNodeColor;
|
|
}
|
|
|
|
FSlateIcon UControlRigGraphNode::GetIconAndTint(FLinearColor& OutColor) const
|
|
{
|
|
OutColor = GetNodeTitleColor();
|
|
static FSlateIcon Icon("EditorStyle", "Kismet.AllClasses.FunctionIcon");
|
|
return Icon;
|
|
}
|
|
|
|
// bool UControlRigGraphNode::ReferencesVariable(const FName& InVarName, const UStruct* InScope) const
|
|
// {
|
|
// return InVarName == PropertyName;
|
|
// }
|
|
|
|
TSharedPtr<FControlRigField> UControlRigGraphNode::CreateControlRigField(const FControlRigModelPin* InPin, const FString& InPinPath, int32 InArrayIndex) const
|
|
{
|
|
TSharedPtr<FControlRigField> NewField = MakeShareable(new FControlRigPin(InPin, InPinPath, InArrayIndex));
|
|
NewField->DisplayNameText = InPin->DisplayNameText;
|
|
NewField->TooltipText = InPin->TooltipText;
|
|
NewField->InputPin = FindPin(InPinPath, EGPD_Input);
|
|
NewField->OutputPin = FindPin(InPinPath, EGPD_Output);
|
|
return NewField;
|
|
}
|
|
|
|
void UControlRigGraphNode::GetExecutionFields(TArray<TSharedRef<FControlRigField>>& OutFields) const
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
GetFields([](const FControlRigModelPin* InPin, const FControlRigModelNode* InNode)
|
|
{
|
|
FString PinPath = InNode->GetPinPath(InPin->Index, false);
|
|
return InPin->Direction == EGPD_Output &&
|
|
InNode->FindPin(*PinPath, true) != nullptr &&
|
|
InPin->Type.PinSubCategoryObject == FControlRigExecuteContext::StaticStruct();
|
|
}, OutFields);
|
|
}
|
|
|
|
void UControlRigGraphNode::GetInputFields(TArray<TSharedRef<FControlRigField>>& OutFields) const
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
GetFields([](const FControlRigModelPin* InPin, const FControlRigModelNode* InNode)
|
|
{
|
|
FString PinPath = InNode->GetPinPath(InPin->Index, false);
|
|
if (InPin->Direction != EGPD_Input)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (InNode->IsParameter() && InNode->ParameterType == EControlRigModelParameterType::Output)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return InNode->FindPin(*PinPath, false) == nullptr;
|
|
}, OutFields);
|
|
}
|
|
|
|
void UControlRigGraphNode::GetOutputFields(TArray<TSharedRef<FControlRigField>>& OutFields) const
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
GetFields([](const FControlRigModelPin* InPin, const FControlRigModelNode* InNode)
|
|
{
|
|
FString PinPath = InNode->GetPinPath(InPin->Index, false);
|
|
if (InPin->Direction != EGPD_Output)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (InNode->IsParameter() && InNode->ParameterType == EControlRigModelParameterType::Input)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return InNode->FindPin(*PinPath, true) == nullptr;
|
|
}, OutFields);
|
|
}
|
|
|
|
void UControlRigGraphNode::GetInputOutputFields(TArray<TSharedRef<FControlRigField>>& OutFields) const
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
GetFields([](const FControlRigModelPin* InPin, const FControlRigModelNode* InNode)
|
|
{
|
|
if (InNode->IsParameter())
|
|
{
|
|
return false;
|
|
}
|
|
FString PinPath = InNode->GetPinPath(InPin->Index, false);
|
|
return InPin->Direction == EGPD_Input &&
|
|
InNode->FindPin(*PinPath, false) != nullptr &&
|
|
InPin->Type.PinSubCategoryObject != FControlRigExecuteContext::StaticStruct();
|
|
}, OutFields);
|
|
}
|
|
|
|
void UControlRigGraphNode::GetFields(TFunction<bool(const FControlRigModelPin*, const FControlRigModelNode*)> InPinCheckFunction, TArray<TSharedRef<FControlRigField>>& OutFields) const
|
|
{
|
|
OutFields.Reset();
|
|
|
|
FControlRigModelNode Node;
|
|
|
|
if (UControlRigBlueprint* RigBlueprint = Cast<UControlRigBlueprint>(GetBlueprint()))
|
|
{
|
|
if (RigBlueprint->Model)
|
|
{
|
|
const FControlRigModelNode* FoundNode = RigBlueprint->Model->FindNode(GetPropertyName());
|
|
if (FoundNode != nullptr)
|
|
{
|
|
Node = *FoundNode;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Node.IsValid())
|
|
{
|
|
if (IsVariable())
|
|
{
|
|
FName DataType = PinType.PinCategory;
|
|
if (UStruct* Struct = Cast<UStruct>(PinType.PinSubCategoryObject))
|
|
{
|
|
DataType = Struct->GetFName();
|
|
}
|
|
UControlRigController::ConstructPreviewParameter(DataType, EControlRigModelParameterType::Input, Node);
|
|
}
|
|
else
|
|
{
|
|
if (UStruct* Struct = GetUnitScriptStruct())
|
|
{
|
|
FName FunctionName = Struct->GetFName();
|
|
UControlRigController::ConstructPreviewNode(FunctionName, Node);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Node.IsValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
Node.Name = GetPropertyName();
|
|
|
|
TMap<int32, TSharedRef<FControlRigField>> AllFields;
|
|
for(int32 PinIndex=0;PinIndex < Node.Pins.Num(); PinIndex++)
|
|
{
|
|
const FControlRigModelPin& Pin = Node.Pins[PinIndex];
|
|
if (InPinCheckFunction(&Pin, &Node))
|
|
{
|
|
FString PinPath = Node.GetPinPath(Pin.Index, true);
|
|
TSharedPtr<FControlRigField> NewField = CreateControlRigField(&Pin, PinPath);
|
|
if (NewField.IsValid())
|
|
{
|
|
TSharedRef<FControlRigField> NewFieldRef = NewField.ToSharedRef();
|
|
AllFields.Add(Pin.Index, NewFieldRef);
|
|
|
|
TSharedRef<FControlRigField>* ParentField = AllFields.Find(Pin.ParentIndex);
|
|
if (ParentField)
|
|
{
|
|
(*ParentField)->Children.Add(NewFieldRef);
|
|
}
|
|
else
|
|
{
|
|
OutFields.Add(NewFieldRef);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UStructProperty* UControlRigGraphNode::GetUnitProperty() const
|
|
{
|
|
UProperty* ClassProperty = GetProperty();
|
|
if(ClassProperty)
|
|
{
|
|
// Check if this is a unit struct and if so extract the pins we want to display...
|
|
if(UStructProperty* StructProperty = Cast<UStructProperty>(ClassProperty))
|
|
{
|
|
if(StructProperty->Struct->IsChildOf(FRigUnit::StaticStruct()))
|
|
{
|
|
return StructProperty;
|
|
}
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
UScriptStruct* UControlRigGraphNode::GetUnitScriptStruct() const
|
|
{
|
|
if(UStructProperty* StructProperty = GetUnitProperty())
|
|
{
|
|
if(StructProperty->Struct->IsChildOf(FRigUnit::StaticStruct()))
|
|
{
|
|
return StructProperty->Struct;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Assume that the property name we have is the name of the struct type
|
|
UScriptStruct* Struct = FindObject<UScriptStruct>(ANY_PACKAGE, *PropertyName.ToString());
|
|
if(Struct && Struct->IsChildOf(FRigUnit::StaticStruct()))
|
|
{
|
|
return Struct;
|
|
}
|
|
|
|
// if this doesn't work we can still fall back on the struct path
|
|
FString Prefix, StructName;
|
|
if (StructPath.Split(TEXT("."), &Prefix, &StructName))
|
|
{
|
|
Struct = FindObject<UScriptStruct>(ANY_PACKAGE, *StructName);
|
|
if (Struct && Struct->IsChildOf(FRigUnit::StaticStruct()))
|
|
{
|
|
return Struct;
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
UProperty* UControlRigGraphNode::GetProperty() const
|
|
{
|
|
if (UClass* MyControlRigClass = GetControlRigSkeletonGeneratedClass())
|
|
{
|
|
return MyControlRigClass->FindPropertyByName(PropertyName);
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void UControlRigGraphNode::PinConnectionListChanged(UEdGraphPin* Pin)
|
|
{
|
|
|
|
}
|
|
|
|
void UControlRigGraphNode::GetNodeContextMenuActions(UToolMenu* Menu, UGraphNodeContextMenuContext* Context) const
|
|
{
|
|
#if WITH_EDITOR
|
|
IControlRigEditorModule::Get().GetNodeContextMenuActions(this, Menu, Context);
|
|
#endif
|
|
}
|
|
|
|
void UControlRigGraphNode::SetPinExpansion(const FString& InPinPropertyPath, bool bExpanded)
|
|
{
|
|
if(bExpanded)
|
|
{
|
|
ExpandedPins.AddUnique(InPinPropertyPath);
|
|
}
|
|
else
|
|
{
|
|
ExpandedPins.Remove(InPinPropertyPath);
|
|
}
|
|
}
|
|
|
|
bool UControlRigGraphNode::IsPinExpanded(const FString& InPinPropertyPath) const
|
|
{
|
|
return ExpandedPins.Contains(InPinPropertyPath);
|
|
}
|
|
|
|
void UControlRigGraphNode::DestroyNode()
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
if(UControlRigGraph* Graph = Cast<UControlRigGraph>(GetOuter()))
|
|
{
|
|
UControlRigBlueprint* ControlRigBlueprint = Cast<UControlRigBlueprint>(Graph->GetOuter());
|
|
if(ControlRigBlueprint)
|
|
{
|
|
BreakAllNodeLinks();
|
|
FControlRigBlueprintUtils::RemoveMemberVariableIfNotUsed(ControlRigBlueprint, PropertyName, this);
|
|
}
|
|
}
|
|
|
|
UEdGraphNode::DestroyNode();
|
|
}
|
|
|
|
void UControlRigGraphNode::PinDefaultValueChanged(UEdGraphPin* Pin)
|
|
{
|
|
CopyPinDefaultsToModel(Pin, true);
|
|
}
|
|
|
|
TSharedPtr<INameValidatorInterface> UControlRigGraphNode::MakeNameValidator() const
|
|
{
|
|
return MakeShared<FKismetNameValidator>(GetBlueprint(), PropertyName);
|
|
}
|
|
|
|
void UControlRigGraphNode::CopyPinDefaultsToModel(UEdGraphPin* Pin, bool bUndo)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
|
|
|
|
if(UControlRigGraph* Graph = Cast<UControlRigGraph>(GetOuter()))
|
|
{
|
|
UControlRigBlueprint* ControlRigBlueprint = Cast<UControlRigBlueprint>(Graph->GetOuter());
|
|
if(ControlRigBlueprint)
|
|
{
|
|
if (ControlRigBlueprint->Model)
|
|
{
|
|
if (Pin->Direction == EGPD_Input)
|
|
{
|
|
FString DefaultValue = Pin->DefaultValue;
|
|
FString Left, Right;
|
|
ControlRigBlueprint->Model->SplitPinPath(Pin->GetName(), Left, Right);
|
|
if (DefaultValue.IsEmpty() && Pin->DefaultObject != nullptr)
|
|
{
|
|
DefaultValue = Pin->DefaultObject->GetPathName();
|
|
}
|
|
ControlRigBlueprint->ModelController->SetPinDefaultValue(*Left, *Right, DefaultValue, false, bUndo);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
UControlRigBlueprint* UControlRigGraphNode::GetBlueprint() const
|
|
{
|
|
if(UControlRigGraph* Graph = Cast<UControlRigGraph>(GetOuter()))
|
|
{
|
|
return Cast<UControlRigBlueprint>(Graph->GetOuter());
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void UControlRigGraphNode::SetupPinDefaultsFromCDO(UEdGraphPin* Pin)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
|
|
|
|
if(UControlRigGraph* Graph = Cast<UControlRigGraph>(GetOuter()))
|
|
{
|
|
UControlRigBlueprint* ControlRigBlueprint = Cast<UControlRigBlueprint>(Graph->GetOuter());
|
|
if(ControlRigBlueprint)
|
|
{
|
|
// Note we need the actual generated class here
|
|
if (UClass* MyControlRigClass = GetControlRigGeneratedClass())
|
|
{
|
|
if(UObject* DefaultObject = MyControlRigClass->GetDefaultObject(false))
|
|
{
|
|
FString DefaultValueString;
|
|
FCachedPropertyPath PropertyPath(Pin->PinName.ToString());
|
|
if(PropertyPathHelpers::GetPropertyValueAsString(DefaultObject, PropertyPath, DefaultValueString))
|
|
{
|
|
K2Schema->GetPinDefaultValuesFromString(Pin->PinType, Pin->GetOwningNodeUnchecked(), DefaultValueString, Pin->DefaultValue, Pin->DefaultObject, Pin->DefaultTextValue);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
FText UControlRigGraphNode::GetTooltipText() const
|
|
{
|
|
if(GetUnitScriptStruct())
|
|
{
|
|
return GetUnitScriptStruct()->GetToolTipText();
|
|
}
|
|
else if(GetUnitProperty())
|
|
{
|
|
return GetUnitProperty()->GetToolTipText();
|
|
}
|
|
|
|
return FText::FromName(PropertyName);
|
|
}
|
|
|
|
void UControlRigGraphNode::InvalidateNodeTitle() const
|
|
{
|
|
NodeTitleFull = FText();
|
|
NodeTitle = FText();
|
|
}
|
|
|
|
bool UControlRigGraphNode::CanCreateUnderSpecifiedSchema(const UEdGraphSchema* InSchema) const
|
|
{
|
|
return InSchema->IsA<UControlRigGraphSchema>();
|
|
}
|
|
|
|
void UControlRigGraphNode::AutowireNewNode(UEdGraphPin* FromPin)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
Super::AutowireNewNode(FromPin);
|
|
|
|
const UControlRigGraphSchema* Schema = GetDefault<UControlRigGraphSchema>();
|
|
|
|
for(UEdGraphPin* Pin : Pins)
|
|
{
|
|
if (Pin->ParentPin != nullptr)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
FPinConnectionResponse ConnectResponse = Schema->CanCreateConnection(FromPin, Pin);
|
|
if(ConnectResponse.Response != ECanCreateConnectionResponse::CONNECT_RESPONSE_DISALLOW)
|
|
{
|
|
if(Schema->TryCreateConnection(FromPin, Pin))
|
|
{
|
|
// expand any sub-pins so the connection is visible
|
|
if(UControlRigGraphNode* OuterNode = Cast<UControlRigGraphNode>(Pin->GetOwningNode()))
|
|
{
|
|
UEdGraphPin* ParentPin = Pin->ParentPin;
|
|
while(ParentPin != nullptr)
|
|
{
|
|
OuterNode->SetPinExpansion(ParentPin->PinName.ToString(), true);
|
|
ParentPin = ParentPin->ParentPin;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void ReplacePropertyName(TArray<TSharedRef<FControlRigField>>& InArray, const FString& OldPropName, const FString& NewPropName)
|
|
{
|
|
for (int32 Index = 0; Index < InArray.Num(); ++Index)
|
|
{
|
|
InArray[Index]->PinPath = InArray[Index]->PinPath.Replace(*OldPropName, *NewPropName);
|
|
ReplacePropertyName(InArray[Index]->Children, OldPropName, NewPropName);
|
|
}
|
|
};
|
|
|
|
void UControlRigGraphNode::SetPropertyName(const FName& InPropertyName, bool bReplaceInnerProperties/*=false*/)
|
|
{
|
|
DECLARE_SCOPE_HIERARCHICAL_COUNTER_FUNC()
|
|
|
|
const FString OldPropertyName = PropertyName.ToString();
|
|
const FString NewPropertyName = InPropertyName.ToString();
|
|
PropertyName = InPropertyName;
|
|
|
|
if (bReplaceInnerProperties && InPropertyName != NAME_None)
|
|
{
|
|
ReplacePropertyName(InputInfos, OldPropertyName, NewPropertyName);
|
|
ReplacePropertyName(InputOutputInfos, OldPropertyName, NewPropertyName);
|
|
ReplacePropertyName(OutputInfos, OldPropertyName, NewPropertyName);
|
|
|
|
// now change pins
|
|
for (int32 Index = 0; Index < Pins.Num(); ++Index)
|
|
{
|
|
FString PinString = Pins[Index]->PinName.ToString();
|
|
Pins[Index]->PinName = FName(*PinString.Replace(*OldPropertyName, *NewPropertyName));
|
|
}
|
|
|
|
for (int32 Index = 0; Index < ExpandedPins.Num(); ++Index)
|
|
{
|
|
FString& PinString = ExpandedPins[Index];
|
|
PinString = PinString.Replace(*OldPropertyName, *NewPropertyName);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool UControlRigGraphNode::IsVariable() const
|
|
{
|
|
return GetUnitScriptStruct() == nullptr;
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|