Node.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_NODE_H
#define MATERIALX_NODE_H
 
 
#include <MaterialXCore/Export.h>
 
#include <MaterialXCore/Definition.h>
 
MATERIALX_NAMESPACE_BEGIN
 
class Node;
class GraphElement;
class NodeGraph;
class Backdrop;
 
using NodePtr = shared_ptr<Node>;
using ConstNodePtr = shared_ptr<const Node>;
 
using GraphElementPtr = shared_ptr<GraphElement>;
using ConstGraphElementPtr = shared_ptr<const GraphElement>;
 
using NodeGraphPtr = shared_ptr<NodeGraph>;
using ConstNodeGraphPtr = shared_ptr<const NodeGraph>;
 
using BackdropPtr = shared_ptr<Backdrop>;
using ConstBackdropPtr = shared_ptr<const Backdrop>;
 
// Predicate to test a node against some criteria whether
// that criteria has passed
using NodePredicate = std::function<bool(NodePtr node)>;
 
class MX_CORE_API Node : public InterfaceElement
{
  public:
    Node(ElementPtr parent, const string& name) :
        InterfaceElement(parent, CATEGORY, name)
    {
    }
    virtual ~Node() { }
 
 
    void setConnectedNode(const string& inputName, ConstNodePtr node);
 
    NodePtr getConnectedNode(const string& inputName) const;
 
    void setConnectedNodeName(const string& inputName, const string& nodeName);
 
    string getConnectedNodeName(const string& inputName) const;
 
    void setConnectedOutput(const string& inputName, OutputPtr output);
 
    OutputPtr getConnectedOutput(const string& inputName) const;
 
 
    NodeDefPtr getNodeDef(const string& target = EMPTY_STRING,
                          bool allowRoughMatch = false) const;
 
 
    InterfaceElementPtr getImplementation(const string& target = EMPTY_STRING) const
    {
        NodeDefPtr nodeDef = getNodeDef(target);
        return nodeDef ? nodeDef->getImplementation(target) : InterfaceElementPtr();
    }
 
 
    Edge getUpstreamEdge(size_t index = 0) const override;
 
    size_t getUpstreamEdgeCount() const override
    {
        return getInputCount();
    }
 
    OutputPtr getNodeDefOutput(ElementPtr connectingElement);
 
    vector<PortElementPtr> getDownstreamPorts() const;
 
 
    ConstInterfaceElementPtr getDeclaration(const string& target = EMPTY_STRING) const override
    {
        return getNodeDef(target);
    }
 
    InputPtr addInputFromNodeDef(const string& inputName);
 
    void addInputsFromNodeDef();
 
 
    bool validate(string* message = nullptr) const override;
 
 
  public:
    static const string CATEGORY;
};
 
class MX_CORE_API GraphElement : public InterfaceElement
{
  protected:
    GraphElement(ElementPtr parent, const string& category, const string& name) :
        InterfaceElement(parent, category, name)
    {
    }
 
  public:
    virtual ~GraphElement() { }
 
 
    NodePtr addNode(const string& category,
                    const string& name = EMPTY_STRING,
                    const string& type = DEFAULT_TYPE_STRING)
    {
        NodePtr node = addChild<Node>(name);
        node->setCategory(category);
        node->setType(type);
        return node;
    }
 
    NodePtr addNodeInstance(ConstNodeDefPtr nodeDef, const string& name = EMPTY_STRING)
    {
        NodePtr node = addNode(nodeDef->getNodeString(), name, nodeDef->getType());
        node->setNodeDefString(nodeDef->getName());
        return node;
    }
 
    NodePtr getNode(const string& name) const
    {
        return getChildOfType<Node>(name);
    }
 
    vector<NodePtr> getNodes(const string& category = EMPTY_STRING) const
    {
        return getChildrenOfType<Node>(category);
    }
 
    vector<NodePtr> getNodesOfType(const string& nodeType) const
    {
        vector<NodePtr> nodes;
        for (auto node : getNodes())
        {
            if (node->getType() == nodeType)
            {
                nodes.push_back(node);
            }
        }
        return nodes;
    }
 
