EdGraphNode.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/Object.h"
#include "Misc/Guid.h"
#include "UObject/WeakObjectPtr.h"
#include "Types/SlateVector2.h"
#include "EdGraphNode.generated.h"
 
class INameValidatorInterface;
class SGraphNode;
class SWidget;
class UBlueprint;
class UEdGraph;
class UEdGraphNode;
class UEdGraphPin;
class UEdGraphSchema;
struct FEdGraphPinType;
struct FPropertyChangedEvent;
struct FSlateIcon;
struct FDiffResults;
struct FDiffSingleResult;
 
class FPropertyLocalizationDataGatherer;
enum class EPropertyLocalizationGathererTextFlags : uint8;
 
USTRUCT()
struct FEdGraphTerminalType
{
    GENERATED_USTRUCT_BODY()
 
    FEdGraphTerminalType()
        : TerminalCategory()
        , TerminalSubCategory()
        , TerminalSubCategoryObject(nullptr)
        , bTerminalIsConst(false)
        , bTerminalIsWeakPointer(false)
        , bTerminalIsUObjectWrapper(false)
    {
    }
 
    UPROPERTY()
    FName TerminalCategory;
 
    UPROPERTY()
    FName TerminalSubCategory;
 
    UPROPERTY()
    TWeakObjectPtr<UObject> TerminalSubCategoryObject;
 
    UPROPERTY()
    bool bTerminalIsConst;
 
    UPROPERTY()
    bool bTerminalIsWeakPointer;
 
    UPROPERTY()
    bool bTerminalIsUObjectWrapper;
 
    static ENGINE_API FEdGraphTerminalType FromPinType(const FEdGraphPinType& PinType);
 
    friend FArchive& operator<<(FArchive& Ar, FEdGraphTerminalType& P);
 
    friend inline bool operator!= (const FEdGraphTerminalType& A, const FEdGraphTerminalType& B)
    {
        return A.TerminalCategory != B.TerminalCategory
            || A.TerminalSubCategory != B.TerminalSubCategory
            || A.TerminalSubCategoryObject != B.TerminalSubCategoryObject
            || A.bTerminalIsConst != B.bTerminalIsConst
            || A.bTerminalIsWeakPointer != B.bTerminalIsWeakPointer;
    }
 
    friend inline bool operator==(const FEdGraphTerminalType& A, const FEdGraphTerminalType& B)
    {
        return !(A != B);
    }
};
 
UENUM()
enum EEdGraphPinDirection : int
{
    EGPD_Input,
    EGPD_Output,
    EGPD_MAX,
};
 
inline const TCHAR* const LexToString(const EEdGraphPinDirection State)
{
    switch (State)
    {
    case EEdGraphPinDirection::EGPD_Input:
        return TEXT("Input");
    case EEdGraphPinDirection::EGPD_Output:
        return TEXT("Output");
    case EEdGraphPinDirection::EGPD_MAX:
    default:
        break;
    }
 
    checkf(false, TEXT("Missing EEdGraphPinDirection Type: %d"), static_cast<const int32>(State));
    return TEXT("");
}
 
UENUM()
enum class EPinContainerType : uint8
{
    None,
    Array,
    Set,
    Map
};
 
UENUM()
namespace ENodeTitleType
{
    enum Type : int
    {
        FullTitle,
        ListView,
        EditableTitle,
        MenuTitle,
 
        MAX_TitleTypes,
    };
}
 
UENUM()
namespace ENodeAdvancedPins
{
    enum Type : int
    {
        NoPins,
        Shown,
        Hidden
    };
}
 
UENUM()
enum class ENodeEnabledState : uint8
{
    Enabled,
    Disabled,
    DevelopmentOnly
};
 
inline const TCHAR* const LexToString(const ENodeEnabledState State)
{
    switch (State)
    {
    case ENodeEnabledState::Enabled:
        return TEXT("Enabled");
    case ENodeEnabledState::Disabled:
        return TEXT("Disabled");
    case ENodeEnabledState::DevelopmentOnly:
        return TEXT("DevelopmentOnly");
    default:
        break;
    }
 
    checkf(false, TEXT("Missing ENodeEnabledState Type: %d"), static_cast<const int32>(State));
    return TEXT("");
}
 
