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