EdGraphPin.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 "UObject/ObjectPtr.h"
#include "Misc/Guid.h"
#include "UObject/Class.h"
#include "UObject/WeakObjectPtr.h"
#include "Templates/Casts.h"
#include "EdGraph/EdGraphNode.h"
#include "EdGraphPin.generated.h"
 
class UEdGraphPin;
enum class EPinResolveType : uint8;
 
enum class EPinInsertPosition
{
    Before,
    After,
};
 
USTRUCT()
struct FSimpleMemberReference
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    TObjectPtr<UObject> MemberParent;
 
    UPROPERTY()
    FName MemberName;
 
    UPROPERTY()
    FGuid MemberGuid;
 
    FSimpleMemberReference() : MemberParent(nullptr) {}
 
    void Reset()
    {
        operator=(FSimpleMemberReference());
    }
 
    bool operator==(const FSimpleMemberReference& Other) const
    {
        return (MemberParent == Other.MemberParent)
            && (MemberName == Other.MemberName)
            && (MemberGuid == Other.MemberGuid);
    }
 
    /* For backwards compatibility (when MemberParent used to exclusively be a class) */
    UClass* GetMemberParentClass() const
    {
        return Cast<UClass>(MemberParent);
    }
};
 
inline FArchive& operator<<(FArchive& Ar, FSimpleMemberReference& Data)
{
    Ar << Data.MemberParent;
    Ar << Data.MemberName;
    Ar << Data.MemberGuid;
    return Ar;
}
 
USTRUCT(BlueprintType)
struct FEdGraphPinType
{
    GENERATED_USTRUCT_BODY()
 
    
    UPROPERTY()
    FName PinCategory;
 
    UPROPERTY()
    FName PinSubCategory;
 
    UPROPERTY()
    TWeakObjectPtr<UObject> PinSubCategoryObject;
 
    UPROPERTY()
    FSimpleMemberReference PinSubCategoryMemberReference;
 
    UPROPERTY()
    FEdGraphTerminalType PinValueType;
 
    UPROPERTY()
    EPinContainerType ContainerType;
 
private:
    UPROPERTY()
    uint8 bIsArray_DEPRECATED:1;
 
public:
    UPROPERTY()
    uint8 bIsReference:1;
 
    UPROPERTY()
    uint8 bIsConst:1;
 
    UPROPERTY()
    uint8 bIsWeakPointer:1;
 
    UPROPERTY()
    uint8 bIsUObjectWrapper:1;
 
    UPROPERTY()
    uint8 bSerializeAsSinglePrecisionFloat:1;
 
    inline bool IsContainer() const { return (ContainerType != EPinContainerType::None); }
    inline bool IsArray() const { return (ContainerType == EPinContainerType::Array); }
    inline bool IsSet() const { return (ContainerType == EPinContainerType::Set); }
    inline bool IsMap() const { return (ContainerType == EPinContainerType::Map); }
 
public:
    FEdGraphPinType() 
        : PinSubCategoryObject(nullptr)
        , ContainerType(EPinContainerType::None)
        , bIsArray_DEPRECATED(false)
        , bIsReference(false)
        , bIsConst(false)
        , bIsWeakPointer(false)
        , bIsUObjectWrapper(false)
        , bSerializeAsSinglePrecisionFloat(false)
    {
    }
 
    FEdGraphPinType(FName InPinCategory, FName InPinSubCategory, UObject* InPinSubCategoryObject, EPinContainerType InPinContainerType, bool bInIsReference, const FEdGraphTerminalType& InValueTerminalType )
        : PinCategory(InPinCategory)
        , PinSubCategory(InPinSubCategory)
        , PinSubCategoryObject(InPinSubCategoryObject)
        , PinValueType(InValueTerminalType)
        , ContainerType(InPinContainerType)
        , bIsArray_DEPRECATED(false)
        , bIsReference(bInIsReference)
        , bIsConst(false)
        , bIsWeakPointer(false)
        , bIsUObjectWrapper(false)
        , bSerializeAsSinglePrecisionFloat(false)
    {
    }
 
