void UK2Node_GetClassDefaults::OnClassPinChanged()
{
TArray<UEdGraphPin*> OldPins = Pins;
TArray<UEdGraphPin*> OldOutputPins;
// Gather all current output pins
for(int32 PinIndex = 0; PinIndex < OldPins.Num(); ++PinIndex)
{
UEdGraphPin* OldPin = OldPins[PinIndex];
if(OldPin->Direction == EGPD_Output)
{
Pins.Remove(OldPin);
OldOutputPins.Add(OldPin);
}
}
// Clear the current output pin settings (so they don't carry over to the new set)
ShowPinForProperties.Empty();
// Create output pins for the new class type
UClass* InputClass = GetInputClass();
CreateOutputPins(InputClass);
// Destroy the previous set of output pins
DestroyPinList(OldOutputPins);
// Notify the graph that the node has been changed
if(UEdGraph* Graph = GetGraph())
{
Graph->NotifyGraphChanged();
}
}
void UK2Node_GetClassDefaults::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
const UClass* ClassType = GetInputClass();
// @TODO - Remove if/when we support 'const' input pins.
// For array properties, return a local copy of the array so that the original cannot be modified.
for(UEdGraphPin* OutputPin : Pins)
{
if(OutputPin != nullptr && OutputPin->Direction == EGPD_Output && OutputPin->LinkedTo.Num() > 0)
{
UProperty* BoundProperty = FindField<UProperty>(ClassType, *(OutputPin->PinName));
if(BoundProperty != nullptr && BoundProperty->IsA<UArrayProperty>())
{
UK2Node_TemporaryVariable* LocalVariable = CompilerContext.SpawnIntermediateNode<UK2Node_TemporaryVariable>(this, SourceGraph);
LocalVariable->VariableType = OutputPin->PinType;
LocalVariable->VariableType.bIsReference = false;
LocalVariable->AllocateDefaultPins();
UK2Node_PureAssignmentStatement* CopyDefaultValue = CompilerContext.SpawnIntermediateNode<UK2Node_PureAssignmentStatement>(this, SourceGraph);
CopyDefaultValue->AllocateDefaultPins();
CompilerContext.GetSchema()->TryCreateConnection(LocalVariable->GetVariablePin(), CopyDefaultValue->GetVariablePin());
// Note: This must be done AFTER connecting the variable input, which sets the pin type.
CompilerContext.MovePinLinksToIntermediate(*OutputPin, *CopyDefaultValue->GetOutputPin());
CompilerContext.GetSchema()->TryCreateConnection(OutputPin, CopyDefaultValue->GetValuePin());
}
}
}
}
void UK2Node_GetClassDefaults::ReallocatePinsDuringReconstruction(TArray<UEdGraphPin*>& OldPins)
{
Super::ReallocatePinsDuringReconstruction(OldPins);
// Recreate output pins based on the previous input class
UEdGraphPin* OldClassPin = FindClassPin(OldPins);
if(UClass* InputClass = GetInputClass(OldClassPin))
{
CreateOutputPins(InputClass);
}
}
bool UK2Node_GetClassDefaults::HasExternalDependencies(TArray<class UStruct*>* OptionalOutput) const
{
UClass* SourceClass = GetInputClass();
UBlueprint* SourceBlueprint = GetBlueprint();
const bool bResult = (SourceClass && (SourceClass->ClassGeneratedBy != SourceBlueprint));
if (bResult && OptionalOutput)
{
OptionalOutput->AddUnique(SourceClass);
}
const bool bSuperResult = Super::HasExternalDependencies(OptionalOutput);
return bSuperResult || bResult;
}
void UK2Node_GetClassDefaults::PostPlacedNewNode()
{
// Always exclude object array properties for new nodes.
// @TODO - Could potentially expose object reference values if/when we have support for 'const' input pins.
bExcludeObjectArrays = true;
if(UEdGraphPin* ClassPin = FindClassPin(Pins))
{
// Default to the owner BP's generated class for "normal" BPs if this is a new node
const UBlueprint* OwnerBlueprint = GetBlueprint();
if(OwnerBlueprint != nullptr && OwnerBlueprint->BlueprintType == BPTYPE_Normal)
{
ClassPin->DefaultObject = OwnerBlueprint->GeneratedClass;
}
if(UClass* InputClass = GetInputClass(ClassPin))
{
CreateOutputPins(InputClass);
}
}
}
void UK2Node_GetClassDefaults::ValidateNodeDuringCompilation(class FCompilerResultsLog& MessageLog) const
{
Super::ValidateNodeDuringCompilation(MessageLog);
if(auto SourceClass = GetInputClass())
{
for(auto Pin : Pins)
{
if(Pin && Pin->Direction == EGPD_Output && Pin->LinkedTo.Num() > 0)
{
// Emit a warning for existing connections to potentially unsafe array property defaults. We do this rather than just implicitly breaking the connection (for compatibility).
if(auto ArrayProperty = Cast<UArrayProperty>(SourceClass->FindPropertyByName(FName(*Pin->PinName))))
{
// Even though array property defaults are copied, the copy could still contain a reference to a non-class object that belongs to the CDO, which would potentially be unsafe to modify.
if(ArrayProperty->Inner && ArrayProperty->Inner->IsA<UObjectProperty>() && !ArrayProperty->Inner->IsA<UClassProperty>())
{
MessageLog.Warning(*LOCTEXT("UnsafeConnectionWarning", "@@ has an unsafe connection to the @@ output pin that is not fully supported at this time. It should be disconnected to avoid potentially corrupting class defaults at runtime. If you need to keep this connection, make sure you're not changing the state of any elements in the array. Also note that if you recreate this node, it will not include this output pin.").ToString(), this, Pin);
}
}
}
}
}
}
