自学教程：C++ CreatePin函数代码示例

void UK2Node_GetEnumeratorName::AllocateDefaultPins(){	const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Input, Schema->PC_Byte, TEXT(""), NULL, false, false, EnumeratorPinName);	CreatePin(EGPD_Output, Schema->PC_Name, TEXT(""), NULL, false, false, Schema->PN_ReturnValue);}

void UK2Node_MatineeController::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	// Preload the matinee data, if needed, so that we can have all the event tracks we need	if (MatineeActor != NULL)	{		PreloadObject(MatineeActor);		PreloadObject(MatineeActor->MatineeData);	}	// Create the "finished" playing pin	CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_MatineeFinished);	// Create pins for each event	if(MatineeActor != NULL && MatineeActor->MatineeData != NULL)	{		TArray<FName> EventNames;		MatineeActor->MatineeData->GetAllEventNames(EventNames);		for(int32 i=0; i<EventNames.Num(); i++)		{			FName EventName = EventNames[i];			CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, EventName.ToString());					}	}	Super::AllocateDefaultPins();}

void UK2Node_Composite::AllocateDefaultPins(){	UK2Node::AllocateDefaultPins();	if (OutputSourceNode)	{		for (TArray<UEdGraphPin*>::TIterator PinIt(OutputSourceNode->Pins); PinIt; ++PinIt)		{			UEdGraphPin* PortPin = *PinIt;			if (PortPin->Direction == EGPD_Input)			{				UEdGraphPin* NewPin = CreatePin(UEdGraphPin::GetComplementaryDirection(PortPin->Direction), PortPin->PinType, PortPin->PinName);				NewPin->DefaultValue = NewPin->AutogeneratedDefaultValue = PortPin->DefaultValue;			}		}	}	if (InputSinkNode)	{		for (TArray<UEdGraphPin*>::TIterator PinIt(InputSinkNode->Pins); PinIt; ++PinIt)		{			UEdGraphPin* PortPin = *PinIt;			if (PortPin->Direction == EGPD_Output)			{				UEdGraphPin* NewPin = CreatePin(UEdGraphPin::GetComplementaryDirection(PortPin->Direction), PortPin->PinType, PortPin->PinName);				NewPin->DefaultValue = NewPin->AutogeneratedDefaultValue = PortPin->DefaultValue;			}		}	}}

void UGameplayTagsK2Node_LiteralGameplayTag::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Input, K2Schema->PC_String, TEXT("LiteralGameplayTagContainer"), NULL, false, false, TEXT("TagIn"));	CreatePin(EGPD_Output, K2Schema->PC_Struct, TEXT(""), FGameplayTagContainer::StaticStruct(), false, false, K2Schema->PN_ReturnValue);}

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 UBehaviorTreeGraphNode_SimpleParallel::AllocateDefaultPins(){	CreatePin(EGPD_Input, UBehaviorTreeEditorTypes::PinCategory_MultipleNodes, TEXT(""), NULL, false, false, TEXT("In"));		CreatePin(EGPD_Output, UBehaviorTreeEditorTypes::PinCategory_SingleTask, TEXT(""), NULL, false, false, TEXT("Task"));	CreatePin(EGPD_Output, UBehaviorTreeEditorTypes::PinCategory_SingleNode, TEXT(""), NULL, false, false, TEXT("Out"));}

