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_MultiGate::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
/////////////////////////////
// Handle the "Reset"
/////////////////////////////
// Redirect the reset pin if linked to
UEdGraphPin* ResetPin = GetResetPin();
if (ResetPin->LinkedTo.Num() > 0)
{
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
/////////////////////////////
// Temporary Variable node
/////////////////////////////
// Create the node
UK2Node_TemporaryVariable* TempVarNode = SourceGraph->CreateBlankNode<UK2Node_TemporaryVariable>();
TempVarNode->VariableType.PinCategory = Schema->PC_Int;
TempVarNode->AllocateDefaultPins();
CompilerContext.MessageLog.NotifyIntermediateObjectCreation(TempVarNode, this);
// Give a reference of the variable node to the multi gate node
DataNode = TempVarNode;
/////////////////////////////
// Assignment node
/////////////////////////////
// Create the node
UK2Node_AssignmentStatement* AssignmentNode = SourceGraph->CreateBlankNode<UK2Node_AssignmentStatement>();
AssignmentNode->AllocateDefaultPins();
CompilerContext.MessageLog.NotifyIntermediateObjectCreation(AssignmentNode, this);
// Coerce the wildcards pin types (set the default of the value to 0)
AssignmentNode->GetVariablePin()->PinType = TempVarNode->GetVariablePin()->PinType;
AssignmentNode->GetVariablePin()->MakeLinkTo(TempVarNode->GetVariablePin());
AssignmentNode->GetValuePin()->PinType = TempVarNode->GetVariablePin()->PinType;
AssignmentNode->GetValuePin()->DefaultValue = TEXT("0");
// Move the "Reset" link to the Assignment node
CompilerContext.MovePinLinksToIntermediate(*ResetPin, *AssignmentNode->GetExecPin());
}
}
/**
* This is essentially a mix of K2Node_BaseAsyncTask::ExpandNode and K2Node_SpawnActorFromClass::ExpandNode.
* Several things are going on here:
* -Factory call to create proxy object (K2Node_BaseAsyncTask)
* -Task return delegates are created and hooked up (K2Node_BaseAsyncTask)
* -A BeginSpawn function is called on proxyu object (similiar to K2Node_SpawnActorFromClass)
* -BeginSpawn can choose to spawn or not spawn an actor (and return it)
* -If spawned:
* -SetVars are run on the newly spawned object (set expose on spawn variables - K2Node_SpawnActorFromClass)
* -FinishSpawn is called on the proxy object
*
*
* Also, a K2Node_SpawnActorFromClass could not be used directly here, since we want the proxy object to implement its own
* BeginSpawn/FinishSpawn function (custom game logic will often be performed in the native implementation). K2Node_SpawnActorFromClass also
* requires a SpawnTransform be wired into it, and in most ability task cases, the spawn transform is implied or not necessary.
*
*
*/
void UK2Node_LatentAbilityCall::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
bool validatedActorSpawn = ValidateActorSpawning(CompilerContext, false);
bool validatedActorArraySpawn = ValidateActorArraySpawning(CompilerContext, false);
UEdGraphPin* ClassPin = GetClassPin();
if (ClassPin == nullptr)
{
// Nothing special about this task, just call super
Super::ExpandNode(CompilerContext, SourceGraph);
return;
}
UK2Node::ExpandNode(CompilerContext, SourceGraph);
if (!validatedActorSpawn && !validatedActorArraySpawn)
{
ValidateActorSpawning(CompilerContext, true);
ValidateActorArraySpawning(CompilerContext, true);
}
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
check(SourceGraph && Schema);
bool bIsErrorFree = true;
// ------------------------------------------------------------------------------------------
// CREATE A CALL TO FACTORY THE PROXY OBJECT
// ------------------------------------------------------------------------------------------
UK2Node_CallFunction* const CallCreateProxyObjectNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
CallCreateProxyObjectNode->FunctionReference.SetExternalMember(ProxyFactoryFunctionName, ProxyFactoryClass);
CallCreateProxyObjectNode->AllocateDefaultPins();
bIsErrorFree &= CompilerContext.MovePinLinksToIntermediate(*FindPinChecked(Schema->PN_Execute), *CallCreateProxyObjectNode->FindPinChecked(Schema->PN_Execute)).CanSafeConnect();
for (auto CurrentPin : Pins)
{
if (FBaseAsyncTaskHelper::ValidDataPin(CurrentPin, EGPD_Input, Schema))
{
UEdGraphPin* DestPin = CallCreateProxyObjectNode->FindPin(CurrentPin->PinName); // match function inputs, to pass data to function from CallFunction node
// NEW: if no DestPin, assume it is a Class Spawn PRoperty - not an error
if (DestPin)
{
bIsErrorFree &= CompilerContext.CopyPinLinksToIntermediate(*CurrentPin, *DestPin).CanSafeConnect();
}
}
}
// ------------------------------------------------------------------------------------------
// GATHER OUTPUT PARAMETERS AND PAIR THEM WITH LOCAL VARIABLES
// ------------------------------------------------------------------------------------------
TArray<FBaseAsyncTaskHelper::FOutputPinAndLocalVariable> VariableOutputs;
for (auto CurrentPin : Pins)
{
if (FBaseAsyncTaskHelper::ValidDataPin(CurrentPin, EGPD_Output, Schema))
{
const FEdGraphPinType& PinType = CurrentPin->PinType;
UK2Node_TemporaryVariable* TempVarOutput = CompilerContext.SpawnInternalVariable(
this, PinType.PinCategory, PinType.PinSubCategory, PinType.PinSubCategoryObject.Get(), PinType.bIsArray);
bIsErrorFree &= TempVarOutput->GetVariablePin() && CompilerContext.MovePinLinksToIntermediate(*CurrentPin, *TempVarOutput->GetVariablePin()).CanSafeConnect();
VariableOutputs.Add(FBaseAsyncTaskHelper::FOutputPinAndLocalVariable(CurrentPin, TempVarOutput));
}
}
// ------------------------------------------------------------------------------------------
// FOR EACH DELEGATE DEFINE EVENT, CONNECT IT TO DELEGATE AND IMPLEMENT A CHAIN OF ASSIGMENTS
// ------------------------------------------------------------------------------------------
UEdGraphPin* LastThenPin = CallCreateProxyObjectNode->FindPinChecked(Schema->PN_Then);
UEdGraphPin* const ProxyObjectPin = CallCreateProxyObjectNode->GetReturnValuePin();
for (TFieldIterator<UMulticastDelegateProperty> PropertyIt(ProxyClass, EFieldIteratorFlags::ExcludeSuper); PropertyIt && bIsErrorFree; ++PropertyIt)
{
bIsErrorFree &= FBaseAsyncTaskHelper::HandleDelegateImplementation(*PropertyIt, VariableOutputs, ProxyObjectPin, LastThenPin, this, SourceGraph, CompilerContext);
}
if (CallCreateProxyObjectNode->FindPinChecked(Schema->PN_Then) == LastThenPin)
{
CompilerContext.MessageLog.Error(*LOCTEXT("MissingDelegateProperties", "BaseAsyncTask: Proxy has no delegates defined. @@").ToString(), this);
return;
}
// ------------------------------------------------------------------------------------------
// NEW: CREATE A CALL TO THE PRESPAWN FUNCTION, IF IT RETURNS TRUE, THEN WE WILL SPAWN THE NEW ACTOR
// ------------------------------------------------------------------------------------------
FName ProxyPrespawnFunctionName = validatedActorArraySpawn ? *FK2Node_LatentAbilityCallHelper::BeginSpawnArrayFuncName : *FK2Node_LatentAbilityCallHelper::BeginSpawnFuncName;
UFunction* PreSpawnFunction = ProxyFactoryClass->FindFunctionByName(ProxyPrespawnFunctionName);
FName ProxyPostpawnFunctionName = validatedActorArraySpawn ? *FK2Node_LatentAbilityCallHelper::FinishSpawnArrayFuncName : *FK2Node_LatentAbilityCallHelper::FinishSpawnFuncName;
UFunction* PostSpawnFunction = ProxyFactoryClass->FindFunctionByName(ProxyPostpawnFunctionName);
if (PreSpawnFunction == nullptr)
{
if (validatedActorArraySpawn)
{
CompilerContext.MessageLog.Error(*LOCTEXT("MissingBeginSpawningActorArrayFunction", "AbilityTask: Proxy is missing BeginSpawningActorArray native function. @@").ToString(), this);
}
else
{
CompilerContext.MessageLog.Error(*LOCTEXT("MissingBeginSpawningActorFunction", "AbilityTask: Proxy is missing BeginSpawningActor native function. @@").ToString(), this);
}
return;
}
if (PostSpawnFunction == nullptr)
{
if (validatedActorArraySpawn)
{
CompilerContext.MessageLog.Error(*LOCTEXT("MissingFinishSpawningActorArrayFunction", "AbilityTask: Proxy is missing FinishSpawningActorArray native function. @@").ToString(), this);
}
else
{
CompilerContext.MessageLog.Error(*LOCTEXT("MissingFinishSpawningActorFunction", "AbilityTask: Proxy is missing FinishSpawningActor native function. @@").ToString(), this);
}
return;
}
UK2Node_CallFunction* const CallPrespawnProxyObjectNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
CallPrespawnProxyObjectNode->FunctionReference.SetExternalMember(ProxyPrespawnFunctionName, ProxyClass);
CallPrespawnProxyObjectNode->AllocateDefaultPins();
// Hook up the self connection
UEdGraphPin* PrespawnCallSelfPin = Schema->FindSelfPin(*CallPrespawnProxyObjectNode, EGPD_Input);
check(PrespawnCallSelfPin);
bIsErrorFree &= Schema->TryCreateConnection(ProxyObjectPin, PrespawnCallSelfPin);
// Hook up input parameters to PreSpawn
for (auto CurrentPin : Pins)
{
if (FBaseAsyncTaskHelper::ValidDataPin(CurrentPin, EGPD_Input, Schema))
{
UEdGraphPin* DestPin = CallPrespawnProxyObjectNode->FindPin(CurrentPin->PinName);
if (DestPin)
{
bIsErrorFree &= CompilerContext.CopyPinLinksToIntermediate(*CurrentPin, *DestPin).CanSafeConnect();
}
}
}
// Hook the activate node up in the exec chain
UEdGraphPin* PrespawnExecPin = CallPrespawnProxyObjectNode->FindPinChecked(Schema->PN_Execute);
UEdGraphPin* PrespawnThenPin = CallPrespawnProxyObjectNode->FindPinChecked(Schema->PN_Then);
UEdGraphPin* PrespawnReturnPin = CallPrespawnProxyObjectNode->FindPinChecked(Schema->PN_ReturnValue);
UEdGraphPin* SpawnedActorReturnPin = CallPrespawnProxyObjectNode->FindPinChecked(FK2Node_LatentAbilityCallHelper::SpawnedActorPinName);
bIsErrorFree &= Schema->TryCreateConnection(LastThenPin, PrespawnExecPin);
LastThenPin = PrespawnThenPin;
// -------------------------------------------
// Branch based on return value of Prespawn
// -------------------------------------------
UK2Node_IfThenElse* BranchNode = SourceGraph->CreateBlankNode<UK2Node_IfThenElse>();
BranchNode->AllocateDefaultPins();
CompilerContext.MessageLog.NotifyIntermediateObjectCreation(BranchNode, this);
// Link return value of prespawn with the branch condtional
bIsErrorFree &= Schema->TryCreateConnection(PrespawnReturnPin, BranchNode->GetConditionPin());
// Link our Prespawn call to the branch node
bIsErrorFree &= Schema->TryCreateConnection(LastThenPin, BranchNode->GetExecPin());
UEdGraphPin* BranchElsePin = BranchNode->GetElsePin();
LastThenPin = BranchNode->GetThenPin();
UClass* ClassToSpawn = GetClassToSpawn();
if (validatedActorArraySpawn && ClassToSpawn)
{
//Branch for main loop control
UK2Node_IfThenElse* Branch = CompilerContext.SpawnIntermediateNode<UK2Node_IfThenElse>(this, SourceGraph);
Branch->AllocateDefaultPins();
//Create int Iterator
UK2Node_TemporaryVariable* IteratorVar = CompilerContext.SpawnIntermediateNode<UK2Node_TemporaryVariable>(this, SourceGraph);
IteratorVar->VariableType.PinCategory = Schema->PC_Int;
IteratorVar->AllocateDefaultPins();
//Iterator assignment (initialization to zero)
UK2Node_AssignmentStatement* IteratorInitialize = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(this, SourceGraph);
IteratorInitialize->AllocateDefaultPins();
IteratorInitialize->GetValuePin()->DefaultValue = TEXT("0");
//Iterator assignment (incrementing)
UK2Node_AssignmentStatement* IteratorAssign = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(this, SourceGraph);
IteratorAssign->AllocateDefaultPins();
//Increment iterator command
UK2Node_CallFunction* Increment = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
Increment->SetFromFunction(UKismetMathLibrary::StaticClass()->FindFunctionByName(TEXT("Add_IntInt")));
Increment->AllocateDefaultPins();
Increment->FindPinChecked(TEXT("B"))->DefaultValue = TEXT("1");
//Array length
UK2Node_CallArrayFunction* ArrayLength = CompilerContext.SpawnIntermediateNode<UK2Node_CallArrayFunction>(this, SourceGraph);
ArrayLength->SetFromFunction(UKismetArrayLibrary::StaticClass()->FindFunctionByName(TEXT("Array_Length")));
ArrayLength->AllocateDefaultPins();
//Array element retrieval
UK2Node_CallArrayFunction* GetElement = CompilerContext.SpawnIntermediateNode<UK2Node_CallArrayFunction>(this, SourceGraph);
GetElement->SetFromFunction(UKismetArrayLibrary::StaticClass()->FindFunctionByName(TEXT("Array_Get")));
GetElement->AllocateDefaultPins();
//Check node for iterator versus array length
UK2Node_CallFunction* Condition = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
Condition->SetFromFunction(UKismetMathLibrary::StaticClass()->FindFunctionByName(TEXT("Less_IntInt")));
Condition->AllocateDefaultPins();
//Connections to set up the loop
UEdGraphSchema_K2 const* const K2Schema = Cast<const UEdGraphSchema_K2>(Schema);
bIsErrorFree &= Schema->TryCreateConnection(LastThenPin, IteratorInitialize->GetExecPin());
bIsErrorFree &= Schema->TryCreateConnection(IteratorVar->GetVariablePin(), IteratorInitialize->GetVariablePin());
bIsErrorFree &= Schema->TryCreateConnection(IteratorInitialize->GetThenPin(), Branch->GetExecPin());
bIsErrorFree &= Schema->TryCreateConnection(SpawnedActorReturnPin, ArrayLength->GetTargetArrayPin());
bIsErrorFree &= Schema->TryCreateConnection(Condition->GetReturnValuePin(), Branch->GetConditionPin());
bIsErrorFree &= Schema->TryCreateConnection(IteratorVar->GetVariablePin(), Condition->FindPinChecked(TEXT("A")));
bIsErrorFree &= Schema->TryCreateConnection(ArrayLength->FindPin(K2Schema->PN_ReturnValue), Condition->FindPinChecked(TEXT("B")));
//Connections to establish loop iteration
bIsErrorFree &= Schema->TryCreateConnection(IteratorVar->GetVariablePin(), Increment->FindPinChecked(TEXT("A")));
bIsErrorFree &= Schema->TryCreateConnection(IteratorVar->GetVariablePin(), IteratorAssign->GetVariablePin());
bIsErrorFree &= Schema->TryCreateConnection(Increment->GetReturnValuePin(), IteratorAssign->GetValuePin());
bIsErrorFree &= Schema->TryCreateConnection(IteratorAssign->GetThenPin(), Branch->GetExecPin());
//This is the inner loop
LastThenPin = Branch->GetThenPin(); //Connect the loop branch to the spawn-assignment code block
bIsErrorFree &= Schema->TryCreateConnection(SpawnedActorReturnPin, GetElement->GetTargetArrayPin());
bIsErrorFree &= Schema->TryCreateConnection(IteratorVar->GetVariablePin(), GetElement->FindPinChecked(K2Schema->PN_Index));
bIsErrorFree &= ConnectSpawnProperties(ClassToSpawn, Schema, CompilerContext, SourceGraph, LastThenPin, GetElement->FindPinChecked(K2Schema->PN_Item)); //Last argument is the array element
bIsErrorFree &= Schema->TryCreateConnection(LastThenPin, IteratorAssign->GetExecPin()); //Connect the spawn-assignment code block to the iterator increment
//Finish by providing the proper path out
LastThenPin = Branch->GetElsePin();
}
// -------------------------------------------
// Set spawn variables
// Borrowed heavily from FKismetCompilerUtilities::GenerateAssignmentNodes
// -------------------------------------------
if (validatedActorSpawn && ClassToSpawn)
{
bIsErrorFree &= ConnectSpawnProperties(ClassToSpawn, Schema, CompilerContext, SourceGraph, LastThenPin, SpawnedActorReturnPin);
}
// -------------------------------------------
// Call FinishSpawning
// -------------------------------------------
UK2Node_CallFunction* const CallPostSpawnnProxyObjectNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
CallPostSpawnnProxyObjectNode->FunctionReference.SetExternalMember(ProxyPostpawnFunctionName, ProxyClass);
CallPostSpawnnProxyObjectNode->AllocateDefaultPins();
// Hook up the self connection
UEdGraphPin* PostspawnCallSelfPin = Schema->FindSelfPin(*CallPostSpawnnProxyObjectNode, EGPD_Input);
check(PostspawnCallSelfPin);
bIsErrorFree &= Schema->TryCreateConnection(ProxyObjectPin, PostspawnCallSelfPin);
// Link our Postspawn call in
bIsErrorFree &= Schema->TryCreateConnection(LastThenPin, CallPostSpawnnProxyObjectNode->FindPinChecked(Schema->PN_Execute));
// Hook up any other input parameters to PostSpawn
for (auto CurrentPin : Pins)
{
if (FBaseAsyncTaskHelper::ValidDataPin(CurrentPin, EGPD_Input, Schema))
{
UEdGraphPin* DestPin = CallPostSpawnnProxyObjectNode->FindPin(CurrentPin->PinName);
if (DestPin)
{
bIsErrorFree &= CompilerContext.CopyPinLinksToIntermediate(*CurrentPin, *DestPin).CanSafeConnect();
}
}
}
UEdGraphPin* InSpawnedActorPin = CallPostSpawnnProxyObjectNode->FindPin(TEXT("SpawnedActor"));
if (InSpawnedActorPin == nullptr)
{
CompilerContext.MessageLog.Error(*LOCTEXT("MissingSpawnedActorInputPin", "AbilityTask: Proxy is missing SpawnedActor input pin in FinishSpawningActor. @@").ToString(), this);
return;
}
bIsErrorFree &= Schema->TryCreateConnection(SpawnedActorReturnPin, InSpawnedActorPin);
LastThenPin = CallPostSpawnnProxyObjectNode->FindPinChecked(Schema->PN_Then);
// Move the connections from the original node then pin to the last internal then pin
bIsErrorFree &= CompilerContext.MovePinLinksToIntermediate(*FindPinChecked(Schema->PN_Then), *LastThenPin).CanSafeConnect();
bIsErrorFree &= CompilerContext.CopyPinLinksToIntermediate(*LastThenPin, *BranchElsePin).CanSafeConnect();
if (!bIsErrorFree)
{
CompilerContext.MessageLog.Error(*LOCTEXT("InternalConnectionError", "BaseAsyncTask: Internal connection error. @@").ToString(), this);
}
// Make sure we caught everything
BreakAllNodeLinks();
}
void UK2Node_Message::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
UEdGraphPin* ExecPin = Schema->FindExecutionPin(*this, EGPD_Input);
const bool bExecPinConnected = ExecPin && (ExecPin->LinkedTo.Num() > 0);
UEdGraphPin* ThenPin = Schema->FindExecutionPin(*this, EGPD_Output);
const bool bThenPinConnected = ThenPin && (ThenPin->LinkedTo.Num() > 0);
// Skip ourselves if our exec isn't wired up
if (bExecPinConnected)
{
// Make sure our interface is valid
if (FunctionReference.GetMemberParentClass(this) == NULL)
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("MessageNodeInvalid_Error", "Message node @@ has an invalid interface.").ToString()), this);
return;
}
UFunction* MessageNodeFunction = GetTargetFunction();
if (MessageNodeFunction == NULL)
{
//@TODO: Why do this here in teh compiler, it's already done on AllocateDefaultPins() during on-load node reconstruction
MessageNodeFunction = Cast<UFunction>(UK2Node::FindRemappedField(FunctionReference.GetMemberParentClass(this), FunctionReference.GetMemberName()));
}
if (MessageNodeFunction == NULL)
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("MessageNodeInvalidFunction_Error", "Unable to find function with name %s for Message node @@.").ToString(), *(FunctionReference.GetMemberName().ToString())), this);
return;
}
// Check to make sure we have a target
UEdGraphPin* MessageSelfPin = Schema->FindSelfPin(*this, EGPD_Input);
if( !MessageSelfPin || MessageSelfPin->LinkedTo.Num() == 0 )
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("MessageNodeSelfPin_Error", "Message node @@ must have a valid target or reference to self.").ToString()), this);
return;
}
// First, create an internal cast-to-interface node
UK2Node_DynamicCast* CastToInterfaceNode = CompilerContext.SpawnIntermediateNode<UK2Node_DynamicCast>(this, SourceGraph);
CastToInterfaceNode->TargetType = MessageNodeFunction->GetOuterUClass();
CastToInterfaceNode->SetPurity(false);
CastToInterfaceNode->AllocateDefaultPins();
UEdGraphPin* CastToInterfaceResultPin = CastToInterfaceNode->GetCastResultPin();
if( !CastToInterfaceResultPin )
{
CompilerContext.MessageLog.Error(*LOCTEXT("InvalidInterfaceClass_Error", "Node @@ has an invalid target interface class").ToString(), this);
return;
}
CastToInterfaceResultPin->PinType.PinSubCategoryObject = *CastToInterfaceNode->TargetType;
if (ExecPin != nullptr)
{
UEdGraphPin* CastExecInput = CastToInterfaceNode->GetExecPin();
check(CastExecInput != nullptr);
// Wire up the connections
CompilerContext.MovePinLinksToIntermediate(*ExecPin, *CastExecInput);
}
UEdGraphPin* CastToInterfaceSourceObjectPin = CastToInterfaceNode->GetCastSourcePin();
CompilerContext.MovePinLinksToIntermediate(*MessageSelfPin, *CastToInterfaceSourceObjectPin);
// Next, create the function call node
UK2Node_CallFunction* FunctionCallNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
FunctionCallNode->bIsInterfaceCall = true;
FunctionCallNode->FunctionReference = FunctionReference;
FunctionCallNode->AllocateDefaultPins();
UEdGraphPin* CastToInterfaceValidPin = CastToInterfaceNode->GetValidCastPin();
check(CastToInterfaceValidPin != nullptr);
UEdGraphPin* LastOutCastFaildPin = CastToInterfaceNode->GetInvalidCastPin();
check(LastOutCastFaildPin != nullptr);
UEdGraphPin* LastOutCastSuccessPin = CastToInterfaceValidPin;
// Wire up the connections
if (UEdGraphPin* CallFunctionExecPin = Schema->FindExecutionPin(*FunctionCallNode, EGPD_Input))
{
CastToInterfaceValidPin->MakeLinkTo(CallFunctionExecPin);
LastOutCastSuccessPin = Schema->FindExecutionPin(*FunctionCallNode, EGPD_Output);
}
// Self pin
UEdGraphPin* FunctionCallSelfPin = Schema->FindSelfPin(*FunctionCallNode, EGPD_Input);
CastToInterfaceResultPin->MakeLinkTo(FunctionCallSelfPin);
UFunction* ArrayClearFunction = UKismetArrayLibrary::StaticClass()->FindFunctionByName(FName(TEXT("Array_Clear")));
check(ArrayClearFunction);
bool const bIsPureFunc = Super::IsNodePure();
// Variable pins - Try to associate variable inputs to the message node with the variable inputs and outputs to the call function node
for( int32 i = 0; i < Pins.Num(); i++ )
{
UEdGraphPin* CurrentPin = Pins[i];
if( CurrentPin && (CurrentPin->PinType.PinCategory != Schema->PC_Exec) && (CurrentPin->PinName != Schema->PN_Self) )
{
// Try to find a match for the pin on the function call node
UEdGraphPin* FunctionCallPin = FunctionCallNode->FindPin(CurrentPin->PinName);
if( FunctionCallPin )
{
// Move pin links if the pin is connected...
CompilerContext.MovePinLinksToIntermediate(*CurrentPin, *FunctionCallPin);
// when cast fails all return values must be cleared.
if (EEdGraphPinDirection::EGPD_Output == CurrentPin->Direction)
{
UEdGraphPin* VarOutPin = FunctionCallPin;
if (bIsPureFunc)
{
// since we cannot directly use the output from the
// function call node (since it is pure, and invoking
// it with a null target would cause an error), we
// have to use a temporary variable in it's place...
UK2Node_TemporaryVariable* TempVar = CompilerContext.SpawnIntermediateNode<UK2Node_TemporaryVariable>(this, SourceGraph);
TempVar->VariableType = CurrentPin->PinType;
TempVar->AllocateDefaultPins();
VarOutPin = TempVar->GetVariablePin();
// nodes using the function's outputs directly, now
// use this TempVar node instead
CompilerContext.MovePinLinksToIntermediate(*FunctionCallPin, *VarOutPin);
// on a successful cast, the temp var is filled with
// the function's value, on a failed cast, the var
// is filled with a default value (DefaultValueNode,
// below)... this is the node for the success case:
UK2Node_AssignmentStatement* AssignTempVar = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(this, SourceGraph);
AssignTempVar->AllocateDefaultPins();
// assign the output from the pure function node to
// the TempVar (either way, this message node is
// returning the TempVar's value, so on a successful
// cast we want it to have the function's result)
UEdGraphPin* ValueInPin = AssignTempVar->GetValuePin();
Schema->TryCreateConnection(FunctionCallPin, ValueInPin);
AssignTempVar->PinConnectionListChanged(ValueInPin);
UEdGraphPin* VarInPin = AssignTempVar->GetVariablePin();
Schema->TryCreateConnection(VarOutPin, VarInPin);
AssignTempVar->PinConnectionListChanged(VarInPin);
// fold this AssignTempVar node into the cast's
// success execution chain
Schema->TryCreateConnection(AssignTempVar->GetExecPin(), LastOutCastSuccessPin);
LastOutCastSuccessPin = AssignTempVar->GetThenPin();
}
UK2Node* DefaultValueNode = NULL;
UEdGraphPin* DefaultValueThenPin = NULL;
if (CurrentPin->PinType.bIsArray)
{
UK2Node_CallArrayFunction* ClearArray = CompilerContext.SpawnIntermediateNode<UK2Node_CallArrayFunction>(this, SourceGraph);
DefaultValueNode = ClearArray;
ClearArray->SetFromFunction(ArrayClearFunction);
ClearArray->AllocateDefaultPins();
UEdGraphPin* ArrayPin = ClearArray->GetTargetArrayPin();
check(ArrayPin);
Schema->TryCreateConnection(ArrayPin, VarOutPin);
ClearArray->PinConnectionListChanged(ArrayPin);
DefaultValueThenPin = ClearArray->GetThenPin();
}
else
{
UK2Node_AssignmentStatement* AssignDefaultValue = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(this, SourceGraph);
DefaultValueNode = AssignDefaultValue;
AssignDefaultValue->AllocateDefaultPins();
Schema->TryCreateConnection(AssignDefaultValue->GetVariablePin(), VarOutPin);
AssignDefaultValue->PinConnectionListChanged(AssignDefaultValue->GetVariablePin());
Schema->SetPinDefaultValueBasedOnType(AssignDefaultValue->GetValuePin());
DefaultValueThenPin = AssignDefaultValue->GetThenPin();
}
UEdGraphPin* DefaultValueExecPin = DefaultValueNode->GetExecPin();
check(DefaultValueExecPin);
Schema->TryCreateConnection(DefaultValueExecPin, LastOutCastFaildPin);
LastOutCastFaildPin = DefaultValueThenPin;
check(LastOutCastFaildPin);
}
}
else
{
UE_LOG(LogK2Compiler, Log, TEXT("%s"), *LOCTEXT("NoPinConnectionFound_Error", "Unable to find connection for pin! Check AllocateDefaultPins() for consistency!").ToString());
}
}
}
if( bThenPinConnected )
{
check(LastOutCastFaildPin != nullptr);
// Failure case for the cast runs straight through to the exit
CompilerContext.CopyPinLinksToIntermediate(*ThenPin, *LastOutCastFaildPin);
check(LastOutCastSuccessPin != nullptr);
// Copy all links from the invalid cast case above to the call function node
CompilerContext.MovePinLinksToIntermediate(*ThenPin, *LastOutCastSuccessPin);
}
}
// Break all connections to the original node, so it will be pruned
BreakAllNodeLinks();
}
bool BuildLoop(UK2Node* Node, FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
check(Node && SourceGraph && Schema);
bool bResult = true;
// Create int Loop Counter
UK2Node_TemporaryVariable* LoopCounterNode = CompilerContext.SpawnIntermediateNode<UK2Node_TemporaryVariable>(Node, SourceGraph);
LoopCounterNode->VariableType.PinCategory = Schema->PC_Int;
LoopCounterNode->AllocateDefaultPins();
LoopCounterOutPin = LoopCounterNode->GetVariablePin();
check(LoopCounterOutPin);
// Initialize loop counter
UK2Node_AssignmentStatement* LoopCounterInitialize = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(Node, SourceGraph);
LoopCounterInitialize->AllocateDefaultPins();
LoopCounterInitialize->GetValuePin()->DefaultValue = TEXT("0");
bResult &= Schema->TryCreateConnection(LoopCounterOutPin, LoopCounterInitialize->GetVariablePin());
StartLoopExecInPin = LoopCounterInitialize->GetExecPin();
check(StartLoopExecInPin);
// Create int Array Index
UK2Node_TemporaryVariable* ArrayIndexNode = CompilerContext.SpawnIntermediateNode<UK2Node_TemporaryVariable>(Node, SourceGraph);
ArrayIndexNode->VariableType.PinCategory = Schema->PC_Int;
ArrayIndexNode->AllocateDefaultPins();
ArrayIndexOutPin = ArrayIndexNode->GetVariablePin();
check(ArrayIndexOutPin);
// Initialize array index
UK2Node_AssignmentStatement* ArrayIndexInitialize = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(Node, SourceGraph);
ArrayIndexInitialize->AllocateDefaultPins();
ArrayIndexInitialize->GetValuePin()->DefaultValue = TEXT("0");
bResult &= Schema->TryCreateConnection(ArrayIndexOutPin, ArrayIndexInitialize->GetVariablePin());
bResult &= Schema->TryCreateConnection(LoopCounterInitialize->GetThenPin(), ArrayIndexInitialize->GetExecPin());
// Do loop branch
UK2Node_IfThenElse* Branch = CompilerContext.SpawnIntermediateNode<UK2Node_IfThenElse>(Node, SourceGraph);
Branch->AllocateDefaultPins();
bResult &= Schema->TryCreateConnection(ArrayIndexInitialize->GetThenPin(), Branch->GetExecPin());
LoopCompleteOutExecPin = Branch->GetElsePin();
check(LoopCompleteOutExecPin);
// Do loop condition
UK2Node_CallFunction* Condition = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(Node, SourceGraph);
Condition->SetFromFunction(UKismetMathLibrary::StaticClass()->FindFunctionByName(TEXT("Less_IntInt")));
Condition->AllocateDefaultPins();
bResult &= Schema->TryCreateConnection(Condition->GetReturnValuePin(), Branch->GetConditionPin());
bResult &= Schema->TryCreateConnection(Condition->FindPinChecked(TEXT("A")), LoopCounterOutPin);
LoopCounterLimitInPin = Condition->FindPinChecked(TEXT("B"));
check(LoopCounterLimitInPin);
// Array Index assigned
UK2Node_AssignmentStatement* ArrayIndexAssign = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(Node, SourceGraph);
ArrayIndexAssign->AllocateDefaultPins();
bResult &= Schema->TryCreateConnection(Branch->GetThenPin(), ArrayIndexAssign->GetExecPin());
bResult &= Schema->TryCreateConnection(ArrayIndexAssign->GetVariablePin(), ArrayIndexOutPin);
bResult &= Schema->TryCreateConnection(ArrayIndexAssign->GetValuePin(), LoopCounterOutPin);
// body sequence
UK2Node_ExecutionSequence* Sequence = CompilerContext.SpawnIntermediateNode<UK2Node_ExecutionSequence>(Node, SourceGraph);
Sequence->AllocateDefaultPins();
bResult &= Schema->TryCreateConnection(ArrayIndexAssign->GetThenPin(), Sequence->GetExecPin());
InsideLoopExecOutPin = Sequence->GetThenPinGivenIndex(0);
check(InsideLoopExecOutPin);
// Loop Counter increment
UK2Node_CallFunction* Increment = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(Node, SourceGraph);
Increment->SetFromFunction(UKismetMathLibrary::StaticClass()->FindFunctionByName(TEXT("Add_IntInt")));
Increment->AllocateDefaultPins();
bResult &= Schema->TryCreateConnection(Increment->FindPinChecked(TEXT("A")), LoopCounterOutPin);
Increment->FindPinChecked(TEXT("B"))->DefaultValue = TEXT("1");
// Loop Counter assigned
UK2Node_AssignmentStatement* LoopCounterAssign = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(Node, SourceGraph);
LoopCounterAssign->AllocateDefaultPins();
bResult &= Schema->TryCreateConnection(LoopCounterAssign->GetExecPin(), Sequence->GetThenPinGivenIndex(1));
bResult &= Schema->TryCreateConnection(LoopCounterAssign->GetVariablePin(), LoopCounterOutPin);
bResult &= Schema->TryCreateConnection(LoopCounterAssign->GetValuePin(), Increment->GetReturnValuePin());
bResult &= Schema->TryCreateConnection(LoopCounterAssign->GetThenPin(), Branch->GetExecPin());
return bResult;
}
void UK2Node_InputAction::ExpandNode(FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
UEdGraphPin* InputActionPressedPin = GetPressedPin();
UEdGraphPin* InputActionReleasedPin = GetReleasedPin();
struct EventPinData
{
EventPinData(UEdGraphPin* InPin,TEnumAsByte<EInputEvent> InEvent ){ Pin=InPin;EventType=InEvent;};
UEdGraphPin* Pin;
TEnumAsByte<EInputEvent> EventType;
};
TArray<EventPinData> ActivePins;
if(( InputActionPressedPin != nullptr ) && (InputActionPressedPin->LinkedTo.Num() > 0 ))
{
ActivePins.Add(EventPinData(InputActionPressedPin,IE_Pressed));
}
if((InputActionReleasedPin != nullptr) && (InputActionReleasedPin->LinkedTo.Num() > 0 ))
{
ActivePins.Add(EventPinData(InputActionReleasedPin,IE_Released));
}
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
// If more than one is linked we have to do more complicated behaviors
if( ActivePins.Num() > 1 )
{
// Create a temporary variable to copy Key in to
static UScriptStruct* KeyStruct = FKey::StaticStruct();
UK2Node_TemporaryVariable* ActionKeyVar = CompilerContext.SpawnIntermediateNode<UK2Node_TemporaryVariable>(this, SourceGraph);
ActionKeyVar->VariableType.PinCategory = Schema->PC_Struct;
ActionKeyVar->VariableType.PinSubCategoryObject = KeyStruct;
ActionKeyVar->AllocateDefaultPins();
for (auto PinIt = ActivePins.CreateIterator(); PinIt; ++PinIt)
{
UEdGraphPin *EachPin = (*PinIt).Pin;
// Create the input touch event
UK2Node_InputActionEvent* InputActionEvent = CompilerContext.SpawnIntermediateNode<UK2Node_InputActionEvent>(this, SourceGraph);
InputActionEvent->CustomFunctionName = FName( *FString::Printf(TEXT("InpActEvt_%s_%s"), *InputActionName.ToString(), *InputActionEvent->GetName()));
InputActionEvent->InputActionName = InputActionName;
InputActionEvent->bConsumeInput = bConsumeInput;
InputActionEvent->bExecuteWhenPaused = bExecuteWhenPaused;
InputActionEvent->bOverrideParentBinding = bOverrideParentBinding;
InputActionEvent->InputKeyEvent = (*PinIt).EventType;
InputActionEvent->EventReference.SetExternalDelegateMember(FName(TEXT("InputActionHandlerDynamicSignature__DelegateSignature")));
InputActionEvent->bInternalEvent = true;
InputActionEvent->AllocateDefaultPins();
// Create assignment nodes to assign the key
UK2Node_AssignmentStatement* ActionKeyInitialize = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(this, SourceGraph);
ActionKeyInitialize->AllocateDefaultPins();
Schema->TryCreateConnection(ActionKeyVar->GetVariablePin(), ActionKeyInitialize->GetVariablePin());
Schema->TryCreateConnection(ActionKeyInitialize->GetValuePin(), InputActionEvent->FindPinChecked(TEXT("Key")));
// Connect the events to the assign key nodes
Schema->TryCreateConnection(Schema->FindExecutionPin(*InputActionEvent, EGPD_Output), ActionKeyInitialize->GetExecPin());
// Move the original event connections to the then pin of the key assign
CompilerContext.MovePinLinksToIntermediate(*EachPin, *ActionKeyInitialize->GetThenPin());
// Move the original event variable connections to the intermediate nodes
CompilerContext.MovePinLinksToIntermediate(*FindPin(TEXT("Key")), *ActionKeyVar->GetVariablePin());
}
}
else if( ActivePins.Num() == 1 )
{
UEdGraphPin* InputActionPin = ActivePins[0].Pin;
EInputEvent InputEvent = ActivePins[0].EventType;
if (InputActionPin->LinkedTo.Num() > 0)
{
UK2Node_InputActionEvent* InputActionEvent = CompilerContext.SpawnIntermediateNode<UK2Node_InputActionEvent>(this, SourceGraph);
InputActionEvent->CustomFunctionName = FName( *FString::Printf(TEXT("InpActEvt_%s_%s"), *InputActionName.ToString(), *InputActionEvent->GetName()));
InputActionEvent->InputActionName = InputActionName;
InputActionEvent->bConsumeInput = bConsumeInput;
InputActionEvent->bExecuteWhenPaused = bExecuteWhenPaused;
InputActionEvent->bOverrideParentBinding = bOverrideParentBinding;
InputActionEvent->InputKeyEvent = InputEvent;
InputActionEvent->EventReference.SetExternalDelegateMember(FName(TEXT("InputActionHandlerDynamicSignature__DelegateSignature")));
InputActionEvent->bInternalEvent = true;
InputActionEvent->AllocateDefaultPins();
CompilerContext.MovePinLinksToIntermediate(*InputActionPin, *Schema->FindExecutionPin(*InputActionEvent, EGPD_Output));
CompilerContext.MovePinLinksToIntermediate(*FindPin(TEXT("Key")), *InputActionEvent->FindPin(TEXT("Key")));
}
}
}
void UK2Node_LoadAsset::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
check(Schema);
bool bIsErrorFree = true;
// Create LoadAsset function call
auto CallLoadAssetNode = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
CallLoadAssetNode->FunctionReference.SetExternalMember(NativeFunctionName(), UKismetSystemLibrary::StaticClass());
CallLoadAssetNode->AllocateDefaultPins();
// connect to input exe
{
auto InputExePin = GetExecPin();
auto CallFunctionInputExePin = CallLoadAssetNode->GetExecPin();
bIsErrorFree &= InputExePin && CallFunctionInputExePin && CompilerContext.MovePinLinksToIntermediate(*InputExePin, *CallFunctionInputExePin).CanSafeConnect();
}
// Create Local Variable
UK2Node_TemporaryVariable* TempVarOutput = CompilerContext.SpawnInternalVariable(this, GetOutputCategory(), FString(), UObject::StaticClass(), false);
// Create assign node
auto AssignNode = CompilerContext.SpawnIntermediateNode<UK2Node_AssignmentStatement>(this, SourceGraph);
AssignNode->AllocateDefaultPins();
auto LoadedObjectVariablePin = TempVarOutput->GetVariablePin();
// connect local variable to assign node
{
auto AssignLHSPPin = AssignNode->GetVariablePin();
bIsErrorFree &= AssignLHSPPin && LoadedObjectVariablePin && Schema->TryCreateConnection(AssignLHSPPin, LoadedObjectVariablePin);
}
// connect local variable to output
{
auto OutputObjectPinPin = FindPin(GetOutputPinName());
bIsErrorFree &= LoadedObjectVariablePin && OutputObjectPinPin && CompilerContext.MovePinLinksToIntermediate(*OutputObjectPinPin, *LoadedObjectVariablePin).CanSafeConnect();
}
// connect assign exec input to function output
{
auto CallFunctionOutputExePin = CallLoadAssetNode->FindPin(Schema->PN_Then);
auto AssignInputExePin = AssignNode->GetExecPin();
bIsErrorFree &= AssignInputExePin && CallFunctionOutputExePin && Schema->TryCreateConnection(AssignInputExePin, CallFunctionOutputExePin);
}
// connect assign exec output to output
{
auto OutputExePin = FindPin(Schema->PN_Then);
auto AssignOutputExePin = AssignNode->GetThenPin();
bIsErrorFree &= OutputExePin && AssignOutputExePin && CompilerContext.MovePinLinksToIntermediate(*OutputExePin, *AssignOutputExePin).CanSafeConnect();
}
// connect to asset
{
auto AssetPin = FindPin(GetInputPinName());
auto CallFunctionAssetPin = CallLoadAssetNode->FindPin(GetInputPinName());
ensure(CallFunctionAssetPin);
bIsErrorFree &= AssetPin && CallFunctionAssetPin && CompilerContext.MovePinLinksToIntermediate(*AssetPin, *CallFunctionAssetPin).CanSafeConnect();
}
// Create OnLoadEvent
const FString DelegateOnLoadedParamName(TEXT("OnLoaded"));
auto OnLoadEventNode = CompilerContext.SpawnIntermediateNode<UK2Node_CustomEvent>(this, SourceGraph);
OnLoadEventNode->CustomFunctionName = *FString::Printf(TEXT("OnLoaded_%s"), *OnLoadEventNode->NodeGuid.ToString());
OnLoadEventNode->AllocateDefaultPins();
{
UFunction* LoadAssetFunction = CallLoadAssetNode->GetTargetFunction();
UDelegateProperty* OnLoadDelegateProperty = LoadAssetFunction ? FindField<UDelegateProperty>(LoadAssetFunction, *DelegateOnLoadedParamName) : nullptr;
UFunction* OnLoadedSignature = OnLoadDelegateProperty ? OnLoadDelegateProperty->SignatureFunction : nullptr;
ensure(OnLoadedSignature);
for (TFieldIterator<UProperty> PropIt(OnLoadedSignature); PropIt && (PropIt->PropertyFlags & CPF_Parm); ++PropIt)
{
const UProperty* Param = *PropIt;
if (!Param->HasAnyPropertyFlags(CPF_OutParm) || Param->HasAnyPropertyFlags(CPF_ReferenceParm))
{
FEdGraphPinType PinType;
bIsErrorFree &= Schema->ConvertPropertyToPinType(Param, /*out*/ PinType);
bIsErrorFree &= (NULL != OnLoadEventNode->CreateUserDefinedPin(Param->GetName(), PinType, EGPD_Output));
}
}
}
// connect delegate
{
auto CallFunctionDelegatePin = CallLoadAssetNode->FindPin(DelegateOnLoadedParamName);
ensure(CallFunctionDelegatePin);
auto EventDelegatePin = OnLoadEventNode->FindPin(UK2Node_CustomEvent::DelegateOutputName);
bIsErrorFree &= CallFunctionDelegatePin && EventDelegatePin && Schema->TryCreateConnection(CallFunctionDelegatePin, EventDelegatePin);
}
// connect loaded object from event to assign
{
auto LoadedAssetEventPin = OnLoadEventNode->FindPin(TEXT("Loaded"));
ensure(LoadedAssetEventPin);
auto AssignRHSPPin = AssignNode->GetValuePin();
bIsErrorFree &= AssignRHSPPin && LoadedAssetEventPin && Schema->TryCreateConnection(LoadedAssetEventPin, AssignRHSPPin);
}
if (!bIsErrorFree)
{
CompilerContext.MessageLog.Error(*LOCTEXT("InternalConnectionError", "K2Node_LoadAsset: Internal connection error. @@").ToString(), this);
}
BreakAllNodeLinks();
}