enum class ESaveOrphanPinMode : uint8
{
    SaveNone,
    SaveAll,
    SaveAllButExec
};
 
struct FNodeMetadata
{
    static ENGINE_API const FName DefaultGraphNode;
private: 
    FNodeMetadata() {}
};
 
UCLASS(MinimalAPI)
class UGraphNodeContextMenuContext : public UObject
{
    GENERATED_BODY()
 
public:
 
    ENGINE_API UGraphNodeContextMenuContext();
 
    ENGINE_API void Init(const UEdGraph* InGraph, const UEdGraphNode* InNode, const UEdGraphPin* InPin, bool bInDebuggingMode);
 
    UPROPERTY()
    TObjectPtr<const UBlueprint> Blueprint;
 
    UPROPERTY()
    TObjectPtr<const UEdGraph> Graph;
 
    UPROPERTY()
    TObjectPtr<const UEdGraphNode> Node;
 
    const UEdGraphPin* Pin;
 
    UPROPERTY()
    bool bIsDebugging;
};
 
enum class EEdGraphNodeDeprecationType
{
    NodeTypeIsDeprecated,
    NodeHasDeprecatedReference
};
 
enum class EEdGraphNodeDeprecationMessageType
{
    None,
    Note,
    Warning
};
 
struct FEdGraphNodeDeprecationResponse
{
    EEdGraphNodeDeprecationMessageType MessageType = EEdGraphNodeDeprecationMessageType::None;
 
    FText MessageText;
};
 
enum class EGetFindReferenceSearchStringFlags : int8
{
    None = 0,
    Legacy = 1 << 0,
    UseSearchSyntax = 1 << 1,
};
 
ENUM_CLASS_FLAGS(EGetFindReferenceSearchStringFlags);
 
UCLASS(MinimalAPI)
class UEdGraphNode : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
    TArray<UEdGraphPin*> Pins;
 
    UPROPERTY()
    TArray<TObjectPtr<class UEdGraphPin_Deprecated>> DeprecatedPins;
 
    UPROPERTY()
    int32 NodePosX;
 
    UPROPERTY()
    int32 NodePosY;
 
    UPROPERTY()
    int32 NodeWidth;
 
    UPROPERTY()
    int32 NodeHeight;
 
    UPROPERTY()
    TEnumAsByte<ENodeAdvancedPins::Type> AdvancedPinDisplay;
 
private:
    UPROPERTY()
    ENodeEnabledState EnabledState;
 
protected:
    ESaveOrphanPinMode OrphanedPinSaveMode;
 
public:
    uint8 bDisableOrphanPinSaving:1;
 
private:
    UPROPERTY()
    uint8 bDisplayAsDisabled:1;
 
    UPROPERTY()
    uint8 bUserSetEnabledState:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bIsNodeEnabled_DEPRECATED:1;
 
public:
 
    UPROPERTY()
    uint8 bCanResizeNode:1;
 
#endif // WITH_EDITORONLY_DATA
 
private:
    UPROPERTY()
    uint8 bIsIntermediateNode : 1;
 
#if WITH_EDITORONLY_DATA
    uint8 bUnrelated : 1;
 
#endif
 
public:
 
    UPROPERTY()
    uint8 bHasCompilerMessage:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint8 bCommentBubblePinned : 1;
 
    UPROPERTY()
    uint8 bCommentBubbleVisible : 1;
 
    UPROPERTY(Transient)
    uint8 bCommentBubbleMakeVisible : 1;
 
    UPROPERTY()
    uint8 bCanRenameNode:1;
 
    UPROPERTY(Transient)
    FText NodeUpgradeMessage;
#endif // WITH_EDITORONLY_DATA
 
    UPROPERTY()
    FString NodeComment;
 
    UPROPERTY()
    int32 ErrorType;
    
    UPROPERTY()
    FString ErrorMsg;
    
    UPROPERTY()
    FGuid NodeGuid;
 