void UK2Node_BaseMCDelegate::AllocateDefaultPins(){	Super::AllocateDefaultPins();	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Input, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Execute);	CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Then);	UEdGraphPin* SelfPin = NULL;	if (DelegateReference.IsSelfContext())	{		SelfPin = CreatePin(EGPD_Input, K2Schema->PC_Object, K2Schema->PSC_Self, NULL, false, false, K2Schema->PN_Self);	}	else	{		// Allow redirects on the target node if necessary.		DelegateReference.ResolveMember<UMulticastDelegateProperty>((UClass*)NULL);		SelfPin = CreatePin(EGPD_Input, K2Schema->PC_Object, TEXT(""), DelegateReference.GetMemberParentClass(this), false, false, K2Schema->PN_Self);	}	if(SelfPin)	{		SelfPin->PinFriendlyName = NSLOCTEXT("K2Node", "BaseMCDelegateSelfPinName", "Target").ToString();	}}

void UK2Node_PlayMovieScene::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	// Do not allow users to rename the node	// @todo sequencer: If we want to support renaming, this we'll need to update FNameValidatorFactory::MakeValidator() and perhaps other locations	bCanRenameNode = 0;	// "Play" starts or resumes playback from the current position	CreatePin( EGPD_Input, K2Schema->PC_Exec, TEXT(""), NULL, false, false, PlayMovieScenePinNames::Play );	// "Pause" stops playback, leaving the time cursor at its current position	CreatePin( EGPD_Input, K2Schema->PC_Exec, TEXT(""), NULL, false, false, PlayMovieScenePinNames::Pause );	// @todo sequencer: Add PlayFromStart?	// @todo sequencer: Add PlayReverse pin?  PlayReverseFromEnd?	// @todo sequencer: Add "set time" input	// @todo sequencer: Needs output pin for "finished playing"	if( MovieSceneBindings != NULL )	{		for( auto BoundObjectIter( MovieSceneBindings->GetBoundObjects().CreateIterator() ); BoundObjectIter; ++BoundObjectIter )		{			auto& BoundObject = *BoundObjectIter;			CreatePinForBoundObject( BoundObject );		}	}		Super::AllocateDefaultPins();}

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();}

void UNiagaraNodeOutput::AllocateDefaultPins(){	const UEdGraphSchema_Niagara* Schema = GetDefault<UEdGraphSchema_Niagara>();	for (const FNiagaraVariableInfo& Output : Outputs)	{		switch (Output.Type)		{		case ENiagaraDataType::Scalar:		{			CreatePin(EGPD_Input, Schema->PC_Float, TEXT(""), NULL, false, false, Output.Name.ToString());		}			break;		case ENiagaraDataType::Vector:		{			CreatePin(EGPD_Input, Schema->PC_Vector, TEXT(""), NULL, false, false, Output.Name.ToString());		}			break;		case ENiagaraDataType::Matrix:		{			CreatePin(EGPD_Input, Schema->PC_Matrix, TEXT(""), NULL, false, false, Output.Name.ToString());		}			break;		case ENiagaraDataType::Curve:		{			 CreatePin(EGPD_Input, Schema->PC_Curve, TEXT(""), NULL, false, false, Output.Name.ToString());		}			break;		};	}}

void UK2Node_CastByteToEnum::AllocateDefaultPins(){	const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();		CreatePin(EGPD_Input, Schema->PC_Byte, TEXT(""), NULL, false, false, ByteInputPinName);	CreatePin(EGPD_Output, Schema->PC_Byte, TEXT(""), Enum, false, false, Schema->PN_ReturnValue);}

void UNiagaraNodeInput::AllocateDefaultPins(){	const UEdGraphSchema_Niagara* Schema = GetDefault<UEdGraphSchema_Niagara>();	switch (Input.Type)	{		case ENiagaraDataType::Scalar:		{			CreatePin(EGPD_Output, Schema->PC_Float, TEXT(""), NULL, false, false, TEXT("Input"));		}			break;		case ENiagaraDataType::Vector:		{			CreatePin(EGPD_Output, Schema->PC_Vector, TEXT(""), NULL, false, false, TEXT("Input"));		}			break;		case ENiagaraDataType::Matrix:		{			CreatePin(EGPD_Output, Schema->PC_Matrix, TEXT(""), NULL, false, false, TEXT("Input"));		}			break;		case ENiagaraDataType::Curve:		{			CreatePin(EGPD_Output, Schema->PC_Curve, TEXT(""), NULL, false, false, TEXT("Input"));		}		break;	};}

void UEdGraphNode_Reference::AllocateDefaultPins(){	ReferencerPin = CreatePin( EEdGraphPinDirection::EGPD_Input, TEXT(""), TEXT(""), NULL, false, false, TEXT("") );	DependencyPin = CreatePin( EEdGraphPinDirection::EGPD_Output, TEXT(""), TEXT(""), NULL, false, false, TEXT("") );	ReferencerPin->bHidden = true;	DependencyPin->bHidden = true;}

