// Copyright Epic Games, Inc. All Rights Reserved. #pragma once #include "CoreMinimal.h" #include "MetasoundAccessPtr.h" #include "MetasoundBuilderInterface.h" #include "MetasoundFrontend.h" #include "MetasoundFrontendDocument.h" #include "MetasoundFrontendDocumentAccessPtr.h" #include "MetasoundFrontendRegistries.h" #include "MetasoundGraph.h" /* Metasound Controllers and Handles provide a object oriented interface for manipulating Metasound Documents. * * Each controller interface is associated with a single Metasound entity such as * Document, Graph, Node, Input or Output. Access to these entities generally begins * with the DocumentController which provides access to Graphs. Graphs provide access * to Nodes and Nodes provide access to Inputs and Outputs. * * A "Handle" is simply a TSharedRef<> of a controller. * * In general, the workflow for editing a Metasound graph will be: * 1) Load or create a metasound asset. * 2) Call UMetaSound::GetDocumentHandle() to get a handle to the document for that asset. * * Typically the workflow for creating a Metasound subgraph will be * 1) Get a Metasound::Frontend::FGraphHandle (typically through the two steps described in the first paragraph) * 2) Build a FMetasoundFrontendClassMetadata struct with whatever name/author/description you want to give the subgraph, * 3) call Metasound::Frontend::FGraphHandle::CreateEmptySubgraphNode, which will return that subgraph as it as a FNodeHandle for that subgraph in the current graph. * 4) class Metasound::Frontend::FNodeHandle::AsGraph which provides access to edit the subgraphs internal structure as well as externally facing inputs and outputs. * * General note- these apis are NOT thread safe. * Make sure that any FDocumentHandle, FGraphHandle, FNodeHandle, FInputHandle and FOutputHandle that access similar data are called on the same thread. */ namespace Metasound { namespace Frontend { // Forward declare class IInputController; class IOutputController; class INodeController; class IGraphController; class IDocumentController; // Metasound Frontend Handles are all TSharedRefs of various Metasound Frontend Controllers. using FInputHandle = TSharedRef; using FConstInputHandle = TSharedRef; using FOutputHandle = TSharedRef; using FConstOutputHandle = TSharedRef; using FNodeHandle = TSharedRef; using FConstNodeHandle = TSharedRef; using FGraphHandle = TSharedRef; using FConstGraphHandle = TSharedRef; using FDocumentHandle = TSharedRef; using FConstDocumentHandle = TSharedRef; // Container holding various access pointers to the FMetasoundFrontendDocument struct FConstDocumentAccess { FConstVertexAccessPtr ConstVertex; FConstClassInputAccessPtr ConstClassInput; FConstClassOutputAccessPtr ConstClassOutput; FConstNodeAccessPtr ConstNode; FConstClassAccessPtr ConstClass; FConstGraphClassAccessPtr ConstGraphClass; FConstGraphAccessPtr ConstGraph; FConstDocumentAccessPtr ConstDocument; }; // Container holding various access pointers to the FMetasoundFrontendDocument struct FDocumentAccess : public FConstDocumentAccess { FVertexAccessPtr Vertex; FClassInputAccessPtr ClassInput; FClassOutputAccessPtr ClassOutput; FNodeAccessPtr Node; FClassAccessPtr Class; FGraphClassAccessPtr GraphClass; FGraphAccessPtr Graph; FDocumentAccessPtr Document; }; /** IDocumentAccessor describes an interface for various I*Controllers to interact with * each other without exposing that interface publicly or requiring friendship * between various controller implementation classes. */ class METASOUNDFRONTEND_API IDocumentAccessor { protected: /** Share access to FMetasoundFrontendDocument objects. * * Derived classes must implement this method. In the implementation, * derived classes should set the various TAccessPtrs on FDocumentAccess * to the TAccessPtrs held internal in the derived class. * * Sharing access simplifies operations involving multiple frontend controllers * by providing direct access to the FMetasoundFrontendDocument objects to be * edited. */ virtual FDocumentAccess ShareAccess() = 0; /** Share access to FMetasoundFrontendDocument objects. * * Derived classes must implement this method. In the implementation, * derived classes should set the various TAccessPtrs on FDocumentAccess * to the TAccessPtrs held internal in the derived class. * * Sharing access simplifies operations involving multiple frontend controllers * by providing direct access to the FMetasoundFrontendDocument objects to be * edited. */ virtual FConstDocumentAccess ShareAccess() const = 0; /** Returns the shared access from an IDocumentAccessor. */ static FDocumentAccess GetSharedAccess(IDocumentAccessor& InDocumentAccessor); /** Returns the shared access from an IDocumentAccessor. */ static FConstDocumentAccess GetSharedAccess(const IDocumentAccessor& InDocumentAccessor); }; /* An IOutputController provides methods for querying and manipulating a metasound output vertex. */ class METASOUNDFRONTEND_API IOutputController : public TSharedFromThis, public IDocumentAccessor { public: static FOutputHandle GetInvalidHandle(); IOutputController() = default; virtual ~IOutputController() = default; /** Returns true if the controller is in a valid state. */ virtual bool IsValid() const = 0; virtual FGuid GetID() const = 0; /** Returns the data type name associated with this output. */ virtual const FName& GetDataType() const = 0; /** Returns the name associated with this output. */ virtual const FString& GetName() const = 0; /** Returns the human readable name associated with this output. */ virtual const FText& GetDisplayName() const = 0; /** Returns the tooltip associated with this output. */ virtual const FText& GetTooltip() const = 0; /** Returns all metadata associated with this output. */ virtual const FMetasoundFrontendVertexMetadata& GetMetadata() const = 0; /** Returns the ID of the node which owns this output. */ virtual FGuid GetOwningNodeID() const = 0; /** Returns a FNodeHandle to the node which owns this output. */ virtual FNodeHandle GetOwningNode() = 0; /** Returns a FConstNodeHandle to the node which owns this output. */ virtual FConstNodeHandle GetOwningNode() const = 0; /** Return true if the input is connect to an output. */ virtual bool IsConnected() const = 0; /** Returns the currently connected output. If this input is not * connected, the returned handle will be invalid. */ virtual TArray GetConnectedInputs() = 0; /** Returns the currently connected output. If this input is not * connected, the returned handle will be invalid. */ virtual TArray GetConstConnectedInputs() const = 0; virtual bool Disconnect() = 0; /** Returns information describing connectability between this output and the supplied input. */ virtual FConnectability CanConnectTo(const IInputController& InController) const = 0; /** Connects this output and the supplied input. * @return True on success, false on failure. */ virtual bool Connect(IInputController& InController) = 0; /** Connects this output to the input using a converter node. * @return True on success, false on failure. */ virtual bool ConnectWithConverterNode(IInputController& InController, const FConverterNodeInfo& InNodeClassName) = 0; /** Disconnects this output from the input. * @return True on success, false on failure. */ virtual bool Disconnect(IInputController& InController) = 0; }; /* An IInputController provides methods for querying and manipulating a metasound input vertex. */ class METASOUNDFRONTEND_API IInputController : public TSharedFromThis, public IDocumentAccessor { public: static FInputHandle GetInvalidHandle(); IInputController() = default; virtual ~IInputController() = default; /** Returns true if the controller is in a valid state. */ virtual bool IsValid() const = 0; virtual FGuid GetID() const = 0; /** Return true if the input is connect to an output. */ virtual bool IsConnected() const = 0; /** Returns the data type name associated with this input. */ virtual const FName& GetDataType() const = 0; /** Returns the data type name associated with this input. */ virtual const FString& GetName() const = 0; /** Returns the data type name associated with this input. */ virtual const FText& GetDisplayName() const = 0; /** Returns the value for the given input instance if set. */ virtual const FMetasoundFrontendLiteral* GetLiteral() const = 0; /** Sets the value for the given input instance (effectively overriding the class default). */ virtual void SetLiteral(const FMetasoundFrontendLiteral& InLiteral) = 0; /** Returns the class default value of the given input. */ virtual const FMetasoundFrontendLiteral* GetClassDefaultLiteral() const = 0; /** Returns the data type name associated with this input. */ virtual const FText& GetTooltip() const = 0; /** Returns all metadata associated with this input. */ virtual const FMetasoundFrontendVertexMetadata& GetMetadata() const = 0; /** Returns the ID of the node which owns this output. */ virtual FGuid GetOwningNodeID() const = 0; /** Returns a FNodeHandle to the node which owns this output. */ virtual FNodeHandle GetOwningNode() = 0; /** Returns a FConstNodeHandle to the node which owns this output. */ virtual FConstNodeHandle GetOwningNode() const = 0; /** Returns the currently connected output. If this input is not * connected, the returned handle will be invalid. */ virtual FOutputHandle GetConnectedOutput() = 0; /** Returns the currently connected output. If this input is not * connected, the returned handle will be invalid. */ virtual FConstOutputHandle GetConnectedOutput() const = 0; /** Returns information describing connectability between this input and the supplied output. */ virtual FConnectability CanConnectTo(const IOutputController& InController) const = 0; /** Connects this input and the supplied output. * @return True on success, false on failure. */ virtual bool Connect(IOutputController& InController) = 0; /** Connects this input to the output using a converter node. * @return True on success, false on failure. */ virtual bool ConnectWithConverterNode(IOutputController& InController, const FConverterNodeInfo& InNodeClassName) = 0; /** Disconnects this input from the given output. * @return True on success, false on failure. */ virtual bool Disconnect(IOutputController& InController) = 0; /** Disconnects this input from any connected output. * @return True on success, false on failure. */ virtual bool Disconnect() = 0; }; /* An INodeController provides methods for querying and manipulating a Metasound node. */ class METASOUNDFRONTEND_API INodeController : public TSharedFromThis, public IDocumentAccessor { public: static FNodeHandle GetInvalidHandle(); INodeController() = default; virtual ~INodeController() = default; /** Returns true if the controller is in a valid state. */ virtual bool IsValid() const = 0; /** Returns all node inputs. */ virtual TArray GetInputs() = 0; /** Returns all node inputs. */ virtual TArray GetConstInputs() const = 0; /** Returns the display name of the given node (what to distinguish and label in visual arrays, such as context menus). */ virtual const FText& GetDisplayName() const = 0; /** Sets the description of the node. */ virtual void SetDescription(const FText& InDescription) = 0; /** Sets the display name of the node. */ virtual void SetDisplayName(const FText& InDisplayName) = 0; /** Returns the title of the given node (what to label when displayed as visual node). */ virtual const FText& GetDisplayTitle() const = 0; /** Iterate over inputs */ virtual void IterateInputs(TUniqueFunction InFunction) = 0; virtual void IterateConstInputs(TUniqueFunction InFunction) const = 0; /** Returns number of node inputs. */ virtual int32 GetNumInputs() const = 0; /** Iterate over outputs */ virtual void IterateOutputs(TUniqueFunction InFunction) = 0; virtual void IterateConstOutputs(TUniqueFunction InFunction) const = 0; /** Returns number of node outputs. */ virtual int32 GetNumOutputs() const = 0; virtual TArray GetInputsWithVertexName(const FString& InName) = 0; virtual TArray GetConstInputsWithVertexName(const FString& InName) const = 0; /** Returns all node outputs. */ virtual TArray GetOutputs() = 0; /** Returns all node outputs. */ virtual TArray GetConstOutputs() const = 0; virtual TArray GetOutputsWithVertexName(const FString& InName) = 0; virtual TArray GetConstOutputsWithVertexName(const FString& InName) const = 0; /** Returns true if node is required to satisfy the document archetype. */ virtual bool IsRequired() const = 0; /** Returns an input with the given id. * * If the input does not exist, an invalid handle is returned. */ virtual FInputHandle GetInputWithID(FGuid InVertexID) = 0; /** Returns an input with the given name. * * If the input does not exist, an invalid handle is returned. */ virtual FConstInputHandle GetInputWithID(FGuid InVertexID) const = 0; /** Returns an output with the given name. * * If the output does not exist, an invalid handle is returned. */ virtual FOutputHandle GetOutputWithID(FGuid InVertexID) = 0; /** Returns an output with the given name. * * If the output does not exist, an invalid handle is returned. */ virtual FConstOutputHandle GetOutputWithID(FGuid InVertexID) const = 0; virtual bool CanAddInput(const FString& InVertexName) const = 0; virtual FInputHandle AddInput(const FString& InVertexName, const FMetasoundFrontendLiteral* InDefault) = 0; virtual bool RemoveInput(FGuid InVertexID) = 0; // TODO: VertexID -> PinID? VertexID? SlotID? RefID? virtual bool CanAddOutput(const FString& InVertexName) const = 0; virtual FInputHandle AddOutput(const FString& InVertexName, const FMetasoundFrontendLiteral* InDefault) = 0; virtual bool RemoveOutput(FGuid InVertexID) = 0; // Returns an input's default literal if set, null if not. virtual const FMetasoundFrontendLiteral* GetInputLiteral(const FGuid& InVertexID) const = 0; // Sets an input's default literal virtual void SetInputLiteral(const FMetasoundFrontendVertexLiteral& InVertexLiteral) = 0; // Clears an input's default literal virtual bool ClearInputLiteral(FGuid InVertexID) = 0; /** Returns associated node class data */ virtual const FMetasoundFrontendClassInterface& GetClassInterface() const = 0; virtual const FMetasoundFrontendClassMetadata& GetClassMetadata() const = 0; virtual const FMetasoundFrontendInterfaceStyle& GetOutputStyle() const = 0; virtual const FMetasoundFrontendInterfaceStyle& GetInputStyle() const = 0; virtual const FMetasoundFrontendClassStyle& GetClassStyle() const = 0; /** Description of the given node. */ virtual const FText& GetDescription() const = 0; /** If the node is also a graph, this returns a graph handle. * If the node is not also a graph, it will return an invalid handle. */ virtual FGraphHandle AsGraph() = 0; /** If the node is also a graph, this returns a graph handle. * If the node is not also a graph, it will return an invalid handle. */ virtual FConstGraphHandle AsGraph() const = 0; /** Returns the name of this node. */ virtual const FString& GetNodeName() const = 0; virtual const FMetasoundFrontendNodeStyle& GetNodeStyle() const = 0; virtual void SetNodeStyle(const FMetasoundFrontendNodeStyle& InStyle) = 0; /** Returns the ID associated with this node. */ virtual FGuid GetID() const = 0; /** Returns the ID associated with the node class. */ virtual FGuid GetClassID() const = 0; /** Returns the class ID of the metasound class which owns this node. */ virtual FGuid GetOwningGraphClassID() const = 0; /** Returns the graph which owns this node. */ virtual FGraphHandle GetOwningGraph() = 0; /** Returns the graph which owns this node. */ virtual FConstGraphHandle GetOwningGraph() const = 0; }; /* An IGraphController provides methods for querying and manipulating a Metasound graph. */ class METASOUNDFRONTEND_API IGraphController : public TSharedFromThis, public IDocumentAccessor { public: static FGraphHandle GetInvalidHandle(); IGraphController() = default; virtual ~IGraphController() = default; /** Returns true if the controller is in a valid state. */ virtual bool IsValid() const = 0; /** Returns the ClassID associated with this graph. */ virtual FGuid GetClassID() const = 0; /** Return the metadata for the current graph. */ virtual const FMetasoundFrontendClassMetadata& GetGraphMetadata() const = 0; /** Sets the metadata for the current graph. */ virtual void SetGraphMetadata(const FMetasoundFrontendClassMetadata& InMetadata) = 0; /** Return the display name of the graph. */ virtual const FText& GetDisplayName() const = 0; virtual TArray GetInputVertexNames() const = 0; virtual TArray GetOutputVertexNames() const = 0; /** Returns all nodes in the graph. */ virtual TArray GetNodes() = 0; /** Returns a node by NodeID. If the node does not exist, an invalid handle is returned. */ virtual FConstNodeHandle GetNodeWithID(FGuid InNodeID) const = 0; /** Returns all nodes in the graph. */ virtual TArray GetConstNodes() const = 0; /** Returns a node by NodeID. If the node does not exist, an invalid handle is returned. */ virtual FNodeHandle GetNodeWithID(FGuid InNodeID) = 0; /** Returns all output nodes in the graph. */ virtual TArray GetOutputNodes() = 0; // Returns graph style. virtual const FMetasoundFrontendGraphStyle& GetGraphStyle() const = 0; // Sets graph style. virtual void SetGraphStyle(const FMetasoundFrontendGraphStyle& InStyle) = 0; /** Returns all output nodes in the graph. */ virtual TArray GetConstOutputNodes() const = 0; /** Returns all input nodes in the graph. */ virtual TArray GetInputNodes() = 0; /** Returns all input nodes in the graph. */ virtual TArray GetConstInputNodes() const = 0; /** Iterate over all input nodes with the given function. If ClassType is specified, only iterate over given type. */ virtual void IterateNodes(TUniqueFunction InFunction, EMetasoundFrontendClassType InClassType = EMetasoundFrontendClassType::Invalid) = 0; /** Iterate over all nodes with the given function. If ClassType is specified, only iterate over given type. */ virtual void IterateConstNodes(TUniqueFunction InFunction, EMetasoundFrontendClassType InClassType = EMetasoundFrontendClassType::Invalid) const = 0; /** Returns true if an output vertex with the given Name exists. * * @param InName - Name of vertex. * @return True if the vertex exists, false otherwise. */ virtual bool ContainsOutputVertexWithName(const FString& InName) const = 0; /** Returns true if an input vertex with the given Name exists. * * @param InName - Name of vertex. * @return True if the vertex exists, false otherwise. */ virtual bool ContainsInputVertexWithName(const FString& InName) const = 0; /** Returns a handle to an existing output node for the given graph output name. * If no output exists with the given name, an invalid node handle is returned. * * @param InName - Name of graph output.. * @return The node handle for the output node. If the output does not exist, an invalid handle is returned. */ virtual FNodeHandle GetOutputNodeWithName(const FString& InName) = 0; /** Returns a handle to an existing output node for the given graph output name. * If no output exists with the given name, an invalid node handle is returned. * * @param InName - Name of graph output. * @return The node handle for the output node. If the node does not exist, an invalid handle is returned. */ virtual FConstNodeHandle GetOutputNodeWithName(const FString& InName) const = 0; /** Returns a handle to an existing input node for the given graph input name. * If no input exists with the given name, an invalid node handle is returned. * * @param InName - Name of graph input. * @return The node handle for the input node. If the node does not exist, an invalid handle is returned. */ virtual FNodeHandle GetInputNodeWithName(const FString& InName) = 0; /** Returns a handle to an existing input node for the given graph input name. * If no input exists with the given name, an invalid node handle is returned. * * @param InName - Name of graph input. * @return The node handle for the input node. If the node does not exist, an invalid handle is returned. */ virtual FConstNodeHandle GetInputNodeWithName(const FString& InName) const = 0; virtual FConstClassInputAccessPtr FindClassInputWithName(const FString& InName) const = 0; virtual FConstClassOutputAccessPtr FindClassOutputWithName(const FString& InName) const = 0; /** Add a new input node using the input description. * * @param InDescription - Description for input of graph. * @return On success, a valid input node handle. On failure, an invalid node handle. */ virtual FNodeHandle AddInputVertex(const FMetasoundFrontendClassInput& InDescription) = 0; /** Remove the input with the given name. Returns true if successfully removed, false otherwise. */ virtual bool RemoveInputVertex(const FString& InputName) = 0; /** Add a new output node using the output description. * * @param InDescription - Description for output of graph. * @return On success, a valid output node handle. On failure, an invalid node handle. */ virtual FNodeHandle AddOutputVertex(const FMetasoundFrontendClassOutput& InDescription) = 0; /** Remove the output with the given name. Returns true if successfully removed, false otherwise. */ virtual bool RemoveOutputVertex(const FString& OutputName) = 0; /** Returns the preferred literal argument type for a given input. * Returns ELiteralType::Invalid if the input couldn't be found, * or if the input doesn't support any kind of literals. * * @param InInputName - Name of graph input. * @return The preferred literal argument type. */ virtual ELiteralType GetPreferredLiteralTypeForInputVertex(const FString& InInputName) const = 0; /** Return the UObject class corresponding an input. Meaningful for inputs whose preferred * literal type is UObject or UObjectArray. * * @param InInputName - Name of graph input. * * @return The UClass* for the literal argument input. nullptr on error or if UObject argument is not supported. */ virtual UClass* GetSupportedClassForInputVertex(const FString& InInputName) = 0; virtual FGuid GetVertexIDForInputVertex(const FString& InInputName) const = 0; virtual FGuid GetVertexIDForOutputVertex(const FString& InOutputName) const = 0; virtual FMetasoundFrontendLiteral GetDefaultInput(const FGuid& InVertexID) const = 0; virtual bool SetDefaultInput(const FGuid& InVertexID, const FMetasoundFrontendLiteral& InLiteral) = 0; /** Set the default value for the graph input. * * @param InInputName - Name of the graph input. * @param InVertexID - Vertex to set to DataType default. * @param InDataTypeName - Name of datatype to set to default. * * @return True on success. False if the input does not exist or if the literal type was incompatible with the input. */ virtual bool SetDefaultInputToDefaultLiteralOfType(const FGuid& InVertexID) = 0; /** Set the display name for the input with the given name. */ virtual void SetInputDisplayName(const FString& InName, const FText& InDisplayName) = 0; /** Set the display name for the output with the given name. */ virtual void SetOutputDisplayName(const FString& InName, const FText& InDisplayName) = 0; /** Get the description for the input with the given name. */ virtual const FText& GetInputDescription(const FString& InName) const = 0; /** Get the description for the output with the given name. */ virtual const FText& GetOutputDescription(const FString& InName) const = 0; /** Set the description for the input with the given name. */ virtual void SetInputDescription(const FString& InName, const FText& InDescription) = 0; /** Set the description for the output with the given name. */ virtual void SetOutputDescription(const FString& InName, const FText& InDescription) = 0; /** Clear the current literal for a given input. * * @return True on success, false on failure. */ virtual bool ClearLiteralForInput(const FString& InInputName, FGuid InVertexID) = 0; /** Add a new node to this graph from the node registry. * * @param InKey - Registry key for node. * * @return Node handle for class. On error, an invalid handle is returned. */ virtual FNodeHandle AddNode(const FNodeRegistryKey& InKey) = 0; /** Add a new node to this graph. * * @param InClassMetadata - Info for node class. * * @return Node handle for class. On error, an invalid handle is returned. */ virtual FNodeHandle AddNode(const FMetasoundFrontendClassMetadata& InClassMetadata) = 0; /** Add a new node to this graph by duplicating the supplied node. * The new node has the same interface and node class as the supplied node. * This method will not duplicate node connections. * * @param InNodeController - Node to duplicate. * * @return Node handle for new node. On error, an invalid handle is returned. */ virtual FNodeHandle AddDuplicateNode(const INodeController& InNodeController) = 0; /** Remove the node corresponding to this node handle. * * @return True on success, false on failure. */ virtual bool RemoveNode(INodeController& InNode) = 0; /** Creates and inserts a new subgraph into this graph using the given metadata. * By calling AsGraph() on the returned node handle, callers can modify * the new subgraph. * * @param InInfo - Metadata for the subgraph. * * @return Handle to the subgraph node. On error, the handle is invalid. */ virtual FNodeHandle CreateEmptySubgraph(const FMetasoundFrontendClassMetadata& InInfo) = 0; /** Creates a runtime operator for the given graph. * * @param InSettings - Settings to use when creating operators. * @param InEnvironment - Environment variables available during creation. * @param OutBuildErrors - An array to populate with errors encountered during the build process. * * @return On success, a valid pointer to a Metasound operator. An invalid pointer on failure. */ virtual TUniquePtr BuildOperator(const FOperatorSettings& InSettings, const FMetasoundEnvironment& InEnvironment, TArray& OutBuildErrors) const = 0; /** Returns a handle to the document owning this graph. */ virtual FDocumentHandle GetOwningDocument() = 0; /** Returns a handle to the document owning this graph. */ virtual FConstDocumentHandle GetOwningDocument() const = 0; }; /* An IDocumentController provides methods for querying and manipulating a Metasound document. */ class METASOUNDFRONTEND_API IDocumentController : public TSharedFromThis, public IDocumentAccessor { public: static FDocumentHandle GetInvalidHandle(); /** Create a document from FMetasoundFrontendDocument description pointer. */ static FDocumentHandle CreateDocumentHandle(FDocumentAccessPtr InDocument); static FDocumentHandle CreateDocumentHandle(FMetasoundFrontendDocument& InDocument); /** Create a document from FMetasoundFrontendDocument description pointer. */ static FConstDocumentHandle CreateDocumentHandle(FConstDocumentAccessPtr InDocument); static FConstDocumentHandle CreateDocumentHandle(const FMetasoundFrontendDocument& InDocument); IDocumentController() = default; virtual ~IDocumentController() = default; /** Returns true if the controller is in a valid state. */ virtual bool IsValid() const = 0; // TODO: add info on environment variables. // TODO: consider find/add subgraph // TODO: perhaps functions returning access pointers could be removed from main interface and only exist in FDocumentController. /** Returns an array of all class dependencies for this document. */ virtual TArray GetDependencies() const = 0; virtual TArray GetSubgraphs() const = 0; virtual TArray GetClasses() const = 0; virtual const FMetasoundFrontendGraphClass& GetRootGraphClass() const = 0; virtual FConstClassAccessPtr FindDependencyWithID(FGuid InClassID) const = 0; virtual FConstGraphClassAccessPtr FindSubgraphWithID(FGuid InClassID) const = 0; virtual FConstClassAccessPtr FindClassWithID(FGuid InClassID) const = 0; virtual void SetMetadata(const FMetasoundFrontendDocumentMetadata& InMetadata) = 0; virtual const FMetasoundFrontendDocumentMetadata& GetMetadata() const = 0; /** Returns an existing Metasound class description corresponding to * a dependency which matches the provided class information. * * @return A pointer to the found object, or nullptr if it could not be found. */ virtual FConstClassAccessPtr FindClass(const FNodeRegistryKey& InKey) const = 0; /** Attempts to find an existing Metasound class description corresponding * to a dependency which matches the provided class information. If the * class is not found in the current dependencies, it is added to the * dependencies. * * @return A pointer to the object, or nullptr on error. */ virtual FConstClassAccessPtr FindOrAddClass(const FNodeRegistryKey& InKey) = 0; /** Returns an existing Metasound class description corresponding to * a dependency which matches the provided class information. * * @return A pointer to the found object, or nullptr if it could not be found. */ virtual FConstClassAccessPtr FindClass(const FMetasoundFrontendClassMetadata& InMetadata) const = 0; /** Attempts to find an existing Metasound class description corresponding * to a dependency which matches the provided class information. If the * class is not found in the current dependencies, it is added to the * dependencies. * * @return A pointer to the object, or nullptr on error. */ virtual FConstClassAccessPtr FindOrAddClass(const FMetasoundFrontendClassMetadata& InMetadata) = 0; /** Adds a duplicate subgraph to the document. This method creates a * copy of the graph and adds all the graph dependencies to this document. * * @param InGraph - Graph to copy. * * @return Handle to new graph. On error, an invalid handle is returned. */ virtual FGraphHandle AddDuplicateSubgraph(const IGraphController& InGraph) = 0; virtual const FMetasoundFrontendVersion& GetArchetypeVersion() const = 0; virtual void SetArchetypeVersion(const FMetasoundFrontendVersion& InVersion) = 0; /** Removes all dependencies which are no longer referenced by any graphs within this document * and updates dependency Metadata where necessary with that found in the registry. */ virtual void SynchronizeDependencies() = 0; /** Returns an array of all subgraphs for this document. */ virtual TArray GetSubgraphHandles() = 0; /** Returns an array of all subgraphs for this document. */ virtual TArray GetSubgraphHandles() const = 0; /** Returns a graphs in the document with the given class ID.*/ virtual FGraphHandle GetSubgraphWithClassID(FGuid InClassID) = 0; /** Returns a graphs in the document with the given class ID.*/ virtual FConstGraphHandle GetSubgraphWithClassID(FGuid InClassID) const = 0; /** Returns the root graph of this document. */ virtual FGraphHandle GetRootGraph() = 0; /** Returns the root graph of this document. */ virtual FConstGraphHandle GetRootGraph() const = 0; /** Exports the document to a json file at the provided path. * * @return True on success, false on failure. */ virtual bool ExportToJSONAsset(const FString& InAbsolutePath) const = 0; /** Exports the document to a json formatted string. */ virtual FString ExportToJSON() const = 0; }; } }