EdGraph.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/Class.h"
#include "Templates/SubclassOf.h"
#include "Templates/Casts.h"
#include "EdGraph/EdGraphNode.h"
#include "BlueprintUtilities.h"
#include "EdGraph.generated.h"
 
class UEdGraph;
struct FEdGraphEditAction;
struct FPropertyChangedEvent;
 
USTRUCT()
struct FGraphReference
{
    GENERATED_USTRUCT_BODY()
protected:
    // Reference to the actual graph
    UPROPERTY()
    mutable TObjectPtr<class UEdGraph> MacroGraph;
 
    // The blueprint the graph is contained within
    UPROPERTY()
    TObjectPtr<class UBlueprint> GraphBlueprint;
 
    // The graph GUID so we can refind it if it has been renamed
    UPROPERTY()
    FGuid GraphGuid;
 
public:
    FGraphReference()
        : MacroGraph(NULL)
        , GraphBlueprint(NULL)
    {
    }
 
    ENGINE_API void PostSerialize(const FArchive& Ar);
 
    class UBlueprint* GetBlueprint() const
    {
        return GraphBlueprint;
    }
 
#if WITH_EDITORONLY_DATA
    ENGINE_API void SetGraph(UEdGraph* InGraph);
    ENGINE_API UEdGraph* GetGraph() const;
#endif
};
 
template<>
struct TStructOpsTypeTraits<FGraphReference> : public TStructOpsTypeTraitsBase2<FGraphReference>
{
    enum 
    {
        WithPostSerialize = true,
    };
};
 
UCLASS(MinimalAPI)
class UEdGraph : public UObject
{
    GENERATED_UCLASS_BODY()
 
public:
 
    UPROPERTY()
    TSubclassOf<class UEdGraphSchema>  Schema;
 
    UPROPERTY()
    TArray<TObjectPtr<class UEdGraphNode>> Nodes;
 
    UPROPERTY()
    uint32 bEditable:1;
 
    UPROPERTY()
    uint32 bAllowDeletion:1;
 
    UPROPERTY()
    uint32 bAllowRenaming:1;
 
#if WITH_EDITORONLY_DATA
    UPROPERTY()
    TArray<TObjectPtr<class UEdGraph>> SubGraphs;
 
    UPROPERTY()
    FGuid GraphGuid;
 
    UPROPERTY()
    FGuid InterfaceGuid;
#endif // WITH_EDITORONLY_DATA
 
public:
    template <typename NodeType> friend struct FGraphNodeCreator;
 
    ENGINE_API const class UEdGraphSchema* GetSchema() const;
 
    ENGINE_API FDelegateHandle AddOnGraphChangedHandler( const FOnGraphChanged::FDelegate& InHandler );
 
    ENGINE_API void RemoveOnGraphChangedHandler( FDelegateHandle Handle );
 
    //~ Begin UObject interface
#if WITH_EDITORONLY_DATA
    ENGINE_API virtual void BuildSubobjectMapping(UObject* OtherObject, TMap<UObject*, UObject*>& ObjectMapping) const override;
    ENGINE_API virtual void Serialize(FStructuredArchiveRecord Record) override;
    ENGINE_API virtual void PostInitProperties() override;
    ENGINE_API virtual void PostLoad() override;
    //~ End UObject Interface
#endif
 
public:
 
    template <typename NodeClass>
    NodeClass* CreateIntermediateNode()
    {
        NodeClass* Node = (NodeClass*)CreateNode(NodeClass::StaticClass());
        FSetAsIntermediateNode SetAsIntermediate(Node);
        return Node;
    }
 
    ENGINE_API virtual void AddNode( UEdGraphNode* NodeToAdd, bool bUserAction = false, bool bSelectNewNode = true );
 
    ENGINE_API void SelectNodeSet(TSet<const UEdGraphNode*> NodeSelection, bool bFromUI = false);
 
    ENGINE_API bool RemoveNode( UEdGraphNode* NodeToRemove, bool bBreakAllLinks = true, bool bAlwaysMarkDirty = true );
 
    ENGINE_API virtual void NotifyGraphChanged();
 
    ENGINE_API void NotifyNodeChanged(const UEdGraphNode* Node);
 
