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

void UAnimGraphNode_StateMachineBase::DestroyNode(){	UEdGraph* GraphToRemove = EditorStateMachineGraph;	EditorStateMachineGraph = NULL;	Super::DestroyNode();	if (GraphToRemove)	{		UBlueprint* Blueprint = GetBlueprint();		GraphToRemove->Modify();		FBlueprintEditorUtils::RemoveGraph(Blueprint, GraphToRemove, EGraphRemoveFlags::Recompile);	}}

bool UK2Node_MacroInstance::HasExternalDependencies(TArray<class UStruct*>* OptionalOutput) const{	UBlueprint* OtherBlueprint = MacroGraphReference.GetBlueprint();	const bool bResult = OtherBlueprint && (OtherBlueprint != GetBlueprint());	if (bResult && OptionalOutput)	{		if (UClass* OtherClass = *OtherBlueprint->GeneratedClass)		{			OptionalOutput->AddUnique(OtherClass);		}	}	const bool bSuperResult = Super::HasExternalDependencies(OptionalOutput);	return bSuperResult || bResult;}

ShipBattle::ShipBattle(const Hex& hex, const Game& game, const GroupVec& oldGroups) : Battle(hex, game, oldGroups){	VERIFY_MODEL(m_groups.size() >= 2);	bool missiles = false;	for (auto& group : m_groups)	{		group.hasMissiles = GetBlueprint(game, group.shipType, group.invader).HasMissiles();		missiles |= group.hasMissiles;	}	m_turn.groupIndex = missiles ? FindFirstMissileGroup() : 0;	m_turn.phase = missiles ? BattlePhase::Missile : BattlePhase::Main;}