    bool operator == ( const FEdGraphPinType& Other ) const
    {
        return (PinCategory == Other.PinCategory)
            && (PinSubCategory == Other.PinSubCategory)
            && (PinSubCategoryObject == Other.PinSubCategoryObject)
            && (PinValueType == Other.PinValueType)
            && (ContainerType == Other.ContainerType)
            && (bIsReference == Other.bIsReference)
            && (bIsWeakPointer == Other.bIsWeakPointer)
            && (PinSubCategoryMemberReference == Other.PinSubCategoryMemberReference)
            && (bIsConst == Other.bIsConst);
    }
    bool operator != ( const FEdGraphPinType& Other ) const
    {
        return !(*this == Other);
    }
 
    void ResetToDefaults()
    {
        PinCategory = NAME_None;
        PinSubCategory = NAME_None;
        PinSubCategoryObject = nullptr;
        PinValueType = FEdGraphTerminalType();
        PinSubCategoryMemberReference.Reset();
        ContainerType = EPinContainerType::None;
        bIsReference = false;
        bIsWeakPointer = false;
        bIsUObjectWrapper = false;
        bSerializeAsSinglePrecisionFloat = false;
        bIsConst = false;
    }
 
    ENGINE_API bool Serialize(FArchive& Ar);
    ENGINE_API void PostSerialize(const FArchive& Ar);
#if WITH_EDITORONLY_DATA
    ENGINE_API static void DeclareCustomVersions(FArchive& Ar);
#endif
 
    static ENGINE_API FEdGraphPinType GetPinTypeForTerminalType( const FEdGraphTerminalType& TerminalType );
    static ENGINE_API FEdGraphPinType GetTerminalTypeForContainer( const FEdGraphPinType& ContainerType );
 
    static EPinContainerType ToPinContainerType(const bool bInIsArray, const bool bInIsSet, const bool bInIsMap)
    {
        EPinContainerType ContainerType = EPinContainerType::None;
 
        if (bInIsArray)
        {
            check(!bInIsSet && !bInIsMap);
            ContainerType = EPinContainerType::Array;
        }
        else if (bInIsSet)
        {
            check(!bInIsMap);
            ContainerType = EPinContainerType::Set;
        }
        else if (bInIsMap)
        {
            ContainerType = EPinContainerType::Map;
        }
 
        return ContainerType;
    }
 
};
 
template<>
struct TStructOpsTypeTraits< FEdGraphPinType > : public TStructOpsTypeTraitsBase2< FEdGraphPinType >
{
    enum 
    {
        WithSerializer = true,
        WithPostSerialize = true
    };
    static constexpr EPropertyObjectReferenceType WithSerializerObjectReferences = EPropertyObjectReferenceType::Strong;
};
 
UENUM()
enum EBlueprintPinStyleType : int
{
    BPST_Original UMETA(DisplayName="Circles, Grid, Diamond"),
    BPST_VariantA UMETA(DisplayName="Directional Circles")
};
 
USTRUCT()
struct FEdGraphPinReference
{
    GENERATED_USTRUCT_BODY()
 
    
    FEdGraphPinReference() : OwningNode(nullptr) {}
    FEdGraphPinReference(UEdGraphPin* InPin) : OwningNode(nullptr) { SetPin(InPin); }
    FEdGraphPinReference(const UEdGraphPin* InPin) : OwningNode(nullptr) { SetPin(InPin); }
 
    ENGINE_API void SetPin(const UEdGraphPin* NewPin);
 
    ENGINE_API UEdGraphPin* Get() const;
 
    friend uint32 GetTypeHash(const FEdGraphPinReference& EdGraphPinReference)
    {
        return GetTypeHash(EdGraphPinReference.PinId);
    }
 
    bool operator==(const FEdGraphPinReference& Other) const
    {
        return PinId == Other.PinId && OwningNode == Other.OwningNode;
    }
 
private:
    UPROPERTY()
    TWeakObjectPtr<UEdGraphNode> OwningNode;
 
    UPROPERTY()
    FGuid PinId;
};
 