public:
    bool IsNodeEnabled() const
    {
        return (EnabledState == ENodeEnabledState::Enabled) || ((EnabledState == ENodeEnabledState::DevelopmentOnly) && IsInDevelopmentMode());
    }
 
    ENGINE_API virtual bool GetCanRenameNode() const;
 
    ENodeEnabledState GetDesiredEnabledState() const
    {
        return EnabledState;
    }
 
    void SetEnabledState(ENodeEnabledState NewState, bool bUserAction = true)
    {
        EnabledState = NewState;
        bUserSetEnabledState = bUserAction;
    }
 
    void SetForceDisplayAsDisabled(const bool bInNewDisplayState)
    {
        bDisplayAsDisabled = bInNewDisplayState;
    }
 
    bool IsDisplayAsDisabledForced() const
    {
        return bDisplayAsDisabled;
    }
 
    bool HasUserSetTheEnabledState() const
    {
        return bUserSetEnabledState;
    }
 
#if WITH_EDITOR
    inline void SetNodeUnrelated(bool bNodeUnrelated)
    {
        bUnrelated = bNodeUnrelated;
    }
 
    inline bool IsNodeUnrelated() const
    {
        return bUnrelated;
    }
#endif
 
    ENGINE_API virtual bool IsInDevelopmentMode() const;
 
    ENGINE_API bool IsAutomaticallyPlacedGhostNode() const;
 
    ENGINE_API void MakeAutomaticallyPlacedGhostNode();
 
    // UObject interface
    ENGINE_API virtual void Serialize(FArchive& Ar) override;
#if WITH_EDITORONLY_DATA
    static ENGINE_API void DeclareCustomVersions(FArchive& Ar, const UClass* SpecificSubclass);
#endif
    // End of UObject interface
 
#if WITH_EDITOR
 
private:
    static ENGINE_API TArray<UEdGraphPin*> PooledPins;
 