    ENGINE_API void MoveNodesToAnotherGraph(UEdGraph* DestinationGraph, bool bIsLoading, bool bInIsCompiling);
 
    template<class MinRequiredType, class ArrayElementType>
    inline void GetNodesOfClassEx(TArray<ArrayElementType*>& OutNodes) const
    {
        for (int32 i = 0; i < Nodes.Num(); i++)
        {
            UEdGraphNode* Node = Nodes[i];
            if (MinRequiredType* TypedNode = Cast<MinRequiredType>(Node))
            {
                OutNodes.Add(TypedNode);
            }
        }
    }
 
    template<class MinRequiredType>
    inline void GetNodesOfClass(TArray<MinRequiredType*>& OutNodes) const
    {
        GetNodesOfClassEx<MinRequiredType, MinRequiredType>(OutNodes);
    }
 
    ENGINE_API void GetAllChildrenGraphs(TArray<UEdGraph*>& Graphs) const;
 
    static ENGINE_API UEdGraph* GetOuterGraph(UObject* Obj);
 
    ENGINE_API UE::Slate::FDeprecateVector2DResult GetGoodPlaceForNewNode();
 
#if WITH_EDITOR
    ENGINE_API void NotifyPreChange( const FString& PropertyName );
 
    ENGINE_API void NotifyPostChange( const FPropertyChangedEvent& PropertyChangedEvent, const FString& PropertyName );
 
    ENGINE_API FDelegateHandle AddPropertyChangedNotifier(const FOnPropertyChanged::FDelegate& InDelegate );
 
    ENGINE_API void RemovePropertyChangedNotifier(FDelegateHandle InHandle );
#endif
 
protected:
    ENGINE_API virtual void NotifyGraphChanged( const FEdGraphEditAction& Action );
 
    ENGINE_API UEdGraphNode* CreateNode( TSubclassOf<UEdGraphNode> NewNodeClass, bool bFromUI, bool bSelectNewNode );
 
    UEdGraphNode* CreateNode(TSubclassOf<UEdGraphNode> NewNodeClass, bool bSelectNewNode = true)
    {
        return CreateNode( NewNodeClass, false, bSelectNewNode );
    }
 
    UEdGraphNode* CreateUserInvokedNode(TSubclassOf<UEdGraphNode> NewNodeClass, bool bSelectNewNode = true)
    {
        return CreateNode(NewNodeClass, true, bSelectNewNode);
    }
 
private:
    FOnGraphChanged OnGraphChanged;
 
#if WITH_EDITORONLY_DATA
    FOnPropertyChanged      PropertyChangedNotifiers;
#endif
};
 
 
 
template <typename NodeType>
struct FGraphNodeCreator
{
public:
    FGraphNodeCreator(UEdGraph& InGraph)
        : Node(NULL), Graph(InGraph), bPlaced(false)
    {
    }
 
    NodeType* CreateNode(bool bSelectNewNode = true, TSubclassOf<NodeType> NodeClass = NodeType::StaticClass())
    {
        Node = (NodeType*)Graph.CreateNode(NodeClass, bSelectNewNode);
        return Node;
    } 
 
    NodeType* CreateUserInvokedNode(bool bSelectNewNode = true, TSubclassOf<NodeType> NodeClass = NodeType::StaticClass())
    {
        Node = (NodeType*)Graph.CreateUserInvokedNode(NodeClass, bSelectNewNode);
        return Node;
    }
 
    void Finalize()
    {
        check(!bPlaced);
        Node->CreateNewGuid();
        Node->PostPlacedNewNode();
        bPlaced = true;
        if (Node->Pins.Num() == 0)
        {
            Node->AllocateDefaultPins();
        }
    }
 
    ~FGraphNodeCreator()
    {
        checkf(bPlaced, TEXT("Created node was not finalized in a FGraphNodeCreator<%s>"), *NodeType::StaticClass()->GetName());
    }
 
private:
    // Hide copy and assignment operator
    FGraphNodeCreator(const FGraphNodeCreator& rhs);
    FGraphNodeCreator* operator= (const FGraphNodeCreator& rhs);
 
    NodeType* Node;
    UEdGraph& Graph;
    bool bPlaced;
};