void UK2Node_InputKey::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, TEXT("Pressed"));	CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, TEXT("Released"));	Super::AllocateDefaultPins();}

void UK2Node_VariableGet::CreateNonPurePins(TArray<UEdGraphPin*>* InOldPinsPtr){	const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(GetSchema());	check(K2Schema != nullptr);	if (!K2Schema->DoesGraphSupportImpureFunctions(GetGraph()))	{		bIsPureGet = true;	}	if (!bIsPureGet)	{		FEdGraphPinType PinType;		UProperty* VariableProperty = GetPropertyForVariable();		// We need the pin's type, to both see if it's an array and if it is of the correct types to remain an impure node		if (VariableProperty)		{			K2Schema->ConvertPropertyToPinType(GetPropertyForVariable(), PinType);		}		// If there is no property and we are given some old pins to look at, find the old value pin and use the type there		// This allows nodes to be pasted into other BPs without access to the property		else if(InOldPinsPtr)		{			// find old variable pin and use the type.			const FString PinName = GetVarNameString();			for(auto Iter = InOldPinsPtr->CreateConstIterator(); Iter; ++Iter)			{				if(const UEdGraphPin* Pin = *Iter)				{					if(PinName == Pin->PinName)					{						PinType = Pin->PinType;						break;					}				}			}		}		if (IsValidTypeForNonPure(PinType))		{			// Input - Execution Pin			CreatePin(EGPD_Input, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Execute);			// Output - Execution Pins			UEdGraphPin* ValidPin = CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Then);			ValidPin->PinFriendlyName = LOCTEXT("Valid", "Is Valid");			UEdGraphPin* InvalidPin = CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Else);			InvalidPin->PinFriendlyName = LOCTEXT("Invalid", "Is Not Valid");		}		else		{			bIsPureGet = true;		}	}}

void UK2Node_VariableSetRef::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Input, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Execute);	CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Then);	CreatePin(EGPD_Input, K2Schema->PC_Wildcard, TEXT(""), NULL, false, true, TargetVarPinName);	UEdGraphPin* ValuePin = CreatePin(EGPD_Input, K2Schema->PC_Wildcard, TEXT(""), NULL, false, false, VarValuePinName);}

void UK2Node_GetArrayItem::AllocateDefaultPins(){	// Create the output pin	CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Wildcard, TEXT(""), NULL, true, false, TEXT("Array"));	UEdGraphPin* IndexPin = CreatePin(EGPD_Input, UEdGraphSchema_K2::PC_Int, TEXT(""), NULL, false, false, TEXT("Dimension 1"));	GetDefault<UEdGraphSchema_K2>()->SetPinDefaultValueBasedOnType(IndexPin);	// Create the input pins to create the arrays from	CreatePin(EGPD_Output, UEdGraphSchema_K2::PC_Wildcard, TEXT(""), NULL, false, true, TEXT("Output"));}

void UK2Node_PureAssignmentStatement::AllocateDefaultPins(){	const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Input, Schema->PC_Wildcard, TEXT(""), NULL, false, false, VariablePinName);	CreatePin(EGPD_Input, Schema->PC_Wildcard, TEXT(""), NULL, false, false, ValuePinName);	CreatePin(EGPD_Output, Schema->PC_Wildcard, TEXT(""), NULL, false, false, OutputPinName);	Super::AllocateDefaultPins();}

void UGameplayTagsK2Node_MultiCompareGameplayTagContainerSingleTags::AddPinToSwitchNode(){	FString PinName = GetUniquePinName();	FString InPin = TEXT("Tag") + PinName;	FString OutPin = PinName + TEXT(" True");	PinNames.Add(FName(*PinName));	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Input, K2Schema->PC_Struct, TEXT(""), FGameplayTag::StaticStruct(), false, true, InPin);	CreatePin(EGPD_Output, K2Schema->PC_Boolean, TEXT(""), NULL, false, false, OutPin);}