public:
    // UObject interface
    static ENGINE_API void AddReferencedObjects(UObject* InThis, FReferenceCollector& Collector);
    ENGINE_API virtual void PreSave(FObjectPreSaveContext ObjectSaveContext) override;
    ENGINE_API virtual void PostLoad() override;
    ENGINE_API virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override;
    ENGINE_API virtual void PostEditUndo() override;
    ENGINE_API virtual void ExportCustomProperties(FOutputDevice& Out, uint32 Indent) override;
    ENGINE_API virtual void ImportCustomProperties(const TCHAR* SourceText, FFeedbackContext* Warn) override;
    ENGINE_API virtual void BeginDestroy() override;
    // End of UObject interface
 
    // Helper conversions for the editor which typically expects the Node positions and sizes in floats instead of int32
    float GetWidth() const { return static_cast<float>(NodeWidth); }
    void SetWidth(float InWidth) { NodeWidth = UE::LWC::FloatToIntCastChecked<int32>(InWidth); }
    float GetHeight() const { return static_cast<float>(NodeHeight); }
    void SetHeight(float InHeight) { NodeHeight = UE::LWC::FloatToIntCastChecked<int32>(InHeight); }
    float GetNodePosX() const { return static_cast<float>(NodePosX); }
    void SetNodePosX(float InX) { NodePosX = UE::LWC::FloatToIntCastChecked<int32>(InX); }
    float GetNodePosY() const { return static_cast<float>(NodePosY); }
    void SetNodePosY(float InY) { NodePosY = UE::LWC::FloatToIntCastChecked<int32>(InY); }
    FVector2f GetSize() const { return FVector2f(GetWidth(), GetHeight()); }
    void SetSize(const FVector2f& InSize) { SetWidth(InSize.X); SetHeight(InSize.Y); }
    FVector2f GetPosition() const { return FVector2f(GetNodePosX(), GetNodePosY()); }
    void SetPosition(const FVector2f& InPosition) { SetNodePosX(InPosition.X); SetNodePosY(InPosition.Y); }
 
    TWeakPtr<SGraphNode> DEPRECATED_NodeWidget;
 
    const TArray<UEdGraphPin*>& GetAllPins() const { return Pins; }
 
    struct FNameParameterHelper
    {
        FNameParameterHelper(const FName InNameParameter) : NameParameter(InNameParameter) { }
        FNameParameterHelper(const FString& InNameParameter) : NameParameter(*InNameParameter) { }
        FNameParameterHelper(const TCHAR* InNameParameter) : NameParameter(InNameParameter) { }
 
        FName operator*() const { return NameParameter; }
 
    private:
        FName NameParameter;
    };
 
    struct FCreatePinParams
    {
        FCreatePinParams()
            : ContainerType(EPinContainerType::None)
            , bIsReference(false)
            , bIsConst(false)
            , Index(INDEX_NONE)
        {
        }
 
        ENGINE_API FCreatePinParams(const FEdGraphPinType& PinType);
 
        EPinContainerType ContainerType;
        bool bIsReference;
        bool bIsConst;
        int32 Index;
        FEdGraphTerminalType ValueTerminalType;
    };
 
    UEdGraphPin* CreatePin(EEdGraphPinDirection Dir, const FName PinCategory, const FName PinName, const FCreatePinParams& PinParams = FCreatePinParams())
    {
        return CreatePin(Dir, PinCategory, NAME_None, nullptr, PinName, PinParams);
    }
 
    UEdGraphPin* CreatePin(EEdGraphPinDirection Dir, const FName PinCategory, const FName PinSubCategory, const FName PinName, const FCreatePinParams& PinParams = FCreatePinParams())
    {
        return CreatePin(Dir, PinCategory, PinSubCategory, nullptr, PinName, PinParams);
    }
 
    UEdGraphPin* CreatePin(EEdGraphPinDirection Dir, const FName PinCategory, UObject* PinSubCategoryObject, const FName PinName, const FCreatePinParams& PinParams = FCreatePinParams())
    {
        return CreatePin(Dir, PinCategory, NAME_None, PinSubCategoryObject, PinName, PinParams);
    }
 
    ENGINE_API UEdGraphPin* CreatePin(EEdGraphPinDirection Dir, const FName PinCategory, const FName PinSubCategory, UObject* PinSubCategoryObject, const FName PinName, const FCreatePinParams& PinParams = FCreatePinParams());
 
    ENGINE_API UEdGraphPin* CreatePin(EEdGraphPinDirection Dir, const FEdGraphPinType& InPinType, const FName PinName, int32 Index = INDEX_NONE);
 
 
    //UE_DEPRECATED(4.19, "Remove when removing FString version. Exists just to resolve ambiguity")
    UEdGraphPin* CreatePin(EEdGraphPinDirection Dir, const FEdGraphPinType& InPinType, const TCHAR* PinName, int32 Index = INDEX_NONE)
    {
        return CreatePin(Dir, InPinType, FName(PinName), Index);
    }
 
    static ENGINE_API void DestroyPin(UEdGraphPin* Pin);
 
    ENGINE_API UEdGraphPin* FindPin(const FName PinName, const EEdGraphPinDirection Direction = EGPD_MAX) const;
 
    UEdGraphPin* FindPinChecked(const FName PinName, const EEdGraphPinDirection Direction = EGPD_MAX) const
    {
        UEdGraphPin* Result = FindPin(PinName, Direction);
        check(Result);
        return Result;
    }
 
    UEdGraphPin* FindPin(const FString& PinName, const EEdGraphPinDirection Direction = EGPD_MAX) const
    {
        return FindPin(*PinName, Direction);
    }
 
    UEdGraphPin* FindPinChecked(const FString& PinName, const EEdGraphPinDirection Direction = EGPD_MAX) const
    {
        return FindPinChecked(*PinName, Direction);
    }
 
    ENGINE_API UEdGraphPin* FindPin(const TCHAR* PinName, const EEdGraphPinDirection Direction = EGPD_MAX) const;
 
    UEdGraphPin* FindPinChecked(const TCHAR* PinName, const EEdGraphPinDirection Direction = EGPD_MAX) const
    {
        UEdGraphPin* Result = FindPin(PinName, Direction);
        check(Result);
        return Result;
    }
 
    ENGINE_API UEdGraphPin* FindPinById(const FGuid PinId) const;
 
    ENGINE_API UEdGraphPin* FindPinByIdChecked(const FGuid PinId) const;
 
    ENGINE_API UEdGraphPin* FindPinByPredicate(TFunctionRef<bool(UEdGraphPin* InPin)> InFunction) const;
    
    ENGINE_API bool RemovePin(UEdGraphPin* Pin);
 
    bool IsIntermediateNode() const { return bIsIntermediateNode; }
 
    virtual bool ShouldOverridePinNames() const { return false; }
 
    virtual bool CanSplitPin(const UEdGraphPin* Pin) const { return false; }
 
    virtual FText GetPinNameOverride(const UEdGraphPin& Pin) const { return FText::GetEmpty(); }
 
    ENGINE_API virtual FText GetPinDisplayName(const UEdGraphPin* Pin) const;
 
    ENGINE_API virtual void GetPinHoverText(const UEdGraphPin& Pin, FString& HoverTextOut) const;
 
    ENGINE_API int32 GetPinIndex(UEdGraphPin* Pin) const;
 
    ENGINE_API UEdGraphPin* GetPinAt(int32 Index) const;
 
    ENGINE_API UEdGraphPin* GetPinWithDirectionAt(int32 Index, EEdGraphPinDirection PinDirection) const;
 
    ENGINE_API void BreakAllNodeLinks(bool bAlwaysMarkDirty = true);
 
    ENGINE_API void SnapToGrid(uint32 GridSnapSize);
 
    void ClearCompilerMessage()
    {
        bHasCompilerMessage = false;
    }
 
    ENGINE_API virtual bool ShowVisualWarning() const;
 
    ENGINE_API virtual FText GetVisualWarningTooltipText() const;
 
    virtual FName CreateUniquePinName(FName SourcePinName) const
    {
        FName PinName(SourcePinName);
        
        int32 Index = 1;
        while (FindPin(PinName) != nullptr)
        {
            ++Index;
            PinName = *FString::Printf(TEXT("%s%d"),*SourcePinName.ToString(),Index);
        }
 
        return PinName;
    }
 
    ENGINE_API class UEdGraph* GetGraph() const;
 
    virtual TArray<UEdGraph*> GetSubGraphs() const { return TArray<UEdGraph*>(); }
 
    virtual void AllocateDefaultPins() {}
 
    ENGINE_API virtual void DestroyNode();
 
    virtual void ReconstructNode() {}
 
    ENGINE_API virtual void RemovePinAt(const int32 PinIndex, const EEdGraphPinDirection PinDirection);
 
    virtual void PrepareForCopying() {}
 
    virtual bool CanPasteHere(const UEdGraph* TargetGraph) const { return IsCompatibleWithGraph(TargetGraph); }
 
    virtual bool CanCreateUnderSpecifiedSchema(const UEdGraphSchema* Schema) const { return true; }
    
    ENGINE_API virtual bool IsCompatibleWithGraph(UEdGraph const* Graph) const;
 
    virtual void PostPasteNode() {}
 
    ENGINE_API virtual FText GetNodeTitle(ENodeTitleType::Type TitleType) const;
 
    UE_DEPRECATED(5.3, "GetFindReferenceSearchString() signature changed. Call the version with flags instead and override the _Impl version.")
    ENGINE_API virtual FString GetFindReferenceSearchString() const;
 
    ENGINE_API FString GetFindReferenceSearchString(EGetFindReferenceSearchStringFlags InFlags) const;
 