#if WITH_EDITORONLY_DATA
struct FSnappedEdGraphPin
{
    UEdGraphPin* ParentPin = nullptr;
    UEdGraphPin* ChildPin = nullptr;
 
    friend auto operator<=>(const FSnappedEdGraphPin&, const FSnappedEdGraphPin&) = default;
};
#endif
 
enum class EPinResolveType : uint8;
 
class UEdGraphPin
{
    friend struct FEdGraphPinReference;
private:
    UEdGraphNode* OwningNode;
 
 
public:
    FGuid PinId;
 
    FName PinName;
 
    int32 SourceIndex;
 
    TEnumAsByte<enum EEdGraphPinDirection> Direction;
 
#if WITH_EDITORONLY_DATA
    // ONLY PUT BITFIELD PROPERTIES AFTER THIS TO ENSURE GOOD MEMORY ALIGNMENT
 
    uint8 bHidden:1;
 
    uint8 bNotConnectable:1;
 
    uint8 bDefaultValueIsReadOnly:1;
 
    uint8 bDefaultValueIsIgnored:1;
    
    uint8 bAdvancedView:1;
 
    uint8 bDeprecated:1;
 
    uint8 bDisplayAsMutableRef:1;
 
    uint8 bAllowFriendlyName:1;
 
    uint8 bOrphanedPin:1;
 
    bool ShouldSavePinIfOrphaned() const { return bSavePinIfOrphaned; }
    ENGINE_API void SetSavePinIfOrphaned(bool bShouldSave);
 
private:
    uint8 bSavePinIfOrphaned:1;
 
public:
    uint8 bUseBackwardsCompatForEmptyAutogeneratedValue:1;
 
private:
    uint8 bHasSnappedChild:1;
    
    uint8 bHasSnappedParent:1;
public:
#endif // WITH_EDITORONLY_DATA
 
    uint8 bWasTrashed:1;    
#if WITH_EDITORONLY_DATA
    FText PinFriendlyName;
 
    FString DeprecationMessage;
#endif
 
    FString PinToolTip;
 
    FEdGraphPinType PinType;
 
    FString DefaultValue;
 
    FString AutogeneratedDefaultValue;
 
    TObjectPtr<class UObject> DefaultObject;
 
    FText DefaultTextValue;
 
    TArray<UEdGraphPin*> LinkedTo;
 
    TArray<UEdGraphPin*> SubPins;
 
    UEdGraphPin* ParentPin;
 
    UEdGraphPin* ReferencePassThroughConnection;
 
#if WITH_EDITORONLY_DATA
    FGuid PersistentGuid;
#endif
 
public:
 
    ENGINE_API static UEdGraphPin* CreatePin(UEdGraphNode* InOwningNode);
 
    ENGINE_API void MakeLinkTo(UEdGraphPin* ToPin, bool bAlwaysMarkDirty = true);
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void SetSnappedChild(UEdGraphPin* SnappedChild);
    ENGINE_API void ClearSnappedChild();
    ENGINE_API bool IsSnapped() const;
    ENGINE_API bool IsSnappedParentOf(const UEdGraphNode* Node) const;
    ENGINE_API FSnappedEdGraphPin GetSnapDescription() const;
    ENGINE_API UEdGraphNode* GetSnappedChildNode() const;
    ENGINE_API UEdGraphPin* GetSnappedChildPin() const;
    ENGINE_API UEdGraphPin* GetSnappedParentPin() const;
#endif
 
    ENGINE_API void BreakLinkTo(UEdGraphPin* ToPin, bool bAlwaysMarkDirty = true);
 
    ENGINE_API void BreakAllPinLinks(bool bNotifyNodes = false, bool bAlwaysMarkDirty = true);
 
private:
    enum class ETransferPersistentDataMode : uint8
    {
        Move,
        Copy
    };
 
    template<class T>
    static void TransferPersistentDataFromOldPin(UEdGraphPin& DestPin, T& SourcePin, const ETransferPersistentDataMode TransferMode);
 
public:
    ENGINE_API void MovePersistentDataFromOldPin(UEdGraphPin& SourcePin);
 