void UK2Node_MultiGate::ReallocatePinsDuringReconstruction(TArray<UEdGraphPin*>& OldPins){	Super::ReallocatePinsDuringReconstruction(OldPins);	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Input, K2Schema->PC_Exec, TEXT(""), NULL, false, false, TEXT("Reset"));	CreatePin(EGPD_Input, K2Schema->PC_Boolean, TEXT(""), NULL, false, false, TEXT("IsRandom"));	CreatePin(EGPD_Input, K2Schema->PC_Boolean, TEXT(""), NULL, false, false, TEXT("Loop"));	UEdGraphPin* IndexPin = CreatePin(EGPD_Input, K2Schema->PC_Int, TEXT(""), NULL, false, false, TEXT("StartIndex"));	IndexPin->DefaultValue = TEXT("-1");	IndexPin->AutogeneratedDefaultValue = TEXT("-1");}

void UK2Node_Knot::AllocateDefaultPins(){	const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();	const FString InputPinName(TEXT("InputPin"));	const FString OutputPinName(TEXT("OutputPin"));	UEdGraphPin* MyInputPin = CreatePin(EGPD_Input, Schema->PC_Wildcard, FString(), nullptr, /*bIsArray=*/ false, /*bIsReference=*/ false, InputPinName);	MyInputPin->bDefaultValueIsIgnored = true;	UEdGraphPin* MyOutputPin = CreatePin(EGPD_Output, Schema->PC_Wildcard, FString(), nullptr, /*bIsArray=*/ false, /*bIsReference=*/ false, OutputPinName);}

void UK2Node_MakeArray::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	// Create the output pin	CreatePin(EGPD_Output, K2Schema->PC_Wildcard, TEXT(""), NULL, true, false, *OutputPinName);	// Create the input pins to create the arrays from	for (int32 i = 0; i < NumInputs; ++i)	{		CreatePin(EGPD_Input, K2Schema->PC_Wildcard, TEXT(""), NULL, false, false, *FString::Printf(TEXT("[%d]"), i));	}}

void UK2Node_EnumEquality::AllocateDefaultPins(){	const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();	// Create the return value pin	CreatePin(EGPD_Output, Schema->PC_Boolean, TEXT(""), NULL, false, false, Schema->PN_ReturnValue);	// Create the input pins	CreatePin(EGPD_Input, Schema->PC_Wildcard, TEXT(""), NULL, false, false, "A");	CreatePin(EGPD_Input, Schema->PC_Wildcard, TEXT(""), NULL, false, false, "B");	Super::AllocateDefaultPins();}

void UK2Node_EnumLiteral::AllocateDefaultPins(){	check(Enum);	const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();	auto InputPin = CreatePin(EGPD_Input, Schema->PC_Byte, TEXT(""), Enum, false, false, GetEnumInputPinName());	Schema->SetPinDefaultValueBasedOnType(InputPin);	CreatePin(EGPD_Output, Schema->PC_Byte, TEXT(""), Enum, false, false, Schema->PN_ReturnValue);	Super::AllocateDefaultPins();}

void UK2Node_FormatText::AllocateDefaultPins(){	Super::AllocateDefaultPins();	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CachedFormatPin = CreatePin(EGPD_Input, K2Schema->PC_Text, TEXT(""), NULL, false, false, FFormatTextNodeHelper::GetFormatPinName());	CreatePin(EGPD_Output, K2Schema->PC_Text, TEXT(""), NULL, false, false, TEXT("Result"));	for(auto It = PinNames.CreateConstIterator(); It; ++It)	{		CreatePin(EGPD_Input, K2Schema->PC_Text, TEXT(""), NULL, false, false, It->ToString());	}}

void UGameplayTagsK2Node_MultiCompareGameplayTagContainerSingleTags::AllocateDefaultPins(){	PinNames.Empty();	for (int32 Index = 0; Index < NumberOfPins; ++Index)	{		AddPinToSwitchNode();	}	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Input, K2Schema->PC_Struct, TEXT(""), FGameplayTagContainer::StaticStruct(), false, true, TEXT("Gameplay Tag Container"));	UEnum* EnumClass = FindObject<UEnum>(NULL, TEXT("GameplayTags.EGameplayTagMatchType"));	CreatePin(EGPD_Input, K2Schema->PC_Byte, TEXT(""), EnumClass, false, false, TEXT("Tag Container Match Type"));	CreatePin(EGPD_Input, K2Schema->PC_Byte, TEXT(""), EnumClass, false, false, TEXT("Tags Match Type"));}