protected:
    virtual FString GetFindReferenceSearchString_Impl(EGetFindReferenceSearchStringFlags InFlags) const
    {
        PRAGMA_DISABLE_DEPRECATION_WARNINGS
        return GetFindReferenceSearchString();
        PRAGMA_ENABLE_DEPRECATION_WARNINGS
    }
 
public:
    ENGINE_API virtual FLinearColor GetNodeTitleColor() const;
 
    ENGINE_API virtual FLinearColor GetNodeCommentColor() const;
 
    ENGINE_API virtual FLinearColor GetNodeTitleTextColor() const;
 
    ENGINE_API virtual FLinearColor GetNodeBodyTintColor() const;
 
    ENGINE_API virtual FText GetTooltipText() const;
 
    ENGINE_API virtual FText GetKeywords() const;
     
    virtual FString GetDocumentationLink() const { return FString(); }
 
    ENGINE_API virtual FString GetDocumentationExcerptName() const;
 
    ENGINE_API virtual FSlateIcon GetIconAndTint(FLinearColor& OutColor) const;
 
    virtual bool ShowPaletteIconOnNode() const { return false; }
 
    virtual void AutowireNewNode(UEdGraphPin* FromPin) {}
 
    // A chance to initialize a new node; called just once when a new node is created, before AutowireNewNode or AllocateDefaultPins is called.
    // This method is not called when a node is reconstructed, etc...
    virtual void PostPlacedNewNode() {}
 
    virtual void PinDefaultValueChanged(UEdGraphPin* Pin) {}
 
    virtual void PinConnectionListChanged(UEdGraphPin* Pin) {}
 
    virtual void PinTypeChanged(UEdGraphPin* Pin) {}
 
    virtual void NodeConnectionListChanged() {}
 
    ENGINE_API const UEdGraphSchema* GetSchema() const;
 
    ENGINE_API virtual bool CanDuplicateNode() const;
 
    ENGINE_API virtual bool CanUserDeleteNode() const;
 
    virtual bool CanUserEditPinAdvancedViewFlag() const { return false; }
 
    ENGINE_API virtual FString GetDescriptiveCompiledName() const;
 
    UE_DEPRECATED(5.6, "Use the version of the function accepting FVector2f")
    virtual void ResizeNode(const FVector2D& NewSize) UE_SLATE_DEPRECATED_VECTOR_VIRTUAL_FUNCTION {}
    ENGINE_API virtual void ResizeNode(const FVector2f& NewSize);
 
    virtual bool HasExternalDependencies(TArray<class UStruct*>* OptionalOutput = nullptr) const { return false; }
 
    // Returns true if this node is deprecated
    ENGINE_API virtual bool IsDeprecated() const;
 
    // Returns true if this node references a deprecated type or member
    virtual bool HasDeprecatedReference() const { return false; }
 
    // Returns the response to use when reporting a deprecation
    ENGINE_API virtual FEdGraphNodeDeprecationResponse GetDeprecationResponse(EEdGraphNodeDeprecationType DeprecationType) const;
 
    // Returns the object that should be focused when double-clicking on this node
    // (the object can be an actor, which selects it in the world, or a node/graph/pin)
    ENGINE_API virtual UObject* GetJumpTargetForDoubleClick() const;
 
    // Returns true if it is possible to jump to the definition of this node (e.g., if it's a variable get or a function call)
    ENGINE_API virtual bool CanJumpToDefinition() const;
 
    // Jump to the definition of this node (should only be called if CanJumpToDefinition() return true)
    ENGINE_API virtual void JumpToDefinition() const;
 
    ENGINE_API void CreateNewGuid();