    ENGINE_API void CopyPersistentDataFromOldPin(const UEdGraphPin& SourcePin);
 
    ENGINE_API void AssignByRefPassThroughConnection(UEdGraphPin* InTargetPin);
 
    inline class UEdGraphNode* GetOwningNode() const { check(OwningNode); return OwningNode; }
    inline class UEdGraphNode* GetOwningNodeUnchecked() const { return OwningNode; }
 
    ENGINE_API const class UEdGraphSchema* GetSchema() const;
 
    ENGINE_API bool HasAnyConnections() const;
 
    static EEdGraphPinDirection GetComplementaryDirection(EEdGraphPinDirection InDirection)
    {
        return (InDirection == EGPD_Input) ? EGPD_Output : EGPD_Input;
    }
 
    void SafeSetHidden(bool bIsHidden)
    {
#if WITH_EDITORONLY_DATA
         if (SubPins.Num() == 0)
         {
             bHidden = bIsHidden;
         }
#endif // WITH_EDITORONLY_DATA
    }
 
    ENGINE_API FString GetDefaultAsString() const;
 
    ENGINE_API bool IsDefaultAsStringEmpty() const;
 
    ENGINE_API FText GetDefaultAsText() const;
 
    ENGINE_API bool DoesDefaultValueMatchAutogenerated() const;
 
#if WITH_EDITORONLY_DATA
    ENGINE_API FText GetDisplayName() const;
#endif // WITH_EDITORONLY_DATA
 
    const FString GetLinkInfoString( const FString& InFunctionName, const FString& InInfoData, const UEdGraphPin* InToPin ) const;
 
    void ResetDefaultValue()
    {
        DefaultValue.Empty();
        DefaultObject = nullptr;
        DefaultTextValue = FText::GetEmpty();
    }
 
    void ResetToDefaults()
    {
        check(LinkedTo.Num() == 0);
 
        PinType.ResetToDefaults();
 
        PinName = NAME_None;
        SourceIndex = INDEX_NONE;
#if WITH_EDITORONLY_DATA
        PinFriendlyName = FText::GetEmpty();
        DeprecationMessage.Reset();
#endif // WITH_EDITORONLY_DATA
        AutogeneratedDefaultValue.Reset();
        ResetDefaultValue();
 
#if WITH_EDITORONLY_DATA
        bHidden = false;
        bNotConnectable = false;
        bDefaultValueIsReadOnly = false;
        bDefaultValueIsIgnored = false;
        bDeprecated = false;
        bOrphanedPin = false;
        bSavePinIfOrphaned = true;
        bAllowFriendlyName = true;
#endif // WITH_EDITORONLY_DATA
    }
 
    void AddStructReferencedObjects(class FReferenceCollector& Collector);
 
    static void SerializeAsOwningNode(FArchive& Ar, TArray<UEdGraphPin*>& ArrayRef);
#if WITH_EDITORONLY_DATA
    static void DeclarePinCustomVersions(FArchive& Ar);
#endif
 
    ENGINE_API bool Modify(bool bAlwaysMarkDirty = true);
 
    ENGINE_API void SetOwningNode(UEdGraphNode* NewOwningNode);
 
    ENGINE_API void MarkAsGarbage();
 
    inline bool WasTrashed() const { return bWasTrashed; }
 
    ENGINE_API static UEdGraphPin* CreatePinFromDeprecatedPin(class UEdGraphPin_Deprecated* DeprecatedPin);
    ENGINE_API static UEdGraphPin* FindPinCreatedFromDeprecatedPin(class UEdGraphPin_Deprecated* DeprecatedPin);
 
    ENGINE_API bool ExportTextItem(FString& ValueStr, int32 PortFlags) const;
    ENGINE_API bool ImportTextItem(const TCHAR*& Buffer, int32 PortFlags, class UObject* Parent, FOutputDevice* ErrorText);
 