void UK2Node_ForEachElementInEnum::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	check(K2Schema);	CreatePin(EGPD_Input, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Execute);	CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Then);	if (Enum)	{		CreatePin(EGPD_Output, K2Schema->PC_Byte, TEXT(""), Enum, false, false, EnumOuputPinName);		CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, InsideLoopPinName);	}}

void UK2Node_Event::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	CreatePin(EGPD_Output, K2Schema->PC_Delegate, TEXT(""), NULL, false, false, DelegateOutputName);	CreatePin(EGPD_Output, K2Schema->PC_Exec, TEXT(""), NULL, false, false, K2Schema->PN_Then);	const UFunction* Function = FindEventSignatureFunction();	if (Function != NULL)	{		CreatePinsForFunctionEntryExit(Function, /*bIsFunctionEntry=*/ true);	}	Super::AllocateDefaultPins();}

UEdGraphPin* UK2Node_Message::CreateSelfPin(const UFunction* Function){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	UEdGraphPin* SelfPin = CreatePin(EGPD_Input, K2Schema->PC_Object, TEXT(""), UObject::StaticClass(), false, false, K2Schema->PN_Self);	SelfPin->bDefaultValueIsIgnored = true;	return SelfPin;}

void UMaterialGraphNode::CreateInputPins(){	const TArray<FExpressionInput*> ExpressionInputs = MaterialExpression->GetInputs();	for (int32 Index = 0; Index < ExpressionInputs.Num() ; ++Index)	{		FExpressionInput* Input = ExpressionInputs[Index];		FString InputName = MaterialExpression->GetInputName(Index);		// Shorten long expression input names.		if ( !FCString::Stricmp( *InputName, TEXT("Coordinates") ) )		{			InputName = TEXT("UVs");		}		else if ( !FCString::Stricmp( *InputName, TEXT("TextureObject") ) )		{			InputName = TEXT("Tex");		}		else if ( !FCString::Stricmp( *InputName, TEXT("Input") ) )		{			InputName = TEXT("");		}		else if ( !FCString::Stricmp( *InputName, TEXT("Exponent") ) )		{			InputName = TEXT("Exp");		}		else if ( !FCString::Stricmp( *InputName, TEXT("AGreaterThanB") ) )		{			InputName = TEXT("A>=B");		}		else if ( !FCString::Stricmp( *InputName, TEXT("AEqualsB") ) )		{			InputName = TEXT("A==B");		}		else if ( !FCString::Stricmp( *InputName, TEXT("ALessThanB") ) )		{			InputName = TEXT("A<B");		}		else if ( !FCString::Stricmp( *InputName, TEXT("MipLevel") ) )		{			InputName = TEXT("Level");		}		else if ( !FCString::Stricmp( *InputName, TEXT("MipBias") ) )		{			InputName = TEXT("Bias");		}		const UMaterialGraphSchema* Schema = CastChecked<UMaterialGraphSchema>(GetSchema());		FString PinCategory = MaterialExpression->IsInputConnectionRequired(Index) ? Schema->PC_Required : Schema->PC_Optional;		FString PinSubCategory = TEXT("");		UEdGraphPin* NewPin = CreatePin(EGPD_Input, PinCategory, PinSubCategory, NULL, /*bIsArray=*/ false, /*bIsReference=*/ false, InputName);		if (NewPin->PinName.IsEmpty())		{			// Makes sure pin has a name for lookup purposes but user will never see it			NewPin->PinName = CreateUniquePinName(TEXT("Input"));			NewPin->PinFriendlyName = TEXT(" ");		}	}}