void FKCHandler_VariableSet::Compile(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
// SubCategory is an object type or "" for the stack frame, default scope is Self
// Each input pin is the name of a variable
// Each input pin represents an assignment statement
for (int32 PinIndex = 0; PinIndex < Node->Pins.Num(); ++PinIndex)
{
UEdGraphPin* Pin = Node->Pins[PinIndex];
if (CompilerContext.GetSchema()->IsMetaPin(*Pin))
{
}
else if (Pin->Direction == EGPD_Input)
{
InnerAssignment(Context, Node, Pin, Pin);
}
else
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("ExpectedOnlyInputPins_Error", "Expected only input pins on @@ but found @@").ToString()), Node, Pin);
}
}
// Generate the output impulse from this node
GenerateSimpleThenGoto(Context, *Node);
}
virtual void Compile(FKismetFunctionContext& Context, UEdGraphNode* Node) override
{
UK2Node_FunctionEntry* EntryNode = CastChecked<UK2Node_FunctionEntry>(Node);
//check(EntryNode->SignatureName != NAME_None);
if (EntryNode->SignatureName == CompilerContext.GetSchema()->FN_ExecuteUbergraphBase)
{
UEdGraphPin* EntryPointPin = Node->FindPin(CompilerContext.GetSchema()->PN_EntryPoint);
FBPTerminal** pTerm = Context.NetMap.Find(EntryPointPin);
if ((EntryPointPin != NULL) && (pTerm != NULL))
{
FBlueprintCompiledStatement& ComputedGotoStatement = Context.AppendStatementForNode(Node);
ComputedGotoStatement.Type = KCST_ComputedGoto;
ComputedGotoStatement.LHS = *pTerm;
}
else
{
CompilerContext.MessageLog.Error(*LOCTEXT("NoEntryPointPin_Error", "Expected a pin named EntryPoint on @@").ToString(), Node);
}
}
else
{
// Generate the output impulse from this node
GenerateSimpleThenGoto(Context, *Node);
}
}
void FKCHandler_ClearDelegate::Compile(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
UK2Node_BaseMCDelegate* DelegateNode = CastChecked<UK2Node_BaseMCDelegate>(Node);
UEdGraphPin* SelfPin = CompilerContext.GetSchema()->FindSelfPin(*DelegateNode, EEdGraphPinDirection::EGPD_Input);
check(SelfPin);
TArray<UEdGraphPin*> Links = SelfPin->LinkedTo;
if(!Links.Num())
{
Links.Add(SelfPin);
}
for (auto NetIt = Links.CreateIterator(); NetIt; ++NetIt)
{
UEdGraphPin* NetPin = *NetIt;
check(NetPin);
FBlueprintCompiledStatement& AddStatement = Context.AppendStatementForNode(DelegateNode);
AddStatement.Type = KCST_ClearMulticastDelegate;
FBPTerminal** VarDelegate = InnerTermMap.Find(FDelegateOwnerId(NetPin, DelegateNode));
check(VarDelegate && *VarDelegate);
AddStatement.LHS = *VarDelegate;
}
GenerateSimpleThenGoto(Context, *DelegateNode, DelegateNode->FindPin(CompilerContext.GetSchema()->PN_Then));
FNodeHandlingFunctor::Compile(Context, DelegateNode);
}
void FKCHandler_VariableSet::Compile(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
GenerateAssigments(Context, Node);
// Generate the output impulse from this node
GenerateSimpleThenGoto(Context, *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);
}
virtual void Compile(FKismetFunctionContext& Context, UEdGraphNode* Node) override
{
const UK2Node_DelegateSet* DelegateNode = Cast<UK2Node_DelegateSet>(Node);
check(DelegateNode);
// Verify that the event has a darget to be bound to
UEdGraphPin* DelegateOwnerPin = DelegateNode->GetDelegateOwner();
if (DelegateOwnerPin == nullptr || DelegateOwnerPin->LinkedTo.Num() == 0)
{
CompilerContext.MessageLog.Error(*FString(*LOCTEXT("FindDynamicallyBoundDelegate_Error", "Couldn't find target for dynamically bound delegate node @@").ToString()), DelegateNode);
return;
}
FBPTerminal** pDelegateOwnerTerm = Context.NetMap.Find(DelegateOwnerPin);
// Create a delegate name term
FBPTerminal* DelegateNameTerm = Context.CreateLocalTerminal(ETerminalSpecification::TS_Literal);
DelegateNameTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Name;
DelegateNameTerm->Name = DelegateNode->GetDelegateTargetEntryPointName().ToString();
DelegateNameTerm->bIsLiteral = true;
// Create a local delegate, which we can then add to the multicast delegate
FBPTerminal* LocalDelegate = *LocalDelegateMap.Find(Node);
FBlueprintCompiledStatement& Statement = Context.AppendStatementForNode(Node);
Statement.Type = KCST_Assignment;
Statement.LHS = LocalDelegate;
Statement.RHS.Add(DelegateNameTerm);
// Add the local delegate to the MC delegate
FBlueprintCompiledStatement& AddStatement = Context.AppendStatementForNode(Node);
AddStatement.Type = KCST_AddMulticastDelegate;
AddStatement.LHS = *pDelegateOwnerTerm;
AddStatement.RHS.Add(LocalDelegate);
GenerateSimpleThenGoto(Context, *Node, DelegateNode->FindPin(CompilerContext.GetSchema()->PN_Then));
FNodeHandlingFunctor::Compile(Context, Node);
}
virtual void Compile(FKismetFunctionContext& Context, UEdGraphNode* Node) override
{
UK2Node_Switch* SwitchNode = CastChecked<UK2Node_Switch>(Node);
FEdGraphPinType ExpectedExecPinType;
ExpectedExecPinType.PinCategory = UEdGraphSchema_K2::PC_Exec;
// Make sure that the input pin is connected and valid for this block
UEdGraphPin* ExecTriggeringPin = Context.FindRequiredPinByName(SwitchNode, UEdGraphSchema_K2::PN_Execute, EGPD_Input);
if ((ExecTriggeringPin == NULL) || !Context.ValidatePinType(ExecTriggeringPin, ExpectedExecPinType))
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("NoValidExecutionPinForSwitch_Error", "@@ must have a valid execution pin @@").ToString()), SwitchNode, ExecTriggeringPin);
return;
}
// Make sure that the selection pin is connected and valid for this block
UEdGraphPin* SelectionPin = SwitchNode->GetSelectionPin();
if ((SelectionPin == NULL) || !Context.ValidatePinType(SelectionPin, SwitchNode->GetPinType()))
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("NoValidSelectionPinForSwitch_Error", "@@ must have a valid execution pin @@").ToString()), SwitchNode, SelectionPin);
return;
}
// Find the boolean intermediate result term, so we can track whether the compare was successful
FBPTerminal* BoolTerm = BoolTermMap.FindRef(SwitchNode);
// Generate the output impulse from this node
UEdGraphPin* SwitchSelectionNet = FEdGraphUtilities::GetNetFromPin(SelectionPin);
FBPTerminal* SwitchSelectionTerm = Context.NetMap.FindRef(SwitchSelectionNet);
if ((BoolTerm != NULL) && (SwitchSelectionTerm != NULL))
{
UEdGraphNode* TargetNode = NULL;
UEdGraphPin* FuncPin = SwitchNode->GetFunctionPin();
FBPTerminal* FuncContext = Context.NetMap.FindRef(FuncPin);
UEdGraphPin* DefaultPin = SwitchNode->GetDefaultPin();
// Pull out function to use
UClass* FuncClass = Cast<UClass>(FuncPin->PinType.PinSubCategoryObject.Get());
UFunction* FunctionPtr = FindField<UFunction>(FuncClass, *FuncPin->PinName);
check(FunctionPtr);
// Run thru all the output pins except for the default label
for (auto PinIt = SwitchNode->Pins.CreateIterator(); PinIt; ++PinIt)
{
UEdGraphPin* Pin = *PinIt;
if ((Pin->Direction == EGPD_Output) && (Pin != DefaultPin))
{
// Create a term for the switch case value
FBPTerminal* CaseValueTerm = new (Context.Literals) FBPTerminal();
CaseValueTerm->Name = Pin->PinName;
CaseValueTerm->Type = SelectionPin->PinType;
CaseValueTerm->SourcePin = Pin;
CaseValueTerm->bIsLiteral = true;
// Call the comparison function associated with this switch node
FBlueprintCompiledStatement& Statement = Context.AppendStatementForNode(SwitchNode);
Statement.Type = KCST_CallFunction;
Statement.FunctionToCall = FunctionPtr;
Statement.FunctionContext = FuncContext;
Statement.bIsParentContext = false;
Statement.LHS = BoolTerm;
Statement.RHS.Add(SwitchSelectionTerm);
Statement.RHS.Add(CaseValueTerm);
// Jump to output if strings are actually equal
FBlueprintCompiledStatement& IfFailTest_SucceedAtBeingEqualGoto = Context.AppendStatementForNode(SwitchNode);
IfFailTest_SucceedAtBeingEqualGoto.Type = KCST_GotoIfNot;
IfFailTest_SucceedAtBeingEqualGoto.LHS = BoolTerm;
Context.GotoFixupRequestMap.Add(&IfFailTest_SucceedAtBeingEqualGoto, Pin);
}
}
// Finally output default pin
GenerateSimpleThenGoto(Context, *SwitchNode, DefaultPin);
}
else
{
CompilerContext.MessageLog.Error(*LOCTEXT("ResolveTermPassed_Error", "Failed to resolve term passed into @@").ToString(), SelectionPin);
}
}
FBlueprintCompiledStatement& FNodeHandlingFunctor::GenerateSimpleThenGoto(FKismetFunctionContext& Context, UEdGraphNode& Node)
{
UEdGraphPin* ThenExecPin = CompilerContext.GetSchema()->FindExecutionPin(Node, EGPD_Output);
return GenerateSimpleThenGoto(Context, Node, ThenExecPin);
}
virtual void Compile(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
/////////////////////////////////////////////////////////////////////////////////////
// Get the node, retrieve the helper functions, and create a local "Index" variable
/////////////////////////////////////////////////////////////////////////////////////
// Get the multi gate node and the helper functions
UK2Node_MultiGate* GateNode = Cast<UK2Node_MultiGate>(Node);
// Get function names and class pointers to helper nodes
FName MarkBitFunctionName = "";
UClass* MarkBitFunctionClass = NULL;
GateNode->GetMarkBitFunction(MarkBitFunctionName, &MarkBitFunctionClass);
UFunction* MarkBitFunction = FindField<UFunction>(MarkBitFunctionClass, MarkBitFunctionName);
FName HasUnmarkedBitFunctionName = "";
UClass* HasUnmarkedBitFunctionClass = NULL;
GateNode->GetHasUnmarkedBitFunction(HasUnmarkedBitFunctionName, &HasUnmarkedBitFunctionClass);
UFunction* HasUnmarkedBitFunction = FindField<UFunction>(HasUnmarkedBitFunctionClass, HasUnmarkedBitFunctionName);
FName GetUnmarkedBitFunctionName = "";
UClass* GetUnmarkedBitFunctionClass = NULL;
GateNode->GetUnmarkedBitFunction(GetUnmarkedBitFunctionName, &GetUnmarkedBitFunctionClass);
UFunction* GetUnmarkedBitFunction = FindField<UFunction>(GetUnmarkedBitFunctionClass, GetUnmarkedBitFunctionName);
FName ConditionalFunctionName = "";
UClass* ConditionalFunctionClass = NULL;
GateNode->GetConditionalFunction(ConditionalFunctionName, &ConditionalFunctionClass);
UFunction* ConditionFunction = FindField<UFunction>(ConditionalFunctionClass, ConditionalFunctionName);
FName EqualityFunctionName = "";
UClass* EqualityFunctionClass = NULL;
GateNode->GetEqualityFunction(EqualityFunctionName, &EqualityFunctionClass);
UFunction* EqualityFunction = FindField<UFunction>(EqualityFunctionClass, EqualityFunctionName);
FName BoolNotEqualFunctionName = "";
UClass* BoolNotEqualFunctionClass = NULL;
GateNode->GetBoolNotEqualFunction(BoolNotEqualFunctionName, &BoolNotEqualFunctionClass);
UFunction* BoolNotEqualFunction = FindField<UFunction>(BoolNotEqualFunctionClass, BoolNotEqualFunctionName);
FName PrintStringFunctionName = "";
UClass* PrintStringFunctionClass = NULL;
GateNode->GetPrintStringFunction(PrintStringFunctionName, &PrintStringFunctionClass);
UFunction* PrintFunction = FindField<UFunction>(PrintStringFunctionClass, PrintStringFunctionName);
FName ClearBitsFunctionName = "";
UClass* ClearBitsFunctionClass = NULL;
GateNode->GetClearAllBitsFunction(ClearBitsFunctionName, &ClearBitsFunctionClass);
UFunction* ClearBitsFunction = FindField<UFunction>(ClearBitsFunctionClass, ClearBitsFunctionName);
// Find the data terms if there is already a data node from expansion phase
FBPTerminal* DataTerm = NULL;
if (GateNode->DataNode)
{
UEdGraphPin* PinToTry = FEdGraphUtilities::GetNetFromPin(GateNode->DataNode->GetVariablePin());
FBPTerminal** DataTermPtr = Context.NetMap.Find(PinToTry);
DataTerm = (DataTermPtr != NULL) ? *DataTermPtr : NULL;
}
// Else we built it in the net registration, so find it
else
{
DataTerm = DataTermMap.FindRef(GateNode);
}
check(DataTerm);
// Used for getting all the nets from pins
UEdGraphPin* PinToTry = NULL;
// The StartIndex passed into the multi gate node
PinToTry = FEdGraphUtilities::GetNetFromPin(GateNode->GetStartIndexPin());
FBPTerminal** StartIndexPinTerm = Context.NetMap.Find(PinToTry);
// Get the bRandom pin as a kismet term from the multi gate node
PinToTry = FEdGraphUtilities::GetNetFromPin(GateNode->GetIsRandomPin());
FBPTerminal** RandomTerm = Context.NetMap.Find(PinToTry);
// Get the Loop pin as a kismet term from the multi gate node
PinToTry = FEdGraphUtilities::GetNetFromPin(GateNode->GetLoopPin());
FBPTerminal** LoopTerm = Context.NetMap.Find(PinToTry);
// Find the local boolean for use in determining if this is the first run of the node or not
FBPTerminal* FirstRunBoolTerm = FirstRunTermMap.FindRef(GateNode);
// Create a literal pin that represents a -1 value
FBPTerminal* InvalidIndexTerm = Context.CreateLocalTerminal(ETerminalSpecification::TS_Literal);
InvalidIndexTerm->bIsLiteral = true;
InvalidIndexTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Int;
InvalidIndexTerm->Name = TEXT("-1");
// Create a literal pin that represents a true value
FBPTerminal* TrueBoolTerm = Context.CreateLocalTerminal(ETerminalSpecification::TS_Literal);
TrueBoolTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Boolean;
TrueBoolTerm->bIsLiteral = true;
TrueBoolTerm->Name = TEXT("true");
// Get the out pins and create a literal describing how many logical outs there are
TArray<UEdGraphPin*> OutPins;
GateNode->GetOutPins(OutPins);
FBPTerminal* NumOutsTerm = Context.CreateLocalTerminal(ETerminalSpecification::TS_Literal);
NumOutsTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Int;
NumOutsTerm->bIsLiteral = true;
NumOutsTerm->Name = FString::Printf(TEXT("%d"), OutPins.Num());
///////////////////////////////////////////////////
// See if this is the first time in
///////////////////////////////////////////////////
FFunctionScopedTerms& FuncLocals = FunctionTermMap.FindChecked(Context.Function);
check(FuncLocals.GenericBoolTerm != nullptr);
// (bIsNotFirstTime != true)
FBlueprintCompiledStatement& BoolNotEqualStatement = Context.AppendStatementForNode(Node);
BoolNotEqualStatement.Type = KCST_CallFunction;
BoolNotEqualStatement.FunctionToCall = BoolNotEqualFunction;
BoolNotEqualStatement.FunctionContext = NULL;
BoolNotEqualStatement.bIsParentContext = false;
// Set the params
BoolNotEqualStatement.LHS = FuncLocals.GenericBoolTerm;
BoolNotEqualStatement.RHS.Add(FirstRunBoolTerm);
BoolNotEqualStatement.RHS.Add(TrueBoolTerm);
// if (bIsNotFirstTime == false)
// {
FBlueprintCompiledStatement& IfFirstTimeStatement = Context.AppendStatementForNode(Node);
IfFirstTimeStatement.Type = KCST_GotoIfNot;
IfFirstTimeStatement.LHS = FuncLocals.GenericBoolTerm;
///////////////////////////////////////////////////////////////////
// This is the first time in... set the bool and the start index
///////////////////////////////////////////////////////////////////
// bIsNotFirstTime = true;
FBlueprintCompiledStatement& AssignBoolStatement = Context.AppendStatementForNode(Node);
AssignBoolStatement.Type = KCST_Assignment;
AssignBoolStatement.LHS = FirstRunBoolTerm;
AssignBoolStatement.RHS.Add(TrueBoolTerm);
//////////////////////////////////////////////////////////////////////
// See if the StartIndex is greater than -1 (they supplied an index)
//////////////////////////////////////////////////////////////////////
// (StartIndex > -1)
FBlueprintCompiledStatement& Statement = Context.AppendStatementForNode(Node);
Statement.Type = KCST_CallFunction;
Statement.FunctionToCall = ConditionFunction;
Statement.FunctionContext = NULL;
Statement.bIsParentContext = false;
Statement.LHS = FuncLocals.GenericBoolTerm;
Statement.RHS.Add(*StartIndexPinTerm);
Statement.RHS.Add(InvalidIndexTerm);
// if (StartIndex > -1)
// {
FBlueprintCompiledStatement& IfHasIndexStatement = Context.AppendStatementForNode(Node);
IfHasIndexStatement.Type = KCST_GotoIfNot;
IfHasIndexStatement.LHS = FuncLocals.GenericBoolTerm;
///////////////////////////////////////////////////////////////////
// They supplied a start index so set the index to it
///////////////////////////////////////////////////////////////////
// Index = StartIndex; // (StartIndex is from multi gate pin for it)
FBlueprintCompiledStatement& AssignSuppliedIndexStatement = Context.AppendStatementForNode(Node);
AssignSuppliedIndexStatement.Type = KCST_Assignment;
AssignSuppliedIndexStatement.LHS = FuncLocals.IndexTerm;
AssignSuppliedIndexStatement.RHS.Add(*StartIndexPinTerm);
// Jump to index usage
FBlueprintCompiledStatement& ElseGotoIndexUsageStatement = Context.AppendStatementForNode(Node);
ElseGotoIndexUsageStatement.Type = KCST_UnconditionalGoto;
// }
// else
// {
///////////////////////////////////////////////////////////////////
// They did NOT supply a start index so figure one out
///////////////////////////////////////////////////////////////////
check(FuncLocals.IndexTerm != nullptr);
// Index = GetUnmarkedBit(Data, -1, bRandom);
FBlueprintCompiledStatement& GetStartIndexStatement = Context.AppendStatementForNode(Node);
GetStartIndexStatement.Type = KCST_CallFunction;
GetStartIndexStatement.FunctionToCall = GetUnmarkedBitFunction;
GetStartIndexStatement.bIsParentContext = false;
GetStartIndexStatement.LHS = FuncLocals.IndexTerm;
GetStartIndexStatement.RHS.Add(DataTerm);
GetStartIndexStatement.RHS.Add(*StartIndexPinTerm);
GetStartIndexStatement.RHS.Add(NumOutsTerm);
GetStartIndexStatement.RHS.Add(*RandomTerm);
// Hook the IfHasIndexStatement jump to this node
GetStartIndexStatement.bIsJumpTarget = true;
IfHasIndexStatement.TargetLabel = &GetStartIndexStatement;
// Jump to index usage
FBlueprintCompiledStatement& StartIndexGotoIndexUsageStatement = Context.AppendStatementForNode(Node);
StartIndexGotoIndexUsageStatement.Type = KCST_UnconditionalGoto;
// }
// }
// else
// {
////////////////////////////////////////////////////////////////////////////
// Else this is NOT the first time in, see if there is an available index
////////////////////////////////////////////////////////////////////////////
// (HasUnmarkedBit())
FBlueprintCompiledStatement& IsAvailableStatement = Context.AppendStatementForNode(Node);
IsAvailableStatement.Type = KCST_CallFunction;
IsAvailableStatement.FunctionToCall = HasUnmarkedBitFunction;
IsAvailableStatement.FunctionContext = NULL;
IsAvailableStatement.bIsParentContext = false;
IsAvailableStatement.LHS = FuncLocals.GenericBoolTerm;
IsAvailableStatement.RHS.Add(DataTerm);
IsAvailableStatement.RHS.Add(NumOutsTerm);
// Hook the IfFirstTimeStatement jump to this node
IsAvailableStatement.bIsJumpTarget = true;
IfFirstTimeStatement.TargetLabel = &IsAvailableStatement;
// if (HasUnmarkedBit())
// {
FBlueprintCompiledStatement& IfIsAvailableStatement = Context.AppendStatementForNode(Node);
IfIsAvailableStatement.Type = KCST_GotoIfNot;
IfIsAvailableStatement.LHS = FuncLocals.GenericBoolTerm;
////////////////////////////////////////////////////////////////////////////
// Has available index so figure it out and jump to its' usage
////////////////////////////////////////////////////////////////////////////
// Index = GetUnmarkedBit(Data, -1, bRandom)
FBlueprintCompiledStatement& GetNextIndexStatement = Context.AppendStatementForNode(Node);
GetNextIndexStatement.Type = KCST_CallFunction;
GetNextIndexStatement.FunctionToCall = GetUnmarkedBitFunction;
GetNextIndexStatement.bIsParentContext = false;
GetNextIndexStatement.LHS = FuncLocals.IndexTerm;
GetNextIndexStatement.RHS.Add(DataTerm);
GetNextIndexStatement.RHS.Add(*StartIndexPinTerm);
GetNextIndexStatement.RHS.Add(NumOutsTerm);
GetNextIndexStatement.RHS.Add(*RandomTerm);
// Goto Index usage
FBlueprintCompiledStatement& GotoIndexUsageStatement = Context.AppendStatementForNode(Node);
GotoIndexUsageStatement.Type = KCST_UnconditionalGoto;
// }
// else
// {
////////////////////////////////////////////////////////////////////////////
// No available index, see if we can loop
////////////////////////////////////////////////////////////////////////////
// if (bLoop)
FBlueprintCompiledStatement& IfLoopingStatement = Context.AppendStatementForNode(Node);
IfLoopingStatement.Type = KCST_GotoIfNot;
IfLoopingStatement.LHS = *LoopTerm;
IfLoopingStatement.bIsJumpTarget = true;
IfIsAvailableStatement.TargetLabel = &IfLoopingStatement;
// {
////////////////////////////////////////////////////////////////////////////
// Reset the data and jump back up to "if (HasUnmarkedBit())"
////////////////////////////////////////////////////////////////////////////
// Clear the data
// Data = 0;
FBlueprintCompiledStatement& ClearDataStatement = Context.AppendStatementForNode(Node);
ClearDataStatement.Type = KCST_CallFunction;
ClearDataStatement.FunctionToCall = ClearBitsFunction;
ClearDataStatement.bIsParentContext = false;
ClearDataStatement.RHS.Add(DataTerm);
// Goto back up to attempt an index again
FBlueprintCompiledStatement& RetryStatement = Context.AppendStatementForNode(Node);
RetryStatement.Type = KCST_UnconditionalGoto;
IsAvailableStatement.bIsJumpTarget = true;
RetryStatement.TargetLabel = &IsAvailableStatement;
// }
// else
// {
////////////////////////////////////////////////////////////////////////////
// Dead... Jump to end of thread
////////////////////////////////////////////////////////////////////////////
FBlueprintCompiledStatement& NoLoopStatement = Context.AppendStatementForNode(Node);
NoLoopStatement.Type = KCST_EndOfThread;
NoLoopStatement.bIsJumpTarget = true;
IfLoopingStatement.TargetLabel = &NoLoopStatement;
// }
// }
// }
//////////////////////////////////////
// We have a valid index so mark it
//////////////////////////////////////
// MarkBit(Data, Index);
FBlueprintCompiledStatement& MarkIndexStatement = Context.AppendStatementForNode(Node);
MarkIndexStatement.Type = KCST_CallFunction;
MarkIndexStatement.FunctionToCall = MarkBitFunction;
MarkIndexStatement.bIsParentContext = false;
MarkIndexStatement.LHS = FuncLocals.IndexTerm;
MarkIndexStatement.RHS.Add(DataTerm);
MarkIndexStatement.RHS.Add(FuncLocals.IndexTerm);
// Setup jump label
MarkIndexStatement.bIsJumpTarget = true;
GotoIndexUsageStatement.TargetLabel = &MarkIndexStatement;
ElseGotoIndexUsageStatement.TargetLabel = &MarkIndexStatement;
StartIndexGotoIndexUsageStatement.TargetLabel = &MarkIndexStatement;
/////////////////////////////////////////////////////////////////////////
// We have a valid index so mark it, then find the correct exec out pin
/////////////////////////////////////////////////////////////////////////
// Call the correct exec pin out of the multi gate node
FBlueprintCompiledStatement* PrevIndexEqualityStatement = NULL;
FBlueprintCompiledStatement* PrevIfIndexMatchesStatement = NULL;
for (int32 OutIdx = 0; OutIdx < OutPins.Num(); OutIdx++)
{
// (Index == OutIdx)
FBlueprintCompiledStatement& IndexEqualityStatement = Context.AppendStatementForNode(Node);
IndexEqualityStatement.Type = KCST_CallFunction;
IndexEqualityStatement.FunctionToCall = EqualityFunction;
IndexEqualityStatement.FunctionContext = NULL;
IndexEqualityStatement.bIsParentContext = false;
// LiteralIndexTerm will be the right side of the == statemnt
FBPTerminal* LiteralIndexTerm = Context.CreateLocalTerminal(ETerminalSpecification::TS_Literal);
LiteralIndexTerm->bIsLiteral = true;
LiteralIndexTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_Int;
LiteralIndexTerm->Name = FString::Printf(TEXT("%d"), OutIdx);
// Set the params
IndexEqualityStatement.LHS = FuncLocals.GenericBoolTerm;
IndexEqualityStatement.RHS.Add(FuncLocals.IndexTerm);
IndexEqualityStatement.RHS.Add(LiteralIndexTerm);
// if (Index == OutIdx)
FBlueprintCompiledStatement& IfIndexMatchesStatement = Context.AppendStatementForNode(Node);
IfIndexMatchesStatement.Type = KCST_GotoIfNot;
IfIndexMatchesStatement.LHS = FuncLocals.GenericBoolTerm;
// {
//////////////////////////////////////
// Found a match - Jump there
//////////////////////////////////////
GenerateSimpleThenGoto(Context, *GateNode, OutPins[OutIdx]);
// }
// else
// {
////////////////////////////////////////////////////
// Not a match so loop will attempt the next index
////////////////////////////////////////////////////
if (PrevIndexEqualityStatement && PrevIfIndexMatchesStatement)
{
// Attempt next index
IndexEqualityStatement.bIsJumpTarget = true;
PrevIfIndexMatchesStatement->TargetLabel = &IndexEqualityStatement;
}
// }
PrevIndexEqualityStatement = &IndexEqualityStatement;
PrevIfIndexMatchesStatement = &IfIndexMatchesStatement;
}
check(PrevIfIndexMatchesStatement);
// Should have jumped to proper index, print error (should never happen)
// Create a CallFunction statement for doing a print string of our error message
FBlueprintCompiledStatement& PrintStatement = Context.AppendStatementForNode(Node);
PrintStatement.Type = KCST_CallFunction;
PrintStatement.bIsJumpTarget = true;
PrintStatement.FunctionToCall = PrintFunction;
PrintStatement.FunctionContext = NULL;
PrintStatement.bIsParentContext = false;
// Create a local int for use in the equality call function below (LiteralTerm = the right hand side of the EqualEqual_IntInt or NotEqual_BoolBool statement)
FBPTerminal* LiteralStringTerm = Context.CreateLocalTerminal(ETerminalSpecification::TS_Literal);
LiteralStringTerm->bIsLiteral = true;
LiteralStringTerm->Type.PinCategory = CompilerContext.GetSchema()->PC_String;
LiteralStringTerm->Name = FString::Printf(*LOCTEXT("MultiGateNode IndexWarning", "MultiGate Node failed! Out of bounds indexing of the out pins. There are only %d outs available.").ToString(), OutPins.Num());
PrintStatement.RHS.Add(LiteralStringTerm);
// Hook the IfNot statement's jump target to this statement
PrevIfIndexMatchesStatement->TargetLabel = &PrintStatement;
}
