void UK2Node_FunctionEntry::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
UEdGraphPin* OldStartExecPin = nullptr;
if(Pins[0]->LinkedTo.Num())
{
OldStartExecPin = Pins[0]->LinkedTo[0];
}
UEdGraphPin* LastActiveOutputPin = Pins[0];
// Only look for FunctionEntry nodes who were duplicated and have a source object
if ( UK2Node_FunctionEntry* OriginalNode = Cast<UK2Node_FunctionEntry>(CompilerContext.MessageLog.FindSourceObject(this)) )
{
check(OriginalNode->GetOuter());
// Find the associated UFunction
UFunction* Function = FindField<UFunction>(CompilerContext.Blueprint->SkeletonGeneratedClass, *OriginalNode->GetOuter()->GetName());
for (TFieldIterator<UProperty> It(Function); It; ++It)
{
if (const UProperty* Property = *It)
{
for (auto& LocalVar : LocalVariables)
{
if (LocalVar.VarName == Property->GetFName() && !LocalVar.DefaultValue.IsEmpty())
{
// Add a variable set node for the local variable and hook it up immediately following the entry node or the last added local variable
UK2Node_VariableSet* VariableSetNode = CompilerContext.SpawnIntermediateNode<UK2Node_VariableSet>(this, SourceGraph);
VariableSetNode->SetFromProperty(Property, false);
Schema->ConfigureVarNode(VariableSetNode, LocalVar.VarName, Function, CompilerContext.Blueprint);
VariableSetNode->AllocateDefaultPins();
CompilerContext.MessageLog.NotifyIntermediateObjectCreation(VariableSetNode, this);
if(UEdGraphPin* SetPin = VariableSetNode->FindPin(Property->GetName()))
{
if(LocalVar.VarType.bIsArray)
{
TSharedPtr<FStructOnScope> StructData = MakeShareable(new FStructOnScope(Function));
FBlueprintEditorUtils::PropertyValueFromString(Property, LocalVar.DefaultValue, StructData->GetStructMemory());
// Create a Make Array node to setup the array's defaults
UK2Node_MakeArray* MakeArray = CompilerContext.SpawnIntermediateNode<UK2Node_MakeArray>(this, SourceGraph);
MakeArray->AllocateDefaultPins();
MakeArray->GetOutputPin()->MakeLinkTo(SetPin);
MakeArray->PostReconstructNode();
const UArrayProperty* ArrayProperty = Cast<UArrayProperty>(Property);
check(ArrayProperty);
FScriptArrayHelper_InContainer ArrayHelper(ArrayProperty, StructData->GetStructMemory());
FScriptArrayHelper_InContainer DefaultArrayHelper(ArrayProperty, StructData->GetStructMemory());
uint8* StructDefaults = NULL;
UStructProperty* StructProperty = dynamic_cast<UStructProperty*>(ArrayProperty->Inner);
if ( StructProperty != NULL )
{
checkSlow(StructProperty->Struct);
StructDefaults = (uint8*)FMemory::Malloc(StructProperty->Struct->GetStructureSize());
StructProperty->InitializeValue(StructDefaults);
}
// Go through each element in the array to set the default value
for( int32 ArrayIndex = 0 ; ArrayIndex < ArrayHelper.Num() ; ArrayIndex++ )
{
uint8* PropData = ArrayHelper.GetRawPtr(ArrayIndex);
// Always use struct defaults if the inner is a struct, for symmetry with the import of array inner struct defaults
uint8* PropDefault = ( StructProperty != NULL ) ? StructDefaults :
( ( StructData->GetStructMemory() && DefaultArrayHelper.Num() > ArrayIndex ) ? DefaultArrayHelper.GetRawPtr(ArrayIndex) : NULL );
// Retrieve the element's default value
FString DefaultValue;
FBlueprintEditorUtils::PropertyValueToString(ArrayProperty->Inner, PropData, DefaultValue);
if(ArrayIndex > 0)
{
MakeArray->AddInputPin();
}
// Add one to the index for the pin to set the default on to skip the output pin
Schema->TrySetDefaultValue(*MakeArray->Pins[ArrayIndex + 1], DefaultValue);
}
}
else
{
// Set the default value
Schema->TrySetDefaultValue(*SetPin, LocalVar.DefaultValue);
}
}
LastActiveOutputPin->BreakAllPinLinks();
LastActiveOutputPin->MakeLinkTo(VariableSetNode->Pins[0]);
LastActiveOutputPin = VariableSetNode->Pins[1];
}
}
}
}
// Finally, hook up the last node to the old node the function entry node was connected to
if(OldStartExecPin)
{
LastActiveOutputPin->MakeLinkTo(OldStartExecPin);
}
}
}
void FKCHandler_VariableSet::Transform(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
// Expands node out to include a (local) call to the RepNotify function if necessary
UK2Node_VariableSet* SetNotify = Cast<UK2Node_VariableSet>(Node);
if ((SetNotify != NULL))
{
if (SetNotify->ShouldFlushDormancyOnSet())
{
// Create CallFuncNode
UK2Node_CallFunction* CallFuncNode = Node->GetGraph()->CreateBlankNode<UK2Node_CallFunction>();
CallFuncNode->FunctionReference.SetExternalMember(NAME_FlushNetDormancy, AActor::StaticClass() );
CallFuncNode->AllocateDefaultPins();
// Copy self pin
UEdGraphPin* NewSelfPin = CallFuncNode->FindPinChecked(CompilerContext.GetSchema()->PN_Self);
UEdGraphPin* OldSelfPin = Node->FindPinChecked(CompilerContext.GetSchema()->PN_Self);
NewSelfPin->CopyPersistentDataFromOldPin(*OldSelfPin);
// link new CallFuncNode -> Set Node
UEdGraphPin* OldExecPin = Node->FindPin(CompilerContext.GetSchema()->PN_Execute);
check(OldExecPin);
UEdGraphPin* NewExecPin = CallFuncNode->GetExecPin();
if (ensure(NewExecPin))
{
NewExecPin->CopyPersistentDataFromOldPin(*OldExecPin);
OldExecPin->BreakAllPinLinks();
CallFuncNode->GetThenPin()->MakeLinkTo(OldExecPin);
}
}
if (SetNotify->HasLocalRepNotify())
{
UK2Node_CallFunction* CallFuncNode = Node->GetGraph()->CreateBlankNode<UK2Node_CallFunction>();
CallFuncNode->FunctionReference.SetExternalMember(SetNotify->GetRepNotifyName(), SetNotify->GetVariableSourceClass() );
CallFuncNode->AllocateDefaultPins();
// Copy self pin
UEdGraphPin* NewSelfPin = CallFuncNode->FindPinChecked(CompilerContext.GetSchema()->PN_Self);
UEdGraphPin* OldSelfPin = Node->FindPinChecked(CompilerContext.GetSchema()->PN_Self);
NewSelfPin->CopyPersistentDataFromOldPin(*OldSelfPin);
// link Set Node -> new CallFuncNode
UEdGraphPin* OldThenPin = Node->FindPin(CompilerContext.GetSchema()->PN_Then);
check(OldThenPin);
UEdGraphPin* NewThenPin = CallFuncNode->GetThenPin();
if (ensure(NewThenPin))
{
// Link Set Node -> Notify
NewThenPin->CopyPersistentDataFromOldPin(*OldThenPin);
OldThenPin->BreakAllPinLinks();
OldThenPin->MakeLinkTo(CallFuncNode->GetExecPin());
}
}
}
}
void SGraphNodeK2Var::UpdateGraphNode()
{
InputPins.Empty();
OutputPins.Empty();
// Reset variables that are going to be exposed, in case we are refreshing an already setup node.
RightNodeBox.Reset();
LeftNodeBox.Reset();
FText TitleText;
bool bPadTitle = false;
float HorizontalTitleMargin = 0.0f;
float VerticalTitleMargin = 8.0f;
FMargin TitleMargin = FMargin(0.0f, 8.0f);
FMargin ContentAreaMargin = FMargin(0.0f, 4.0f);
EHorizontalAlignment TitleHAlign = HAlign_Center;
TSharedPtr<SWidget> TitleWidget;
if (GraphNode->IsA(UK2Node_VariableSet::StaticClass()))
{
UK2Node_VariableSet *SetNode = Cast<UK2Node_VariableSet>(GraphNode);
if(SetNode->HasLocalRepNotify())
{
TitleText = NSLOCTEXT("GraphEditor", "VariableSetWithNotify", "SET w/ Notify");
}
else
{
TitleText = NSLOCTEXT("GraphEditor", "VariableSet", "SET");
}
}
else if (UK2Node_StructOperation* StructOp = Cast<UK2Node_StructOperation>(GraphNode))
{
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), StructOp->GetVarNameText());
if (GraphNode->IsA(UK2Node_StructMemberGet::StaticClass()))
{
TitleText = FText::Format(NSLOCTEXT("GraphEditor", "StructMemberGet", "Get in {VariableName}"), Args);
}
else if (GraphNode->IsA(UK2Node_StructMemberSet::StaticClass()))
{
TitleText = FText::Format(NSLOCTEXT("GraphEditor", "StructMemberSet", "Set in {VariableName}"), Args);
}
else if (GraphNode->IsA(UK2Node_MakeStruct::StaticClass()))
{
TitleText = FText::Format(NSLOCTEXT("GraphEditor", "MakeStruct", "Make {VariableName}"), Args);
}
else
{
check(false);
}
bPadTitle = true;
HorizontalTitleMargin = 12.0f;
TitleMargin = FMargin(12.0f, VerticalTitleMargin);
}
else if (UK2Node_Literal* LiteralRef = Cast<UK2Node_Literal>(GraphNode))
{
FText SubTitleText;
// Get the name of the level the object is in.
if(AActor* Actor = Cast<AActor>(LiteralRef->GetObjectRef()))
{
FText LevelName;
if(ULevel* Level = Actor->GetLevel())
{
if ( Level->IsPersistentLevel() )
{
LevelName = NSLOCTEXT("GraphEditor", "PersistentTag", "Persistent Level");
}
else
{
LevelName = FText::FromString(FPaths::GetCleanFilename(Actor->GetOutermost()->GetName()));
}
}
SubTitleText = FText::Format(NSLOCTEXT("GraphEditor", "ActorRef", "from {0}"), LevelName);
}
TitleText = GraphNode->GetNodeTitle(ENodeTitleType::FullTitle);
TitleHAlign = HAlign_Left;
TitleMargin = FMargin(12.0f, VerticalTitleMargin, 32.0f, 2.0f);
TitleWidget =
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.HAlign(HAlign_Left)
.VAlign(VAlign_Top)
.AutoWidth()
[
SNew(SImage)
.Image(FSlateIconFinder::FindIconBrushForClass(LiteralRef->GetObjectRef() ? LiteralRef->GetObjectRef()->GetClass() : NULL))
]
+SHorizontalBox::Slot()
.Padding(2.0f, 0.0f, 0.0f, 0.0f)
.HAlign(HAlign_Left)
.VAlign(VAlign_Top)
.AutoWidth()
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
.VAlign(VAlign_Top)
.AutoHeight()
[
SNew(STextBlock)
.WrapTextAt(128.0f)
.TextStyle( FEditorStyle::Get(), "Graph.Node.NodeTitle" )
.Text(TitleText)
]
+SVerticalBox::Slot()
.VAlign(VAlign_Top)
.AutoHeight()
[
SNew(STextBlock)
.Visibility(TitleText.IsEmpty()? EVisibility::Collapsed : EVisibility::Visible)
.WrapTextAt(128.0f)
.TextStyle( FEditorStyle::Get(), "Graph.Node.NodeTitleExtraLines" )
.Text(SubTitleText)
]
];
}
else if (UK2Node_VariableGet* VariableGet = Cast<UK2Node_VariableGet>(GraphNode))
{
if (!VariableGet->IsNodePure())
{
TitleText = NSLOCTEXT("GraphEditor", "VariableGet", "GET");
ContentAreaMargin.Top += 16;
}
}
if (TitleText.IsEmpty())
{
TitleWidget = SNullWidget::NullWidget;
}
if(!TitleWidget.IsValid())
{
TitleWidget = SNew(STextBlock)
.TextStyle( FEditorStyle::Get(), "Graph.Node.NodeTitle" )
.Text(TitleText);
}
SetupErrorReporting();
// Setup a meta tag for this node
FGraphNodeMetaData TagMeta(TEXT("Graphnode"));
PopulateMetaTag(&TagMeta);
// ________________
// | (>) L | R (>) |
// | (>) E | I (>) |
// | (>) F | G (>) |
// | (>) T | H (>) |
// | | T (>) |
// |_______|________|
//
this->ContentScale.Bind( this, &SGraphNode::GetContentScale );
this->GetOrAddSlot( ENodeZone::Center )
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
[
SNew(SVerticalBox)
+SVerticalBox::Slot()
[
SNew(SOverlay)
.AddMetaData<FGraphNodeMetaData>(TagMeta)
+ SOverlay::Slot()
[
SNew(SImage)
.Image( FEditorStyle::GetBrush("Graph.VarNode.Body") )
]
+ SOverlay::Slot()
.VAlign(VAlign_Top)
[
SNew(SImage)
.Image( FEditorStyle::GetBrush("Graph.VarNode.ColorSpill") )
.ColorAndOpacity( this, &SGraphNodeK2Var::GetVariableColor )
]
+ SOverlay::Slot()
[
SNew(SImage)
.Image( FEditorStyle::GetBrush("Graph.VarNode.Gloss") )
]
+SOverlay::Slot()
.VAlign(VAlign_Top)
.HAlign(TitleHAlign)
.Padding( TitleMargin )
[
TitleWidget.ToSharedRef()
]
+ SOverlay::Slot()
.Padding( ContentAreaMargin )
[
// NODE CONTENT AREA
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.HAlign(HAlign_Left)
.FillWidth(1.0f)
.Padding( FMargin(2,0) )
[
// LEFT
SAssignNew(LeftNodeBox, SVerticalBox)
]
+ SHorizontalBox::Slot()
.AutoWidth()
.HAlign(HAlign_Right)
.Padding( FMargin(2,0) )
[
// RIGHT
SAssignNew(RightNodeBox, SVerticalBox)
]
]
]
+SVerticalBox::Slot()
.VAlign(VAlign_Top)
.AutoHeight()
.Padding( FMargin(5.0f, 1.0f) )
[
ErrorReporting->AsWidget()
]
];
float VerticalPaddingAmount = 0.0f;
// Add padding widgets at the top of the pin boxes if it's a struct operation with a long title
if (bPadTitle)
{
VerticalPaddingAmount += 16.0f;
}
// Add padding to offset the exec pin so that it will align with other nodes
if (UK2Node* K2Node = Cast<UK2Node>(GraphNode))
{
if (!K2Node->IsNodePure())
{
VerticalPaddingAmount += 7.0f;
}
}
if (VerticalPaddingAmount > 0.0f)
{
LeftNodeBox->AddSlot()
.AutoHeight()
.HAlign(HAlign_Left)
.VAlign(VAlign_Center)
[
SNew(SSpacer).Size(FVector2D(0.0f, VerticalPaddingAmount))
];
RightNodeBox->AddSlot()
.AutoHeight()
.HAlign(HAlign_Left)
.VAlign(VAlign_Center)
[
SNew(SSpacer).Size(FVector2D(0.0f, VerticalPaddingAmount))
];
}
// Create comment bubble
TSharedPtr<SCommentBubble> CommentBubble;
const FSlateColor CommentColor = GetDefault<UGraphEditorSettings>()->DefaultCommentNodeTitleColor;
SAssignNew( CommentBubble, SCommentBubble )
.GraphNode( GraphNode )
.Text( this, &SGraphNode::GetNodeComment )
.OnTextCommitted( this, &SGraphNode::OnCommentTextCommitted )
.ColorAndOpacity( CommentColor )
.AllowPinning( true )
.EnableTitleBarBubble( true )
.EnableBubbleCtrls( true )
.GraphLOD( this, &SGraphNode::GetCurrentLOD )
.IsGraphNodeHovered( this, &SGraphNode::IsHovered );
GetOrAddSlot( ENodeZone::TopCenter )
.SlotOffset( TAttribute<FVector2D>( CommentBubble.Get(), &SCommentBubble::GetOffset ))
.SlotSize( TAttribute<FVector2D>( CommentBubble.Get(), &SCommentBubble::GetSize ))
.AllowScaling( TAttribute<bool>( CommentBubble.Get(), &SCommentBubble::IsScalingAllowed ))
.VAlign( VAlign_Top )
[
CommentBubble.ToSharedRef()
];
// Create widgets for each of the real pins
CreatePinWidgets();
}