#if WITH_EDITORONLY_DATA
    ENGINE_API void CreateDeterministicGuid();
#endif
 
    virtual void GetNodeContextMenuActions(class UToolMenu* Menu, class UGraphNodeContextMenuContext* Context) const {}
 
    virtual bool IncludeParentNodeContextMenu() const { return false; }
 
    // Gives each visual node a chance to do final validation before it's node is harvested for use at runtime
    virtual void ValidateNodeDuringCompilation(class FCompilerResultsLog& MessageLog) const {}
 
    ENGINE_API virtual void FindDiffs(class UEdGraphNode* OtherNode, FDiffResults& Results);
 
    // This function gets menu items that can be created using this node given the specified context
    virtual void GetMenuEntries(struct FGraphContextMenuBuilder& ContextMenuBuilder) const {}
 
    // create a name validator for this node
    virtual TSharedPtr<class INameValidatorInterface> MakeNameValidator() const { return NULL; }
 
    // called when this node is being renamed after a successful name validation
    virtual void OnRenameNode(const FString& NewName) {}
 
    // called to replace this nodes comment text
    ENGINE_API virtual void OnUpdateCommentText( const FString& NewComment );
 
    // returns true if this node supports comment bubbles
    virtual bool SupportsCommentBubble() const { return true; }
 
    // called when the node's comment bubble is toggled
    virtual void OnCommentBubbleToggled( bool bInCommentBubbleVisible ) {}
 
    // called when a pin is removed
    virtual void OnPinRemoved( UEdGraphPin* InRemovedPin ) {}
 
    ENGINE_API virtual bool ShouldDrawNodeAsControlPointOnly(int32& OutInputPinIndex, int32& OutOutputPinIndex) const;
 
    ENGINE_API virtual void AddSearchMetaDataInfo(TArray<struct FSearchTagDataPair>& OutTaggedMetaData) const;
 
    ENGINE_API virtual void AddPinSearchMetaDataInfo(const UEdGraphPin* Pin, TArray<struct FSearchTagDataPair>& OutTaggedMetaData) const;
 
    virtual FString GetPinMetaData(FName InPinName, FName InKey) { return FString(); }
 
    virtual bool IsCompilerRelevant() const { return true; }
 
    virtual UEdGraphPin* GetPassThroughPin(const UEdGraphPin* FromPin) const { return nullptr; }
 
    virtual bool ShouldMergeChildGraphs() const { return true; }
 
    virtual TSharedPtr<SGraphNode> CreateVisualWidget() { return TSharedPtr<SGraphNode>(); }
 
    virtual TSharedPtr<SWidget> CreateNodeImage() const { return TSharedPtr<SWidget>(); }
 
    ENGINE_API void AddNodeUpgradeNote(FText InUpgradeNote);
 
    ENGINE_API bool ShouldMakeCommentBubbleVisible() const;
 
    ENGINE_API void SetMakeCommentBubbleVisible(bool MakeVisible);
 
    ENGINE_API void ForEachNodeDirectlyConnected(TFunctionRef<void(UEdGraphNode*)> Func);
    
    ENGINE_API void ForEachNodeDirectlyConnectedIf(TFunctionRef<bool(const UEdGraphPin* Pin)> Filter, TFunctionRef<void(UEdGraphNode*)> Func);
 
    ENGINE_API void ForEachNodeDirectlyConnectedToInputs(TFunctionRef<void(UEdGraphNode*)> Func);
 
    ENGINE_API void ForEachNodeDirectlyConnectedToOutputs(TFunctionRef<void(UEdGraphNode*)> Func);
    
    // snapping
    ENGINE_API bool IsSnappedToAny(const TSet<TObjectPtr<UObject>>& NodeSet ) const;
    ENGINE_API UEdGraphNode* GetRootSnappedParent(const TSet<TObjectPtr<UObject>>& NodeSet) const;
    // snapping