USCS_Node* USimpleConstructionScript::CreateNode(UClass* NewComponentClass, FName NewComponentVariableName){	UBlueprint* Blueprint = GetBlueprint();	check(Blueprint);	check(NewComponentClass->IsChildOf(UActorComponent::StaticClass()));	ensure(Cast<UBlueprintGeneratedClass>(Blueprint->GeneratedClass));	// note that naming logic is duplicated in CreateNodeAndRenameComponent:	NewComponentVariableName = GenerateNewComponentName(NewComponentClass, NewComponentVariableName);	UActorComponent* NewComponentTemplate = NewObject<UActorComponent>(Blueprint->GeneratedClass, NewComponentClass, *(NewComponentVariableName.GetPlainNameString() + FGuid::NewGuid().ToString() ), RF_ArchetypeObject|RF_Transactional|RF_Public);	return CreateNodeImpl(NewComponentTemplate, NewComponentVariableName);}

UActorComponent* UK2Node_AddComponent::GetTemplateFromNode() const{	UBlueprint* BlueprintObj = GetBlueprint();	// Find the template name input pin, to get the name from	UEdGraphPin* TemplateNamePin = GetTemplateNamePin();	if (TemplateNamePin)	{		const FString& TemplateName = TemplateNamePin->DefaultValue;		return BlueprintObj->FindTemplateByName(FName(*TemplateName));	}	return NULL;}

bool UK2Node_CallFunctionOnMember::HasExternalDependencies(TArray<class UStruct*>* OptionalOutput) const{	const UBlueprint* SourceBlueprint = GetBlueprint();	auto VarProperty = MemberVariableToCallOn.ResolveMember<UProperty>(GetBlueprintClassFromNode());	UClass* SourceClass = VarProperty ? VarProperty->GetOwnerClass() : nullptr;	const bool bResult = (SourceClass != NULL) && (SourceClass->ClassGeneratedBy != SourceBlueprint);	if (bResult && OptionalOutput)	{		OptionalOutput->AddUnique(SourceClass);	}	const bool bSuperResult = Super::HasExternalDependencies(OptionalOutput);	return bSuperResult || bResult;}

void UK2Node_Timeline::DestroyNode(){	UBlueprint* Blueprint = GetBlueprint();	check(Blueprint);	UTimelineTemplate* Timeline = Blueprint->FindTimelineTemplateByVariableName(TimelineName);	if(Timeline)	{		FBlueprintEditorUtils::RemoveTimeline(Blueprint, Timeline, true);		// Move template object out of the way so that we can potentially create a timeline with the same name either through a paste or a new timeline action		Timeline->Rename(NULL, GetTransientPackage(), (Blueprint->bIsRegeneratingOnLoad ? REN_ForceNoResetLoaders : REN_None));	}	Super::DestroyNode();}

void UK2Node_MakeArray::PropagatePinType(){	const UEdGraphPin* OutputPin = GetOutputPin();	if (OutputPin)	{		UClass const* CallingContext = NULL;		if (UBlueprint const* Blueprint = GetBlueprint())		{			CallingContext = Blueprint->GeneratedClass;			if (CallingContext == NULL)			{				CallingContext = Blueprint->ParentClass;			}		}		const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();		bool bWantRefresh = false;		// Propagate pin type info (except for array info!) to pins with dependent types		for (TArray<UEdGraphPin*>::TIterator it(Pins); it; ++it)		{			UEdGraphPin* CurrentPin = *it;			if (CurrentPin != OutputPin)			{				bWantRefresh = true;				CurrentPin->PinType.PinCategory = OutputPin->PinType.PinCategory;				CurrentPin->PinType.PinSubCategory = OutputPin->PinType.PinSubCategory;				CurrentPin->PinType.PinSubCategoryObject = OutputPin->PinType.PinSubCategoryObject;				// Verify that all previous connections to this pin are still valid with the new type				for (TArray<UEdGraphPin*>::TIterator ConnectionIt(CurrentPin->LinkedTo); ConnectionIt; ++ConnectionIt)				{					UEdGraphPin* ConnectedPin = *ConnectionIt;					if (!Schema->ArePinsCompatible(CurrentPin, ConnectedPin, CallingContext))					{						CurrentPin->BreakLinkTo(ConnectedPin);					}				}			}		}		// If we have a valid graph we should refresh it now to refelect any changes we made		if( (bWantRefresh == true ) && ( OutputPin->GetOwningNode() != NULL ) && ( OutputPin->GetOwningNode()->GetGraph() != NULL ) )		{			OutputPin->GetOwningNode()->GetGraph()->NotifyGraphChanged();		}	}}

uint32 UK2Node_CustomEvent::GetNetFlags() const{	uint32 NetFlags = (FunctionFlags & FUNC_NetFuncFlags);	if (IsOverride())	{		UBlueprint* Blueprint = GetBlueprint();		check(Blueprint != NULL);		UFunction* ParentFunction = FindField<UFunction>(Blueprint->ParentClass, CustomFunctionName);		check(ParentFunction != NULL);		// inherited net flags take precedence 		NetFlags = (ParentFunction->FunctionFlags & FUNC_NetFuncFlags);	}	return NetFlags;}

void UK2Node_AddComponent::DestroyNode(){	// See if this node has a template	UActorComponent* Template = GetTemplateFromNode();	if (Template != NULL)	{		// Get the blueprint so we can remove it from it		UBlueprint* BlueprintObj = GetBlueprint();		// remove it		BlueprintObj->Modify();		BlueprintObj->ComponentTemplates.Remove(Template);	}	Super::DestroyNode();}

    static TSharedRef<FApplicationMode> OnModeCreated(const FName ModeName, TSharedRef<FApplicationMode> InMode)    {        if (ModeName == FBlueprintEditorApplicationModes::BlueprintComponentsMode)        {            //@TODO: Bit of a lie - push GetBlueprint up, or pass in editor!            auto LieMode = StaticCastSharedRef<FComponentsEditorModeOverride>(InMode);            UBlueprint* BP = LieMode->GetBlueprint();            if(	BP )            {                FLiveEditorManager::Get().InjectNewBlueprintEditor( LieMode->GetBlueprintEditor() );            }        }        return InMode;    }

void UK2Node_MacroInstance::NodeConnectionListChanged(){	Super::NodeConnectionListChanged();	if (bReconstructNode)	{		ReconstructNode();		UBlueprint* const Blueprint = GetBlueprint();		if (Blueprint && !Blueprint->bBeingCompiled)		{			FBlueprintEditorUtils::MarkBlueprintAsModified(Blueprint);			Blueprint->BroadcastChanged();		}	}}

void UAnimGraphNode_BlendListByEnum::ExposeEnumElementAsPin(FName EnumElementName){	if (!VisibleEnumEntries.Contains(EnumElementName))	{		FScopedTransaction Transaction( LOCTEXT("ExposeElement", "ExposeElement") );		Modify();		VisibleEnumEntries.Add(EnumElementName);		Node.AddPose();			ReconstructNode();		FBlueprintEditorUtils::MarkBlueprintAsStructurallyModified(GetBlueprint());	}}

SHierarchyView::~SHierarchyView(){	UWidgetBlueprint* Blueprint = GetBlueprint();	if ( Blueprint )	{		Blueprint->OnChanged().RemoveAll(this);		Blueprint->OnCompiled().RemoveAll(this);	}	if ( BlueprintEditor.IsValid() )	{		BlueprintEditor.Pin()->OnSelectedWidgetsChanged.RemoveAll(this);	}	GEditor->OnObjectsReplaced().RemoveAll(this);}

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

void UK2Node_GetArrayItem::PropagatePinType(FEdGraphPinType& InType){	UClass const* CallingContext = NULL;	if (UBlueprint const* Blueprint = GetBlueprint())	{		CallingContext = Blueprint->GeneratedClass;		if (CallingContext == NULL)		{			CallingContext = Blueprint->ParentClass;		}	}	const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();	UEdGraphPin* ArrayPin = Pins[0];	UEdGraphPin* ResultPin = Pins[2];	ArrayPin->PinType = InType;	ArrayPin->PinType.bIsArray = true;	ArrayPin->PinType.bIsReference = false;	ResultPin->PinType = InType;	ResultPin->PinType.bIsArray = false;	ResultPin->PinType.bIsReference = !(ResultPin->PinType.PinCategory == Schema->PC_Object || ResultPin->PinType.PinCategory == Schema->PC_Class || ResultPin->PinType.PinCategory == Schema->PC_Asset || ResultPin->PinType.PinCategory == Schema->PC_AssetClass || ResultPin->PinType.PinCategory == Schema->PC_Interface);	ResultPin->PinType.bIsConst = false;	// Verify that all previous connections to this pin are still valid with the new type	for (TArray<UEdGraphPin*>::TIterator ConnectionIt(ArrayPin->LinkedTo); ConnectionIt; ++ConnectionIt)	{		UEdGraphPin* ConnectedPin = *ConnectionIt;		if (!Schema->ArePinsCompatible(ArrayPin, ConnectedPin, CallingContext))		{			ArrayPin->BreakLinkTo(ConnectedPin);		}	}	// Verify that all previous connections to this pin are still valid with the new type	for (TArray<UEdGraphPin*>::TIterator ConnectionIt(ResultPin->LinkedTo); ConnectionIt; ++ConnectionIt)	{		UEdGraphPin* ConnectedPin = *ConnectionIt;		if (!Schema->ArePinsCompatible(ResultPin, ConnectedPin, CallingContext))		{			ResultPin->BreakLinkTo(ConnectedPin);		}	}}

bool UK2Node_Variable::CanPasteHere(const UEdGraph* TargetGraph) const{	// Do not allow pasting of variables in BPs that cannot handle them	if ( FBlueprintEditorUtils::FindBlueprintForGraph(TargetGraph)->BlueprintType == BPTYPE_MacroLibrary && VariableReference.IsSelfContext() )	{		// Self variables must be from a parent class to the macro BP		if(UProperty* Property = VariableReference.ResolveMember<UProperty>(GetBlueprintClassFromNode()))		{			const UClass* CurrentClass = GetBlueprint()->SkeletonGeneratedClass->GetAuthoritativeClass();			const UClass* PropertyClass = Property->GetOwnerClass()->GetAuthoritativeClass();			const bool bIsChildOf = CurrentClass->IsChildOf(PropertyClass);			return bIsChildOf;		}		return false;	}	return true;}

bool UK2Node_Variable::CreatePinForVariable(EEdGraphPinDirection Direction, FString InPinName/* = FString()*/){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	UProperty* VariableProperty = GetPropertyForVariable();	// favor the skeleton property if possible (in case the property type has 	// been changed, and not yet compiled).	if (!VariableReference.IsSelfContext())	{		UClass* VariableClass = VariableReference.GetMemberParentClass(GetBlueprint()->GeneratedClass);		if (UBlueprintGeneratedClass* BpClassOwner = Cast<UBlueprintGeneratedClass>(VariableClass))		{			// this variable could currently only be a part of some skeleton 			// class (the blueprint has not be compiled with it yet), so let's 			// check the skeleton class as well, see if we can pull pin data 			// from there...			UBlueprint* VariableBlueprint = CastChecked<UBlueprint>(BpClassOwner->ClassGeneratedBy, ECastCheckedType::NullAllowed);			if (VariableBlueprint)			{				if (UProperty* SkelProperty = FindField<UProperty>(VariableBlueprint->SkeletonGeneratedClass, VariableReference.GetMemberName()))				{					VariableProperty = SkelProperty;				}			}		}	}	if (VariableProperty != NULL)	{		const FString PinName = InPinName.IsEmpty()? GetVarNameString() : InPinName;		// Create the pin		UEdGraphPin* VariablePin = CreatePin(Direction, TEXT(""), TEXT(""), NULL, false, false, PinName);		K2Schema->ConvertPropertyToPinType(VariableProperty, /*out*/ VariablePin->PinType);		K2Schema->SetPinDefaultValueBasedOnType(VariablePin);	}	else	{		if (!VariableReference.IsLocalScope())		{			Message_Warn(*FString::Printf(TEXT("CreatePinForVariable: '%s' variable not found. Base class was probably changed."), *GetVarNameString()));		}		return false;	}	return true;}

FString UK2Node_AddComponent::GetDocumentationExcerptName() const{	UEdGraphPin* TemplateNamePin = GetTemplateNamePin();	UBlueprint* Blueprint = GetBlueprint();	if ((TemplateNamePin != NULL) && (Blueprint != NULL))	{		FString TemplateName = TemplateNamePin->DefaultValue;		UActorComponent* SourceTemplate = Blueprint->FindTemplateByName(FName(*TemplateName));		if (SourceTemplate != NULL)		{			return SourceTemplate->GetClass()->GetName();		}	}	return Super::GetDocumentationExcerptName();}

void UK2Node_AddComponent::DestroyNode(){	// See if this node has a template	UActorComponent* Template = GetTemplateFromNode();	if (Template != NULL)	{		// Save current template state - this is needed in order to ensure that we restore to the correct Outer in the case of a compile prior to the undo/redo action.		Template->Modify();		// Get the blueprint so we can remove it from it		UBlueprint* BlueprintObj = GetBlueprint();		// remove it		BlueprintObj->Modify();		BlueprintObj->ComponentTemplates.Remove(Template);	}	Super::DestroyNode();}

void UAnimGraphNode_LayeredBoneBlend::RemovePinFromBlendByFilter(UEdGraphPin* Pin){	FScopedTransaction Transaction( NSLOCTEXT("A3Nodes", "RemovePinFromBlend", "RemovePinFromBlendByFilter") );	Modify();	UProperty* AssociatedProperty;	int32 ArrayIndex;	GetPinAssociatedProperty(GetFNodeType(), Pin, /*out*/ AssociatedProperty, /*out*/ ArrayIndex);	if (ArrayIndex != INDEX_NONE)	{		//@TODO: ANIMREFACTOR: Need to handle moving pins below up correctly		// setting up removed pins info 		RemovedPinArrayIndex = ArrayIndex;		Node.RemovePose(ArrayIndex);		ReconstructNode();		FBlueprintEditorUtils::MarkBlueprintAsStructurallyModified(GetBlueprint());	}}

void UK2Node::DestroyPinList(TArray<UEdGraphPin*>& InPins){	UBlueprint* Blueprint = GetBlueprint();	// Throw away the original pins	for (UEdGraphPin* Pin : InPins)	{		Pin->Modify();		Pin->BreakAllPinLinks();		// just in case this pin was set to watch (don't want to save PinWatches with dead pins)		Blueprint->PinWatches.Remove(Pin);#if 0		UEdGraphNode::ReturnPinToPool(Pin);#else		Pin->Rename(NULL, GetTransientPackage(), (Blueprint->bIsRegeneratingOnLoad ? REN_ForceNoResetLoaders : REN_None));		Pin->RemoveFromRoot();		Pin->MarkPendingKill();#endif	}}

bool UK2Node_Event::IsCosmeticTickEvent() const{	// Special case for EventTick/ReceiveTick that is conditionally executed by a separate bool rather than function flag.	static const FName EventTickName(TEXT("ReceiveTick"));	if (EventSignatureName == EventTickName)	{		const UBlueprint* Blueprint = GetBlueprint();		if (Blueprint)		{			UClass* BPClass = Blueprint->GeneratedClass;			const AActor* DefaultActor = BPClass ? Cast<const AActor>(BPClass->GetDefaultObject()) : NULL;			if (DefaultActor && !DefaultActor->AllowReceiveTickEventOnDedicatedServer())			{				return true;			}		}	}	return false;}

void UK2Node_SpawnActorFromClass::AllocateDefaultPins(){	const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>();	// Add execution pins	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 required add the world context pin	if (GetBlueprint()->ParentClass->HasMetaData(FBlueprintMetadata::MD_ShowWorldContextPin))	{		CreatePin(EGPD_Input, K2Schema->PC_Object, TEXT(""), UObject::StaticClass(), false, false, FK2Node_SpawnActorFromClassHelper::WorldContextPinName);	}	// Add blueprint pin	UEdGraphPin* ClassPin = CreatePin(EGPD_Input, K2Schema->PC_Class, TEXT(""), AActor::StaticClass(), false, false, FK2Node_SpawnActorFromClassHelper::ClassPinName);	K2Schema->ConstructBasicPinTooltip(*ClassPin, LOCTEXT("ClassPinDescription", "The Actor class you want to spawn"), ClassPin->PinToolTip);	// Transform pin	UScriptStruct* TransformStruct = TBaseStructure<FTransform>::Get();	UEdGraphPin* TransformPin = CreatePin(EGPD_Input, K2Schema->PC_Struct, TEXT(""), TransformStruct, false, false, FK2Node_SpawnActorFromClassHelper::SpawnTransformPinName);	K2Schema->ConstructBasicPinTooltip(*TransformPin, LOCTEXT("TransformPinDescription", "The transform to spawn the Actor with"), TransformPin->PinToolTip);	// bNoCollisionFail pin	UEdGraphPin* NoCollisionFailPin = CreatePin(EGPD_Input, K2Schema->PC_Boolean, TEXT(""), NULL, false, false, FK2Node_SpawnActorFromClassHelper::NoCollisionFailPinName);	K2Schema->ConstructBasicPinTooltip(*NoCollisionFailPin, LOCTEXT("NoCollisionFailPinDescription", "Determines if the Actor should be spawned when the location is blocked by a collision"), NoCollisionFailPin->PinToolTip);	UEdGraphPin* OwnerPin = CreatePin(EGPD_Input, K2Schema->PC_Object, TEXT(""), AActor::StaticClass(),/*bIsArray =*/false, /*bIsReference =*/false, FK2Node_SpawnActorFromClassHelper::OwnerPinName);	OwnerPin->bAdvancedView = true;	if (ENodeAdvancedPins::NoPins == AdvancedPinDisplay)	{		AdvancedPinDisplay = ENodeAdvancedPins::Hidden;	}	K2Schema->ConstructBasicPinTooltip(*OwnerPin, LOCTEXT("OwnerPinDescription", "Can be left empty; primarily used for replication (bNetUseOwnerRelevancy and bOnlyRelevantToOwner), or visibility (PrimitiveComponent's bOwnerNoSee/bOnlyOwnerSee)"), OwnerPin->PinToolTip);	// Result pin	UEdGraphPin* ResultPin = CreatePin(EGPD_Output, K2Schema->PC_Object, TEXT(""), AActor::StaticClass(), false, false, K2Schema->PN_ReturnValue);	K2Schema->ConstructBasicPinTooltip(*ResultPin, LOCTEXT("ResultPinDescription", "The spawned Actor"), ResultPin->PinToolTip);	Super::AllocateDefaultPins();}

void UAnimGraphNode_BlendListByInt::RemovePinFromBlendList(UEdGraphPin* Pin){	FScopedTransaction Transaction( NSLOCTEXT("A3Nodes", "RemoveBlendListPin", "RemoveBlendListPin") );	Modify();	UProperty* AssociatedProperty;	int32 ArrayIndex;	GetPinAssociatedProperty(GetFNodeType(), Pin, /*out*/ AssociatedProperty, /*out*/ ArrayIndex);	if (ArrayIndex != INDEX_NONE)	{		//@TODO: ANIMREFACTOR: Need to handle moving pins below up correctly		// setting up removed pins info		RemovedPinArrayIndex = ArrayIndex;		Node.RemovePose(ArrayIndex);		// removes the selected pin and related properties in reconstructNode()		// @TODO: Considering passing "RemovedPinArrayIndex" to ReconstructNode as the argument		ReconstructNode();		FBlueprintEditorUtils::MarkBlueprintAsStructurallyModified(GetBlueprint());	}}