void UK2Node_CallArrayFunction::GetArrayPins(TArray< FArrayPropertyPinCombo >& OutArrayPinInfo ) const
{
OutArrayPinInfo.Empty();
UFunction* TargetFunction = GetTargetFunction();
check(TargetFunction);
FString ArrayPointerMetaData = TargetFunction->GetMetaData(FBlueprintMetadata::MD_ArrayParam);
TArray<FString> ArrayPinComboNames;
ArrayPointerMetaData.ParseIntoArray(ArrayPinComboNames, TEXT(","), true);
for(auto Iter = ArrayPinComboNames.CreateConstIterator(); Iter; ++Iter)
{
TArray<FString> ArrayPinNames;
Iter->ParseIntoArray(ArrayPinNames, TEXT("|"), true);
FArrayPropertyPinCombo ArrayInfo;
ArrayInfo.ArrayPin = FindPin(ArrayPinNames[0]);
if(ArrayPinNames.Num() > 1)
{
ArrayInfo.ArrayPropPin = FindPin(ArrayPinNames[1]);
}
if(ArrayInfo.ArrayPin)
{
OutArrayPinInfo.Add(ArrayInfo);
}
}
}
void UK2Node_Timeline::ExpandNode(FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UBlueprint* Blueprint = GetBlueprint();
check(Blueprint);
UTimelineTemplate* Timeline = Blueprint->FindTimelineTemplateByVariableName(TimelineName);
if(Timeline)
{
ExpandForPin(GetDirectionPin(), Timeline->GetDirectionPropertyName(), CompilerContext, SourceGraph);
for(int32 i=0; i<Timeline->FloatTracks.Num(); i++)
{
const FName TrackName = Timeline->FloatTracks[i].TrackName;
ExpandForPin(FindPin(TrackName.ToString()), Timeline->GetTrackPropertyName(TrackName), CompilerContext, SourceGraph);
}
for(int32 i=0; i<Timeline->VectorTracks.Num(); i++)
{
const FName TrackName = Timeline->VectorTracks[i].TrackName;
ExpandForPin(FindPin(TrackName.ToString()), Timeline->GetTrackPropertyName(TrackName), CompilerContext, SourceGraph);
}
for(int32 i=0; i<Timeline->LinearColorTracks.Num(); i++)
{
const FName TrackName = Timeline->LinearColorTracks[i].TrackName;
ExpandForPin(FindPin(TrackName.ToString()), Timeline->GetTrackPropertyName(TrackName), CompilerContext, SourceGraph);
}
}
}
void UK2Node_DelegateSet::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
if (SourceGraph != CompilerContext.ConsolidatedEventGraph)
{
CompilerContext.MessageLog.Error(*FString::Printf(*NSLOCTEXT("KismetCompiler", "InvalidNodeOutsideUbergraph_Error", "Unexpected node @@ found outside ubergraph.").ToString()), this);
}
else
{
UFunction* TargetFunction = GetDelegateSignature();
if(TargetFunction != NULL)
{
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
// First, create an event node matching the delegate signature
UK2Node_Event* DelegateEvent = CompilerContext.SpawnIntermediateEventNode<UK2Node_Event>(this, nullptr, SourceGraph);
DelegateEvent->EventReference.SetFromField<UFunction>(TargetFunction, false);
DelegateEvent->CustomFunctionName = GetDelegateTargetEntryPointName();
DelegateEvent->bInternalEvent = true;
DelegateEvent->AllocateDefaultPins();
// Move the pins over to the newly created event node
for( TArray<UEdGraphPin*>::TIterator PinIt(DelegateEvent->Pins); PinIt; ++PinIt )
{
UEdGraphPin* CurrentPin = *PinIt;
check(CurrentPin);
if( CurrentPin->Direction == EGPD_Output )
{
if( CurrentPin->PinType.PinCategory == Schema->PC_Exec )
{
// Hook up the exec pin specially, since it has a different name on the dynamic delegate node
UEdGraphPin* OldExecPin = FindPin(Schema->PN_DelegateEntry);
check(OldExecPin);
CompilerContext.MovePinLinksToIntermediate(*OldExecPin, *CurrentPin);
}
else if( CurrentPin->PinName != UK2Node_Event::DelegateOutputName )
{
// Hook up all other pins, EXCEPT the delegate output pin, which isn't needed in this case
UEdGraphPin* OldPin = FindPin(CurrentPin->PinName);
if( !OldPin )
{
// If we couldn't find the old pin, the function signature is out of date. Tell them to reconstruct
CompilerContext.MessageLog.Error(*FString::Printf(*NSLOCTEXT("KismetCompiler", "EventNodeOutOfDate_Error", "Event node @@ is out-of-date. Please refresh it.").ToString()), this);
return;
}
CompilerContext.MovePinLinksToIntermediate(*OldPin, *CurrentPin);
}
}
}
}
else
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("DelegateSigNotFound_Error", "Set Delegate node @@ unable to find function.").ToString()), this);
}
}
}
void UK2Node_EaseFunction::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
/**
At the end of this, the UK2Node_EaseFunction will not be a part of the Blueprint, it merely handles connecting
the other nodes into the Blueprint.
*/
UFunction* Function = UKismetMathLibrary::StaticClass()->FindFunctionByName(*EaseFunctionName);
if (Function == NULL)
{
CompilerContext.MessageLog.Error(*LOCTEXT("InvalidFunctionName", "BaseAsyncTask: Type not supported or not initialized. @@").ToString(), this);
return;
}
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
// The call function does all the real work, each child class implementing easing for a given type provides
// the name of the desired function
UK2Node_CallFunction* CallFunction = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
CallFunction->SetFromFunction(Function);
CallFunction->AllocateDefaultPins();
CompilerContext.MessageLog.NotifyIntermediateObjectCreation(CallFunction, this);
// Move the ease function and the alpha connections from us to the call function
CompilerContext.MovePinLinksToIntermediate(*FindPin(FEaseFunctionNodeHelper::GetEaseFuncPinName()), *CallFunction->FindPin(TEXT("EasingFunc")));
CompilerContext.MovePinLinksToIntermediate(*FindPin(FEaseFunctionNodeHelper::GetAlphaPinName()), *CallFunction->FindPin(TEXT("Alpha")));
// Move base connections to the call function's connections
CompilerContext.MovePinLinksToIntermediate(*FindPin(FEaseFunctionNodeHelper::GetAPinName()), *CallFunction->FindPin(TEXT("A")));
CompilerContext.MovePinLinksToIntermediate(*FindPin(FEaseFunctionNodeHelper::GetBPinName()), *CallFunction->FindPin(TEXT("B")));
CompilerContext.MovePinLinksToIntermediate(*FindPin(FEaseFunctionNodeHelper::GetResultPinName()), *CallFunction->GetReturnValuePin());
// Now move the custom pins to their new locations
UEdGraphPin* ShortestPathPin = FindPinChecked(FEaseFunctionNodeHelper::GetShortestPathPinName());
if (!ShortestPathPin->bHidden)
{
CompilerContext.MovePinLinksToIntermediate(*ShortestPathPin, *CallFunction->FindPinChecked(TEXT("bShortestPath")));
}
UEdGraphPin* BlendExpPin = FindPinChecked(FEaseFunctionNodeHelper::GetBlendExpPinName());
if (!BlendExpPin->bHidden)
{
CompilerContext.MovePinLinksToIntermediate(*BlendExpPin, *CallFunction->FindPinChecked(FEaseFunctionNodeHelper::GetBlendExpPinName()));
}
UEdGraphPin* StepsPin = FindPinChecked(FEaseFunctionNodeHelper::GetStepsPinName());
if (!StepsPin->bHidden)
{
CompilerContext.MovePinLinksToIntermediate(*StepsPin, *CallFunction->FindPinChecked(FEaseFunctionNodeHelper::GetStepsPinName()));
}
// Cleanup links to ourself and we are done!
BreakAllNodeLinks();
}
void UGameplayTagsK2Node_MultiCompareGameplayTagContainerSingleTags::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
// Get The input and output pins to our node
UEdGraphPin* InPinSwitch = FindPin(TEXT("Gameplay Tag Container"));
UEdGraphPin* InPinContainerMatchType = FindPin(TEXT("Tag Container Match Type"));
UEdGraphPin* InPinTagsMatchType = FindPin(TEXT("Tags Match Type"));
// For Each Pin Compare against the Tag container
for (int32 Index = 0; Index < NumberOfPins; ++Index)
{
FString InPinName = TEXT("TagCase_") + FString::FormatAsNumber(Index);
FString OutPinName = TEXT("Case_") + FString::FormatAsNumber(Index) + TEXT(" True");
UEdGraphPin* InPinCase = FindPin(InPinName);
UEdGraphPin* OutPinCase = FindPin(OutPinName);
// Create call function node for the Compare function HasAllMatchingGameplayTags
UK2Node_CallFunction* PinCallFunction = CompilerContext.SpawnIntermediateNode<UK2Node_CallFunction>(this, SourceGraph);
const UFunction* Function = UBlueprintGameplayTagLibrary::StaticClass()->FindFunctionByName(GET_FUNCTION_NAME_CHECKED(UBlueprintGameplayTagLibrary, DoesContainerHaveTag));
PinCallFunction->SetFromFunction(Function);
PinCallFunction->AllocateDefaultPins();
UEdGraphPin *TagContainerPin = PinCallFunction->FindPinChecked(FString(TEXT("TagContainer")));
CompilerContext.CopyPinLinksToIntermediate(*InPinSwitch, *TagContainerPin);
UEdGraphPin *TagPin = PinCallFunction->FindPinChecked(FString(TEXT("Tag")));
CompilerContext.MovePinLinksToIntermediate(*InPinCase, *TagPin);
UEdGraphPin *ContainerTagsMatchTypePin = PinCallFunction->FindPinChecked(FString(TEXT("ContainerTagsMatchType")));
CompilerContext.CopyPinLinksToIntermediate(*InPinContainerMatchType, *ContainerTagsMatchTypePin);
UEdGraphPin *TagMatchTypePin = PinCallFunction->FindPinChecked(FString(TEXT("TagMatchType")));
CompilerContext.CopyPinLinksToIntermediate(*InPinTagsMatchType, *TagMatchTypePin);
UEdGraphPin *OutPin = PinCallFunction->FindPinChecked(K2Schema->PN_ReturnValue);
if (OutPinCase && OutPin)
{
OutPin->PinType = OutPinCase->PinType; // Copy type so it uses the right actor subclass
CompilerContext.MovePinLinksToIntermediate(*OutPinCase, *OutPin);
}
}
// Break any links to the expanded node
BreakAllNodeLinks();
}
HRESULT CSampleCGB::FindEncoder( IEnumMoniker *pEncoders, REGPINMEDIUM pinMedium, IBaseFilter **ppEncoder )
{
if( ! pEncoders )
{
return E_INVALIDARG;
}
if(IsEqualGUID(pinMedium.clsMedium,GUID_NULL) || IsEqualGUID(pinMedium.clsMedium,KSMEDIUMSETID_Standard))
{
return E_INVALIDARG;
}
HRESULT hr;
SmartPtr<IBaseFilter> pFilter;
SmartPtr<IMoniker> pMoniker;
ULONG cFetched;
SmartPtr<IPin> pPin;
while(pFilter.Release(),pMoniker.Release(),S_OK == pEncoders->Next(1,&pMoniker,&cFetched))
{
hr = pMoniker->BindToObject(0,0,IID_IBaseFilter,(void**)&pFilter);
if(FAILED(hr))continue;
hr = FindPin(pFilter,pinMedium,PINDIR_INPUT,TRUE,&pPin);
if(SUCCEEDED(hr))
{
*ppEncoder = pFilter.Detach();
return hr;
}
}
return E_FAIL;
}
void UK2Node_FunctionEntry::AllocateDefaultPins()
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Then);
UFunction* Function = FindField<UFunction>(SignatureClass, SignatureName);
if (Function == nullptr)
{
Function = FindDelegateSignature(SignatureName);
}
if (Function != NULL)
{
CreatePinsForFunctionEntryExit(Function, /*bIsFunctionEntry=*/ true);
}
Super::AllocateDefaultPins();
if (FFunctionEntryHelper::RequireWorldContextParameter(this)
&& ensure(!FindPin(FFunctionEntryHelper::GetWorldContextPinName())))
{
UEdGraphPin* WorldContextPin = CreatePin(
EGPD_Output,
K2Schema->PC_Object,
FString(),
UObject::StaticClass(),
false,
false,
FFunctionEntryHelper::GetWorldContextPinName());
WorldContextPin->bHidden = true;
}
}
void UK2Node_Event::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
if (CompilerContext.bIsFullCompile)
{
UEdGraphPin* OrgDelegatePin = FindPin(UK2Node_Event::DelegateOutputName);
if (OrgDelegatePin && OrgDelegatePin->LinkedTo.Num() > 0)
{
const UEdGraphSchema_K2* Schema = CompilerContext.GetSchema();
const FName FunctionName = GetFunctionName();
if(FunctionName == NAME_None)
{
CompilerContext.MessageLog.Error(*FString::Printf(*LOCTEXT("EventDelegateName_Error", "Event node @@ has no name of function.").ToString()), this);
}
UK2Node_Self* SelfNode = CompilerContext.SpawnIntermediateNode<UK2Node_Self>(this, SourceGraph);
SelfNode->AllocateDefaultPins();
UK2Node_CreateDelegate* CreateDelegateNode = CompilerContext.SpawnIntermediateNode<UK2Node_CreateDelegate>(this, SourceGraph);
CreateDelegateNode->AllocateDefaultPins();
CompilerContext.MovePinLinksToIntermediate(*OrgDelegatePin, *CreateDelegateNode->GetDelegateOutPin());
Schema->TryCreateConnection(SelfNode->FindPinChecked(Schema->PN_Self), CreateDelegateNode->GetObjectInPin());
// When called UFunction is defined in the same class, it wasn't created yet (previously the Skeletal class was checked). So no "CreateDelegateNode->HandleAnyChangeWithoutNotifying();" is called.
CreateDelegateNode->SetFunction(FunctionName);
}
}
}
void UAnimGraphNode_PoseByName::ValidateAnimNodeDuringCompilation(class USkeleton* ForSkeleton, class FCompilerResultsLog& MessageLog)
{
UPoseAsset* PoseAssetToCheck = Node.PoseAsset;
UEdGraphPin* PoseAssetPin = FindPin(GET_MEMBER_NAME_STRING_CHECKED(FAnimNode_PoseByName, PoseAsset));
if (PoseAssetPin != nullptr && PoseAssetToCheck == nullptr)
{
PoseAssetToCheck = Cast<UPoseAsset>(PoseAssetPin->DefaultObject);
}
if (PoseAssetToCheck == nullptr)
{
// we may have a connected node
if (PoseAssetPin == nullptr || PoseAssetPin->LinkedTo.Num() == 0)
{
MessageLog.Error(TEXT("@@ references an unknown pose asset"), this);
}
}
else
{
USkeleton* SeqSkeleton = PoseAssetToCheck->GetSkeleton();
if (SeqSkeleton&& // if anim sequence doesn't have skeleton, it might be due to anim sequence not loaded yet, @todo: wait with anim blueprint compilation until all assets are loaded?
!SeqSkeleton->IsCompatible(ForSkeleton))
{
MessageLog.Error(TEXT("@@ references sequence that uses different skeleton @@"), this, SeqSkeleton);
}
}
}
UEdGraphPin* UK2Node_DynamicCast::GetBoolSuccessPin() const
{
UEdGraphPin* Pin = FindPin(UK2Node_DynamicCastImpl::CastSuccessPinName);
check(Pin != nullptr);
check(Pin->Direction == EGPD_Output);
return Pin;
}
FText UAnimGraphNode_PoseByName::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (Node.PoseAsset == nullptr)
{
// we may have a valid variable connected or default pin value
UEdGraphPin* PosePin = FindPin(GET_MEMBER_NAME_STRING_CHECKED(FAnimNode_PoseByName, PoseAsset));
if (PosePin && PosePin->LinkedTo.Num() > 0)
{
return LOCTEXT("PoseByName_TitleVariable", "Pose");
}
else if (PosePin && PosePin->DefaultObject != nullptr)
{
return GetNodeTitleForPoseAsset(TitleType, CastChecked<UPoseAsset>(PosePin->DefaultObject));
}
else
{
return LOCTEXT("PoseByName_TitleNONE", "Pose (None)");
}
}
// @TODO: don't know enough about this node type to comfortably assert that
// the CacheName won't change after the node has spawned... until
// then, we'll leave this optimization off
else //if (CachedNodeTitle.IsOutOfDate(this))
{
return GetNodeTitleForPoseAsset(TitleType, Node.PoseAsset);
}
}
void UK2Node_Select::AllocateDefaultPins()
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
// To refresh, just in case it changed
SetEnum(Enum, true);
if (Enum)
{
NumOptionPins = EnumEntries.Num();
}
// Create the option pins
for (int32 Idx = 0; Idx < NumOptionPins; Idx++)
{
UEdGraphPin* NewPin = NULL;
if (Enum)
{
const FString PinName = EnumEntries[Idx].ToString();
UEdGraphPin* TempPin = FindPin(PinName);
if (!TempPin)
{
NewPin = CreatePin(EGPD_Input, Schema->PC_Wildcard, TEXT(""), NULL, false, false, PinName);
}
}
else
{
const FString PinName = FString::Printf(TEXT("Option %d"), Idx);
NewPin = CreatePin(EGPD_Input, Schema->PC_Wildcard, TEXT(""), NULL, false, false, PinName);
}
if (NewPin)
{
if (IndexPinType.PinCategory == UEdGraphSchema_K2::PC_Boolean)
{
NewPin->PinFriendlyName = (Idx == 0 ? GFalse : GTrue);
}
else if (Idx < EnumEntryFriendlyNames.Num())
{
if (EnumEntryFriendlyNames[Idx] != NAME_None)
{
NewPin->PinFriendlyName = FText::FromName(EnumEntryFriendlyNames[Idx]);
}
else
{
NewPin->PinFriendlyName = FText::GetEmpty();
}
}
}
}
// Create the index wildcard pin
CreatePin(EGPD_Input, IndexPinType.PinCategory, IndexPinType.PinSubCategory, IndexPinType.PinSubCategoryObject.Get(), false, false, "Index");
// Create the return value
CreatePin(EGPD_Output, Schema->PC_Wildcard, TEXT(""), NULL, false, false, Schema->PN_ReturnValue);
Super::AllocateDefaultPins();
}
bool UK2Node_EditablePinBase::ModifyUserDefinedPinDefaultValue(TSharedPtr<FUserPinInfo> PinInfo, const FString& InDefaultValue)
{
FString NewDefaultValue = InDefaultValue;
// Find and modify the current pin
if (UEdGraphPin* OldPin = FindPin(PinInfo->PinName))
{
FString SavedDefaultValue = OldPin->DefaultValue;
OldPin->DefaultValue = OldPin->AutogeneratedDefaultValue = NewDefaultValue;
// Validate the new default value
const UEdGraphSchema* Schema = GetSchema();
FString ErrorString = Schema->IsCurrentPinDefaultValid(OldPin);
if (!ErrorString.IsEmpty())
{
NewDefaultValue = SavedDefaultValue;
OldPin->DefaultValue = OldPin->AutogeneratedDefaultValue = SavedDefaultValue;
return false;
}
}
PinInfo->PinDefaultValue = NewDefaultValue;
return true;
}
void UAnimGraphNode_PoseHandler::ValidateAnimNodeDuringCompilation(USkeleton* ForSkeleton, FCompilerResultsLog& MessageLog)
{
UPoseAsset* PoseAssetToCheck = GetPoseHandlerNode()->PoseAsset;
UEdGraphPin* PoseAssetPin = FindPin(GET_MEMBER_NAME_STRING_CHECKED(FAnimNode_PoseHandler, PoseAsset));
if (PoseAssetPin != nullptr && PoseAssetToCheck == nullptr)
{
PoseAssetToCheck = Cast<UPoseAsset>(PoseAssetPin->DefaultObject);
}
if (PoseAssetToCheck == nullptr)
{
if (PoseAssetPin == nullptr || PoseAssetPin->LinkedTo.Num() == 0)
{
MessageLog.Error(TEXT("@@ references an unknown poseasset"), this);
}
}
else
{
USkeleton* SeqSkeleton = PoseAssetToCheck->GetSkeleton();
if (SeqSkeleton && // if PoseAsset doesn't have skeleton, it might be due to PoseAsset not loaded yet, @todo: wait with anim blueprint compilation until all assets are loaded?
!SeqSkeleton->IsCompatible(ForSkeleton))
{
MessageLog.Error(TEXT("@@ references poseasset that uses different skeleton @@"), this, SeqSkeleton);
}
}
Super::ValidateAnimNodeDuringCompilation(ForSkeleton, MessageLog);
}
void UK2Node_ConvertAsset::RefreshPinTypes()
{
const UEdGraphSchema_K2* K2Schema = CastChecked<UEdGraphSchema_K2>(GetSchema());
auto InutPin = FindPin(UK2Node_ConvertAssetImpl::InputPinName);
auto OutputPin = FindPin(UK2Node_ConvertAssetImpl::OutputPinName);
ensure(InutPin && OutputPin);
if (InutPin && OutputPin)
{
const bool bIsConnected = InutPin->LinkedTo.Num() > 0;
UClass* TargetType = bIsConnected ? GetTargetClass() : nullptr;
const bool bIsAssetClass = bIsConnected ? IsAssetClassType() : false;
const FString InputCategory = bIsConnected
? (bIsAssetClass ? K2Schema->PC_AssetClass : K2Schema->PC_Asset)
: K2Schema->PC_Wildcard;
InutPin->PinType = FEdGraphPinType(InputCategory, FString(), TargetType, false, false);
const FString OutputCategory = bIsConnected
? (bIsAssetClass ? K2Schema->PC_Class : K2Schema->PC_Object)
: K2Schema->PC_Wildcard;
OutputPin->PinType = FEdGraphPinType(OutputCategory, FString(), TargetType, false, false);
PinTypeChanged(InutPin);
PinTypeChanged(OutputPin);
if (OutputPin->LinkedTo.Num())
{
UClass const* CallingContext = NULL;
if (UBlueprint const* Blueprint = GetBlueprint())
{
CallingContext = Blueprint->GeneratedClass;
if (CallingContext == NULL)
{
CallingContext = Blueprint->ParentClass;
}
}
for (auto TargetPin : OutputPin->LinkedTo)
{
if (TargetPin && !K2Schema->ArePinsCompatible(OutputPin, TargetPin, CallingContext))
{
OutputPin->BreakLinkTo(TargetPin);
}
}
}
}
}
UEdGraphPin* UK2Node_IfThenElse::GetConditionPin() const
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* Pin = FindPin(K2Schema->PN_Condition);
check(Pin != NULL);
return Pin;
}
UEdGraphPin* UK2Node::GetExecPin() const
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* Pin = FindPin(K2Schema->PN_Execute);
check(Pin == NULL || Pin->Direction == EGPD_Input); // If pin exists, it must be input
return Pin;
}
UEdGraphPin* UK2Node_EnumEquality::GetInput2Pin() const
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* Pin = FindPin("B");
check(Pin != NULL);
return Pin;
}
UEdGraphPin* UK2Node_Select::GetReturnValuePin() const
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* Pin = FindPin(K2Schema->PN_ReturnValue);
check(Pin != NULL);
return Pin;
}
UEdGraphPin* UK2Node_Select::GetIndexPin() const
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* Pin = FindPin("Index");
check(Pin != NULL);
return Pin;
}
void UK2Node_AddComponent::ExpandNode(class FKismetCompilerContext& CompilerContext, UEdGraph* SourceGraph)
{
Super::ExpandNode(CompilerContext, SourceGraph);
auto TransformPin = GetRelativeTransformPin();
if (TransformPin && !TransformPin->LinkedTo.Num())
{
FString DefaultValue;
// Try and find the template and get relative transform from it
UEdGraphPin* TemplateNamePin = GetTemplateNamePinChecked();
const FString TemplateName = TemplateNamePin->DefaultValue;
check(CompilerContext.Blueprint);
USceneComponent* SceneCompTemplate = Cast<USceneComponent>(CompilerContext.Blueprint->FindTemplateByName(FName(*TemplateName)));
if (SceneCompTemplate)
{
FTransform TemplateTransform = FTransform(SceneCompTemplate->RelativeRotation, SceneCompTemplate->RelativeLocation, SceneCompTemplate->RelativeScale3D);
DefaultValue = TemplateTransform.ToString();
}
auto ValuePin = InnerHandleAutoCreateRef(this, TransformPin, CompilerContext, SourceGraph, !DefaultValue.IsEmpty());
if (ValuePin)
{
ValuePin->DefaultValue = DefaultValue;
}
}
if (bHasExposedVariable)
{
static FString ObjectParamName = FString(TEXT("Object"));
static FString ValueParamName = FString(TEXT("Value"));
static FString PropertyNameParamName = FString(TEXT("PropertyName"));
UK2Node_AddComponent* NewNode = CompilerContext.SpawnIntermediateNode<UK2Node_AddComponent>(this, SourceGraph);
NewNode->SetFromFunction(GetTargetFunction());
NewNode->AllocateDefaultPinsWithoutExposedVariables();
// function parameters
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
CompilerContext.MovePinLinksToIntermediate(*FindPin(K2Schema->PN_Self), *NewNode->FindPin(K2Schema->PN_Self));
CompilerContext.MovePinLinksToIntermediate(*GetTemplateNamePinChecked(), *NewNode->GetTemplateNamePinChecked());
CompilerContext.MovePinLinksToIntermediate(*GetRelativeTransformPin(), *NewNode->GetRelativeTransformPin());
CompilerContext.MovePinLinksToIntermediate(*GetManualAttachmentPin(), *NewNode->GetManualAttachmentPin());
UEdGraphPin* ReturnPin = NewNode->GetReturnValuePin();
UEdGraphPin* OriginalReturnPin = GetReturnValuePin();
check((NULL != ReturnPin) && (NULL != OriginalReturnPin));
ReturnPin->PinType = OriginalReturnPin->PinType;
CompilerContext.MovePinLinksToIntermediate(*OriginalReturnPin, *ReturnPin);
// exec in
CompilerContext.MovePinLinksToIntermediate(*GetExecPin(), *NewNode->GetExecPin());
UEdGraphPin* LastThen = FKismetCompilerUtilities::GenerateAssignmentNodes( CompilerContext, SourceGraph, NewNode, this, ReturnPin, GetSpawnedType() );
CompilerContext.MovePinLinksToIntermediate(*GetThenPin(), *LastThen);
BreakAllNodeLinks();
}
}
bool ConnectPins(IGraphBuilder *filterGraph, IBaseFilter* outputFilter, unsigned int outputNum, IBaseFilter* inputFilter, unsigned int inputNum)
{
IPin *inputPin = 0;
IPin *outputPin = 0;
if (!outputFilter || !inputFilter) {
return false;
}
FindPin(outputFilter, PINDIR_OUTPUT, outputNum, &outputPin);
FindPin(inputFilter, PINDIR_INPUT, inputNum, &inputPin);
bool ret = false;
if (inputPin && outputPin)
{
IPin *tmp = 0;
outputPin->ConnectedTo (&tmp);
if (tmp)
{
outputPin->Disconnect ();
tmp->Release();
}
inputPin->ConnectedTo (&tmp);
if (tmp)
{
inputPin->Disconnect ();
tmp->Release();
}
HRESULT hr = filterGraph->Connect (outputPin, inputPin);
ret = SUCCEEDED(hr);
}
if (inputPin)
{
inputPin->Release();
}
if (outputPin)
{
outputPin->Release();
}
return ret;
}
void UK2Node_Event::PinConnectionListChanged(UEdGraphPin* Pin)
{
if(Pin == FindPin(DelegateOutputName))
{
UpdateDelegatePin();
}
Super::PinConnectionListChanged(Pin);
}
UEdGraphPin* UK2Node_DynamicCast::GetCastSourcePin() const
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* Pin = FindPin(K2Schema->PN_ObjectToCast);
check(Pin != NULL);
check(Pin->Direction == EGPD_Input);
return Pin;
}
UEdGraphPin* UK2Node_DynamicCast::GetInvalidCastPin() const
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* Pin = FindPin(K2Schema->PN_CastFailed);
check((Pin != nullptr) || bIsPureCast);
check((Pin == nullptr) || (Pin->Direction == EGPD_Output));
return Pin;
}
bool UK2Node_CustomEvent::IsEditable() const
{
const UEdGraphPin* DelegateOutPin = FindPin(DelegateOutputName);
if(DelegateOutPin && DelegateOutPin->LinkedTo.Num())
{
return false;
}
return Super::IsEditable();
}
UEdGraphPin* UK2Node_DelegateSet::GetDelegateOwner() const
{
const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* Pin = FindPin(DelegatePropertyName.ToString());
check(Pin != NULL);
check(Pin->Direction == EGPD_Input);
return Pin;
}
UClass* UK2Node_ConvertAsset::GetTargetClass() const
{
auto InutPin = FindPin(UK2Node_ConvertAssetImpl::InputPinName);
bool bIsConnected = InutPin && InutPin->LinkedTo.Num() && InutPin->LinkedTo[0];
auto SourcePin = bIsConnected ? InutPin->LinkedTo[0] : nullptr;
return SourcePin
? Cast<UClass>(SourcePin->PinType.PinSubCategoryObject.Get())
: nullptr;
}
void UK2Node_EaseFunction::ResetToWildcards()
{
FScopedTransaction Transaction(LOCTEXT("ResetToDefaultsTx", "ResetToDefaults"));
Modify();
// Get pin refs
UEdGraphPin* APin = FindPin(FEaseFunctionNodeHelper::GetAPinName());
UEdGraphPin* BPin = FindPin(FEaseFunctionNodeHelper::GetBPinName());
UEdGraphPin* ResultPin = FindPin(FEaseFunctionNodeHelper::GetResultPinName());
// Set all to defaults and break links
APin->DefaultValue = TEXT("");
BPin->DefaultValue = TEXT("");
APin->BreakAllPinLinks();
BPin->BreakAllPinLinks();
ResultPin->BreakAllPinLinks();
// Do the rest of the work, we will not recompile because the wildcard pins will prevent it
PinTypeChanged(APin);
}
UAnimationAsset* UAnimGraphNode_PoseByName::GetAnimationAsset() const
{
UPoseAsset* PoseAsset = Node.PoseAsset;
UEdGraphPin* PoseAssetPin = FindPin(GET_MEMBER_NAME_STRING_CHECKED(FAnimNode_PoseByName, PoseAsset));
if (PoseAssetPin != nullptr && PoseAsset == nullptr)
{
PoseAsset = Cast<UPoseAsset>(PoseAssetPin->DefaultObject);
}
return PoseAsset;
}