protected:
#if WITH_EDITORONLY_DATA
    friend void GatherGraphNodeForLocalization(const UObject* const Object, FPropertyLocalizationDataGatherer& PropertyLocalizationDataGatherer, const EPropertyLocalizationGathererTextFlags GatherTextFlags);
    ENGINE_API virtual void GatherForLocalization(FPropertyLocalizationDataGatherer& PropertyLocalizationDataGatherer, const EPropertyLocalizationGathererTextFlags GatherTextFlags) const;
#endif
 
    ENGINE_API virtual void DiffProperties(UClass* StructA, UClass* StructB, UObject* DataA, UObject* DataB, FDiffResults& Results, FDiffSingleResult& Diff) const;
 
    ENGINE_API virtual void DiffProperties(UStruct* StructA, UStruct* StructB, uint8* DataA, uint8* DataB, FDiffResults& Results, FDiffSingleResult& Diff) const;
 
    // Returns a human-friendly description of the property in the form "PropertyName: Value"
    ENGINE_API virtual FString GetPropertyNameAndValueForDiff(const FProperty* Prop, const uint8* PropertyAddr) const;
 
#endif // WITH_EDITOR
 
    friend struct FSetAsIntermediateNode;
};
 
struct FSetAsIntermediateNode
{
    friend UEdGraph;
 
private:
    FSetAsIntermediateNode(UEdGraphNode* GraphNode)
    {
        GraphNode->bIsIntermediateNode = true;
    }
};