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); }
bool UK2Node_Timeline::RenameTimeline (const FString& NewName) { UBlueprint* Blueprint = GetBlueprint(); check(Blueprint); FName NewTimelineName(*NewName); if (FBlueprintEditorUtils::RenameTimeline(Blueprint, TimelineName, NewTimelineName)) { // Clear off any existing error message now the timeline has been renamed this->ErrorMsg.Empty(); this->bHasCompilerMessage = false; return true; } return false; }
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); } } } } }
FText UK2Node_Timeline::GetNodeTitle(ENodeTitleType::Type TitleType) const { FText Title = FText::FromName(TimelineName); UBlueprint* Blueprint = GetBlueprint(); check(Blueprint != nullptr); UTimelineTemplate* Timeline = Blueprint->FindTimelineTemplateByVariableName(TimelineName); // if a node hasn't been spawned for this node yet, then lets title it // after what it will do (the name would be invalid anyways) if (Timeline == nullptr) { // if this node hasn't spawned a Title = LOCTEXT("NoTimelineTitle", "Add Timeline..."); } return Title; }
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); } } }
void UK2Node_CustomEvent::RenameCustomEventCloseToName(int32 StartIndex) { bool bFoundName = false; const FString& BaseName = CustomFunctionName.ToString(); for (int32 NameIndex = StartIndex; !bFoundName; ++NameIndex) { const FString NewName = FString::Printf(TEXT("%s_%d"), *BaseName, NameIndex); if (Rename(*NewName, GetOuter(), REN_Test)) { UBlueprint* Blueprint = GetBlueprint(); CustomFunctionName = FName(NewName.GetCharArray().GetData()); Rename(*NewName, GetOuter(), (Blueprint->bIsRegeneratingOnLoad ? REN_ForceNoResetLoaders : 0) | REN_DontCreateRedirectors); bFoundName = true; } } }
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; }
void UK2Node_Variable::CreatePinForSelf() { const UEdGraphSchema_K2* K2Schema = GetDefault<UEdGraphSchema_K2>(); // Create the self pin if (!K2Schema->FindSelfPin(*this, EGPD_Input)) { // Do not create a self pin for locally scoped variables if( !VariableReference.IsLocalScope() ) { bool bSelfTarget = VariableReference.IsSelfContext() && (ESelfContextInfo::NotSelfContext != SelfContextInfo); UClass* MemberParentClass = VariableReference.GetMemberParentClass(GetBlueprintClassFromNode()); UClass* TargetClass = MemberParentClass; // Self Target pins should always make the class be the owning class of the property, // so if the node is from a Macro Blueprint, it will hook up as self in any placed Blueprint if(bSelfTarget) { if(UProperty* Property = VariableReference.ResolveMember<UProperty>(GetBlueprintClassFromNode())) { TargetClass = Property->GetOwnerClass()->GetAuthoritativeClass(); } else { TargetClass = GetBlueprint()->SkeletonGeneratedClass->GetAuthoritativeClass(); } } else if(MemberParentClass && MemberParentClass->ClassGeneratedBy) { TargetClass = MemberParentClass->GetAuthoritativeClass(); } UEdGraphPin* TargetPin = CreatePin(EGPD_Input, K2Schema->PC_Object, TEXT(""), TargetClass, false, false, K2Schema->PN_Self); TargetPin->PinFriendlyName = LOCTEXT("Target", "Target"); if (bSelfTarget) { TargetPin->bHidden = true; // don't show in 'self' context } } } else { //@TODO: Check that the self pin types match! } }
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 USimpleConstructionScript::ValidateSceneRootNodes() { #if WITH_EDITOR UBlueprint* Blueprint = GetBlueprint(); if(DefaultSceneRootNode == nullptr) { // If applicable, create a default scene component node if(Blueprint != nullptr && FBlueprintEditorUtils::IsActorBased(Blueprint) && Blueprint->BlueprintType != BPTYPE_MacroLibrary) { DefaultSceneRootNode = CreateNode(USceneComponent::StaticClass(), USceneComponent::GetDefaultSceneRootVariableName()); CastChecked<USceneComponent>(DefaultSceneRootNode->ComponentTemplate)->bVisualizeComponent = true; } } if(DefaultSceneRootNode != nullptr) { // Get the current root component template const USceneComponent* RootComponentTemplate = GetSceneRootComponentTemplate(); // Add the default scene root back in if there are no other scene component nodes that can be used as root; otherwise, remove it if(RootComponentTemplate == nullptr && !RootNodes.Contains(DefaultSceneRootNode)) { RootNodes.Add(DefaultSceneRootNode); } else if(RootComponentTemplate != nullptr && RootNodes.Contains(DefaultSceneRootNode)) { RootNodes.Remove(DefaultSceneRootNode); // These shouldn't be set, but just in case... DefaultSceneRootNode->bIsParentComponentNative = false; DefaultSceneRootNode->ParentComponentOrVariableName = NAME_None; DefaultSceneRootNode->ParentComponentOwnerClassName = NAME_None; } } #endif // WITH_EDITOR }
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()); } }