Files
UnrealEngine/Engine/Source/Editor/BlueprintGraph/Private/K2Node_VariableSetRef.cpp
2025-05-18 13:04:45 +08:00

354 lines
11 KiB
C++

// Copyright Epic Games, Inc. All Rights Reserved.
#include "K2Node_VariableSetRef.h"
#include "BPTerminal.h"
#include "BlueprintActionDatabaseRegistrar.h"
#include "BlueprintActionFilter.h"
#include "BlueprintCompiledStatement.h"
#include "BlueprintNodeSpawner.h"
#include "Containers/EnumAsByte.h"
#include "Containers/Map.h"
#include "EdGraph/EdGraph.h"
#include "EdGraph/EdGraphPin.h"
#include "EdGraphSchema_K2.h"
#include "EdGraphUtilities.h"
#include "EditorCategoryUtils.h"
#include "HAL/PlatformCrt.h"
#include "Internationalization/Internationalization.h"
#include "Kismet2/CompilerResultsLog.h"
#include "KismetCastingUtils.h"
#include "KismetCompiledFunctionContext.h"
#include "KismetCompiler.h"
#include "Misc/AssertionMacros.h"
#include "Templates/Casts.h"
#include "UObject/Class.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
#include "UObject/WeakObjectPtrTemplates.h"
#include "VariableSetHandler.h"
static FName TargetVarPinName(TEXT("Target"));
static FName VarValuePinName(TEXT("Value"));
#define LOCTEXT_NAMESPACE "K2Node_VariableSetRef"
class FKCHandler_VariableSetRef : public FKCHandler_VariableSet
{
public:
FKCHandler_VariableSetRef(FKismetCompilerContext& InCompilerContext)
: FKCHandler_VariableSet(InCompilerContext)
{
}
virtual void RegisterNets(FKismetFunctionContext& Context, UEdGraphNode* Node) override
{
UK2Node_VariableSetRef* VarRefNode = CastChecked<UK2Node_VariableSetRef>(Node);
UEdGraphPin* ValuePin = VarRefNode->GetValuePin();
ValidateAndRegisterNetIfLiteral(Context, ValuePin);
{
// The pins on UK2Node_VariableSetRef don't actually refer to storage, so there's nothing to register in the NetMap.
// However, their pins' nets do, so we need to check if a cast is required for assignment to the target net.
// The cast detection performed by RegisterImplicitCasts doesn't understand the reference semantics used in this node.
// As a result, we need to manually handle any implicit casts.
using namespace UE::KismetCompiler;
UEdGraphPin* VariablePin = VarRefNode->GetTargetPin();
UEdGraphPin* VariablePinNet = FEdGraphUtilities::GetNetFromPin(VariablePin);
UEdGraphPin* ValuePinNet = FEdGraphUtilities::GetNetFromPin(ValuePin);
if ((VariablePinNet != nullptr) && (ValuePinNet != nullptr))
{
CastingUtils::FConversion Conversion =
CastingUtils::GetFloatingPointConversion(*ValuePinNet, *VariablePinNet);
if (Conversion.Type != CastingUtils::FloatingPointCastType::None)
{
check(!ImplicitCastMap.Contains(VarRefNode));
FBPTerminal* NewTerminal = CastingUtils::MakeImplicitCastTerminal(Context, VariablePinNet);
ImplicitCastMap.Add(VarRefNode, CastingUtils::FImplicitCastParams{Conversion, NewTerminal, Node});
}
}
}
}
virtual void Compile(FKismetFunctionContext& Context, UEdGraphNode* Node) override
{
UK2Node_VariableSetRef* VarRefNode = CastChecked<UK2Node_VariableSetRef>(Node);
UEdGraphPin* VarTargetPin = VarRefNode->GetTargetPin();
UEdGraphPin* ValuePin = VarRefNode->GetValuePin();
InnerAssignment(Context, Node, VarTargetPin, ValuePin);
// Generate the output impulse from this node
GenerateSimpleThenGoto(Context, *Node);
}
private:
void InnerAssignment(FKismetFunctionContext& Context, UEdGraphNode* Node, UEdGraphPin* VariablePin, UEdGraphPin* ValuePin)
{
UEdGraphPin* VariablePinNet = FEdGraphUtilities::GetNetFromPin(VariablePin);
UEdGraphPin* ValuePinNet = FEdGraphUtilities::GetNetFromPin(ValuePin);
FBPTerminal** VariableTerm = Context.NetMap.Find(VariablePin);
if (VariableTerm == nullptr)
{
VariableTerm = Context.NetMap.Find(VariablePinNet);
}
FBPTerminal** ValueTerm = Context.LiteralHackMap.Find(ValuePin);
if (ValueTerm == nullptr)
{
ValueTerm = Context.NetMap.Find(ValuePinNet);
}
if ((VariableTerm != nullptr) && (ValueTerm != nullptr))
{
FBPTerminal* LHSTerm = *VariableTerm;
FBPTerminal* RHSTerm = *ValueTerm;
{
using namespace UE::KismetCompiler;
UK2Node_VariableSetRef* VarRefNode = CastChecked<UK2Node_VariableSetRef>(Node);
if (CastingUtils::FImplicitCastParams* CastParams = ImplicitCastMap.Find(VarRefNode))
{
CastingUtils::InsertImplicitCastStatement(Context, *CastParams, RHSTerm);
RHSTerm = CastParams->TargetTerminal;
ImplicitCastMap.Remove(VarRefNode);
// We've manually registered our cast statement, so it can be removed from the context.
CastingUtils::RemoveRegisteredImplicitCast(Context, VariablePin);
CastingUtils::RemoveRegisteredImplicitCast(Context, ValuePin);
}
}
FBlueprintCompiledStatement& Statement = Context.AppendStatementForNode(Node);
Statement.Type = KCST_Assignment;
Statement.LHS = LHSTerm;
Statement.RHS.Add(RHSTerm);
if (!(*VariableTerm)->IsTermWritable())
{
CompilerContext.MessageLog.Error(*LOCTEXT("WriteConst_Error", "Cannot write to const @@").ToString(), VariablePin);
}
}
else
{
if (VariablePin != ValuePin)
{
CompilerContext.MessageLog.Error(*LOCTEXT("ResolveValueIntoVariablePin_Error", "Failed to resolve term @@ passed into @@").ToString(), ValuePin, VariablePin);
}
else
{
CompilerContext.MessageLog.Error(*LOCTEXT("ResolveTermPassed_Error", "Failed to resolve term passed into @@").ToString(), VariablePin);
}
}
}
TMap<UK2Node_VariableSetRef*, UE::KismetCompiler::CastingUtils::FImplicitCastParams> ImplicitCastMap;
};
UK2Node_VariableSetRef::UK2Node_VariableSetRef(const FObjectInitializer& ObjectInitializer)
: Super(ObjectInitializer)
{
}
void UK2Node_VariableSetRef::AllocateDefaultPins()
{
CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_Execute);
CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Exec, UEdGraphSchema_K2::PN_Then);
UEdGraphNode::FCreatePinParams PinParams;
PinParams.bIsReference = true;
CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Wildcard, TargetVarPinName, PinParams);
CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Wildcard, VarValuePinName);
}
void UK2Node_VariableSetRef::ReallocatePinsDuringReconstruction(TArray<UEdGraphPin*>& OldPins)
{
AllocateDefaultPins();
// Coerce the type of the node from the old pin, if available
UEdGraphPin* OldTargetPin = nullptr;
for (UEdGraphPin* CurrPin : OldPins)
{
if (CurrPin->PinName == TargetVarPinName)
{
OldTargetPin = CurrPin;
break;
}
}
if( OldTargetPin )
{
UEdGraphPin* NewTargetPin = GetTargetPin();
CoerceTypeFromPin(OldTargetPin);
}
CachedNodeTitle.MarkDirty();
RestoreSplitPins(OldPins);
}
FText UK2Node_VariableSetRef::GetTooltipText() const
{
return NSLOCTEXT("K2Node", "SetValueOfRefVariable", "Set the value of the connected pass-by-ref variable");
}
FText UK2Node_VariableSetRef::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* TargetPin = GetTargetPin();
if ((TargetPin == nullptr) || (TargetPin->PinType.PinCategory == UEdGraphSchema_K2::PC_Wildcard))
{
return NSLOCTEXT("K2Node", "SetRefVarNodeTitle", "Set By-Ref Var");
}
else if (CachedNodeTitle.IsOutOfDate(this))
{
FFormatNamedArguments Args;
Args.Add(TEXT("PinType"), Schema->TypeToText(TargetPin->PinType));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle.SetCachedText(FText::Format(NSLOCTEXT("K2Node", "SetRefVarNodeTitle_Typed", "Set {PinType}"), Args), this);
}
return CachedNodeTitle;
}
bool UK2Node_VariableSetRef::IsActionFilteredOut(class FBlueprintActionFilter const& Filter)
{
// Default to filtering this node out unless dragging off of a reference output pin
bool bIsFilteredOut = false;
FBlueprintActionContext const& FilterContext = Filter.Context;
for (UEdGraphPin* Pin : FilterContext.Pins)
{
if(Pin->Direction == EGPD_Output && Pin->PinType.bIsReference == true)
{
bIsFilteredOut = false;
break;
}
}
return bIsFilteredOut;
}
void UK2Node_VariableSetRef::NotifyPinConnectionListChanged(UEdGraphPin* Pin)
{
Super::NotifyPinConnectionListChanged(Pin);
UEdGraphPin* TargetPin = GetTargetPin();
UEdGraphPin* ValuePin = GetValuePin();
if( (Pin == TargetPin) || (Pin == ValuePin) )
{
UEdGraphPin* ConnectedToPin = (Pin->LinkedTo.Num() > 0) ? Pin->LinkedTo[0] : nullptr;
CoerceTypeFromPin(ConnectedToPin);
// If both target and value pins are unlinked, then reset types to wildcard
if(TargetPin->LinkedTo.Num() == 0 && ValuePin->LinkedTo.Num() == 0)
{
// collapse SubPins back into their parent if there are any
auto TryRecombineSubPins = [](UEdGraphPin* ParentPin)
{
if (!ParentPin->SubPins.IsEmpty())
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
K2Schema->RecombinePin(ParentPin->SubPins[0]);
}
};
// Pin disconnected...revert to wildcard
TargetPin->PinType.PinCategory = UEdGraphSchema_K2::PC_Wildcard;
TargetPin->PinType.PinSubCategory = NAME_None;
TargetPin->PinType.PinSubCategoryObject = nullptr;
TargetPin->BreakAllPinLinks();
TryRecombineSubPins(TargetPin);
ValuePin->PinType.PinCategory = UEdGraphSchema_K2::PC_Wildcard;
ValuePin->PinType.PinSubCategory = NAME_None;
ValuePin->PinType.PinSubCategoryObject = nullptr;
ValuePin->BreakAllPinLinks();
TryRecombineSubPins(ValuePin);
}
CachedNodeTitle.MarkDirty();
// Get the graph to refresh our title and default value info
GetGraph()->NotifyNodeChanged(this);
}
}
void UK2Node_VariableSetRef::CoerceTypeFromPin(const UEdGraphPin* Pin)
{
UEdGraphPin* TargetPin = GetTargetPin();
UEdGraphPin* ValuePin = GetValuePin();
check(TargetPin && ValuePin);
if( Pin &&
(Pin->PinType.PinCategory != UEdGraphSchema_K2::PC_Wildcard ||
( Pin->PinType.PinCategory == TargetPin->PinType.PinCategory &&
Pin->PinType.PinCategory == ValuePin->PinType.PinCategory )
) )
{
check((Pin != TargetPin) || (Pin->PinType.bIsReference && !Pin->PinType.IsContainer()));
TargetPin->PinType = Pin->PinType;
TargetPin->PinType.bIsReference = true;
ValuePin->PinType = Pin->PinType;
ValuePin->PinType.bIsReference = false;
}
}
UEdGraphPin* UK2Node_VariableSetRef::GetTargetPin() const
{
return FindPin(TargetVarPinName);
}
UEdGraphPin* UK2Node_VariableSetRef::GetValuePin() const
{
return FindPin(VarValuePinName);
}
FNodeHandlingFunctor* UK2Node_VariableSetRef::CreateNodeHandler(FKismetCompilerContext& CompilerContext) const
{
return new FKCHandler_VariableSetRef(CompilerContext);
}
void UK2Node_VariableSetRef::GetMenuActions(FBlueprintActionDatabaseRegistrar& ActionRegistrar) const
{
// actions get registered under specific object-keys; the idea is that
// actions might have to be updated (or deleted) if their object-key is
// mutated (or removed)... here we use the node's class (so if the node
// type disappears, then the action should go with it)
UClass* ActionKey = GetClass();
// to keep from needlessly instantiating a UBlueprintNodeSpawner, first
// check to make sure that the registrar is looking for actions of this type
// (could be regenerating actions for a specific asset, and therefore the
// registrar would only accept actions corresponding to that asset)
if (ActionRegistrar.IsOpenForRegistration(ActionKey))
{
UBlueprintNodeSpawner* NodeSpawner = UBlueprintNodeSpawner::Create(GetClass());
check(NodeSpawner != nullptr);
ActionRegistrar.AddBlueprintAction(ActionKey, NodeSpawner);
}
}
FText UK2Node_VariableSetRef::GetMenuCategory() const
{
return FEditorCategoryUtils::GetCommonCategory(FCommonEditorCategory::Variables);
}
#undef LOCTEXT_NAMESPACE