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;


    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