    void removeNode(const string& name)
    {
        removeChildOfType<Node>(name);
    }
 
 
    NodePtr addMaterialNode(const string& name = EMPTY_STRING, ConstNodePtr shaderNode = nullptr);
 
    vector<NodePtr> getMaterialNodes() const
    {
        return getNodesOfType(MATERIAL_TYPE_STRING);
    }
 
 
    BackdropPtr addBackdrop(const string& name = EMPTY_STRING)
    {
        return addChild<Backdrop>(name);
    }
 
    BackdropPtr getBackdrop(const string& name) const
    {
        return getChildOfType<Backdrop>(name);
    }
 
    vector<BackdropPtr> getBackdrops() const
    {
        return getChildrenOfType<Backdrop>();
    }
 
    void removeBackdrop(const string& name)
    {
        removeChildOfType<Backdrop>(name);
    }
 
 
    void flattenSubgraphs(const string& target = EMPTY_STRING, NodePredicate filter = nullptr);
 
    vector<ElementPtr> topologicalSort() const;
 
    NodePtr addGeomNode(ConstGeomPropDefPtr geomPropDef, const string& namePrefix);
 
    string asStringDot() const;
 
};
 
class MX_CORE_API NodeGraph : public GraphElement
{
  public:
    NodeGraph(ElementPtr parent, const string& name) :
        GraphElement(parent, CATEGORY, name)
    {
    }
    virtual ~NodeGraph() { }
 
 
    vector<OutputPtr> getMaterialOutputs() const;
 
 
    void setNodeDef(ConstNodeDefPtr nodeDef);
 
    NodeDefPtr getNodeDef() const;
 
    InterfaceElementPtr getImplementation() const;
 
 
    vector<PortElementPtr> getDownstreamPorts() const;
 
 
    ConstInterfaceElementPtr getDeclaration(const string& target = EMPTY_STRING) const override;
 
    InputPtr addInterfaceName(const string& inputPath, const string& interfaceName);
 
    void removeInterfaceName(const string& inputPath);
 
    void modifyInterfaceName(const string& inputPath, const string& interfaceName);
 
 
    bool validate(string* message = nullptr) const override;
 
 
  public:
    static const string CATEGORY;
};
 
class MX_CORE_API Backdrop : public Element
{
  public:
    Backdrop(ElementPtr parent, const string& name) :
        Element(parent, CATEGORY, name)
    {
    }
    virtual ~Backdrop() { }
 
 
    void setContainsString(const string& contains)
    {
        setAttribute(CONTAINS_ATTRIBUTE, contains);
    }
 
    bool hasContainsString() const
    {
        return hasAttribute(CONTAINS_ATTRIBUTE);
    }
 
    string getContainsString() const
    {
        return getAttribute(CONTAINS_ATTRIBUTE);
    }
 
 
    void setWidth(float width)
    {
        setTypedAttribute<float>(WIDTH_ATTRIBUTE, width);
    }
 
    bool hasWidth() const
    {
        return hasAttribute(WIDTH_ATTRIBUTE);
    }
 
    float getWidth() const
    {
        return getTypedAttribute<float>(WIDTH_ATTRIBUTE);
    }
 
 
    void setHeight(float height)
    {
        setTypedAttribute<float>(HEIGHT_ATTRIBUTE, height);
    }
 
    bool hasHeight() const
    {
        return hasAttribute(HEIGHT_ATTRIBUTE);
    }
 
    float getHeight() const
    {
        return getTypedAttribute<float>(HEIGHT_ATTRIBUTE);
    }
 
 
    void setContainsElements(const vector<ConstTypedElementPtr>& nodes);
 
    vector<TypedElementPtr> getContainsElements() const;
 
 
    bool validate(string* message = nullptr) const override;
 
 
  public:
    static const string CATEGORY;
    static const string CONTAINS_ATTRIBUTE;
    static const string WIDTH_ATTRIBUTE;
    static const string HEIGHT_ATTRIBUTE;
};
 
MATERIALX_NAMESPACE_END
 
#endif