    const FString GetName() const { return PinName.ToString(); }
    const FName GetFName() const { return PinName; }
    UEdGraphNode* GetOuter() const { return GetOwningNodeUnchecked(); }
    bool IsPendingKill() const {    return bWasTrashed; }
    ENGINE_API FEdGraphTerminalType GetPrimaryTerminalType() const;
 
    ENGINE_API static void ShutdownVerification();
 
    ENGINE_API static void Purge();
 
    ~UEdGraphPin();
 
    ENGINE_API static void ResolveAllPinReferences();
 
    ENGINE_API static bool AreOrphanPinsEnabled();
 
    ENGINE_API static void SanitizePinsPostUndoRedo();
private:
    UEdGraphPin(UEdGraphNode* InOwningNode, const FGuid& PinGuid);
 
    void InitFromDeprecatedPin(class UEdGraphPin_Deprecated* DeprecatedPin);
 
    void DestroyImpl(bool bClearLinks);
 
    bool Serialize(FArchive& Ar);
 
    // Helper functions
    static void ConvertConnectedGhostNodesToRealNodes(UEdGraphNode* InNode, bool bAlwaysMarkDirty = true);
    static void ResolveReferencesToPin(UEdGraphPin* Pin, bool bStrictValidation = true);
    static void SerializePinArray(FArchive& Ar, TArray<UEdGraphPin*>& ArrayRef, UEdGraphPin* RequestingPin, EPinResolveType ResolveType);
    static bool SerializePin(FArchive& Ar, UEdGraphPin*& PinRef, int32 ArrayIdx, UEdGraphPin* RequestingPin, EPinResolveType ResolveType, TArray<UEdGraphPin*>& OldPins);
    static FString ExportText_PinReference(const UEdGraphPin* Pin);
    static FString ExportText_PinArray(const TArray<UEdGraphPin*>& PinArray);
    static bool ImportText_PinArray(const TCHAR*& Buffer, TArray<UEdGraphPin*>& ArrayRef, UEdGraphPin* RequestingPin, EPinResolveType ResolveType);
    
#if WITH_EDITORONLY_DATA
    static FString bHasSnappedChildName;
    static FString bHasSnappedParentName;
#endif
};
 
UCLASS(MinimalAPI)
class UEdGraphPin_Deprecated : public UObject
{
    GENERATED_UCLASS_BODY()
 
    
    UPROPERTY()
    FString PinName;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    FText PinFriendlyName;
#endif
 
    UPROPERTY()
    FString PinToolTip;
 
    UPROPERTY()
    TEnumAsByte<enum EEdGraphPinDirection> Direction;
 
    UPROPERTY()
    struct FEdGraphPinType PinType;
 
    UPROPERTY()
    FString DefaultValue;
 
    UPROPERTY()
    FString AutogeneratedDefaultValue;
 
    UPROPERTY()
    TObjectPtr<class UObject> DefaultObject;
 
    UPROPERTY()
    FText DefaultTextValue;
 
    UPROPERTY()
    TArray<TObjectPtr<class UEdGraphPin_Deprecated>> LinkedTo;
 
    UPROPERTY()
    TArray<TObjectPtr<class UEdGraphPin_Deprecated>> SubPins;
 
    UPROPERTY()
    TObjectPtr<UEdGraphPin_Deprecated> ParentPin;
 
    UPROPERTY()
    TObjectPtr<UEdGraphPin_Deprecated> ReferencePassThroughConnection;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    uint32 bHidden:1;
 
    UPROPERTY()
    uint32 bNotConnectable:1;
 
    UPROPERTY()
    uint32 bDefaultValueIsReadOnly:1;
 
    UPROPERTY()
    uint32 bDefaultValueIsIgnored:1;
 
    UPROPERTY()
    uint32 bAdvancedView:1;
 
    UPROPERTY(transient)
    uint32 bDisplayAsMutableRef : 1;
 
    UPROPERTY()
    FGuid PersistentGuid;
#endif // WITH_EDITORONLY_DATA
 
public:
    // UObject interface
    virtual bool IsSafeForRootSet() const override { return false; }
    // End UObject interface
 
    void FixupDefaultValue();
};