Interface.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_INTERFACE_H
#define MATERIALX_INTERFACE_H
 
 
#include <MaterialXCore/Export.h>
 
#include <MaterialXCore/Geom.h>
 
MATERIALX_NAMESPACE_BEGIN
 
class PortElement;
class Input;
class Output;
class InterfaceElement;
class Node;
class NodeDef;
 
using PortElementPtr = shared_ptr<PortElement>;
using ConstPortElementPtr = shared_ptr<const PortElement>;
 
using InputPtr = shared_ptr<Input>;
using ConstInputPtr = shared_ptr<const Input>;
 
using OutputPtr = shared_ptr<Output>;
using ConstOutputPtr = shared_ptr<const Output>;
 
using InterfaceElementPtr = shared_ptr<InterfaceElement>;
using ConstInterfaceElementPtr = shared_ptr<const InterfaceElement>;
 
using CharSet = std::set<char>;
 
class MX_CORE_API PortElement : public ValueElement
{
  protected:
    PortElement(ElementPtr parent, const string& category, const string& name) :
        ValueElement(parent, category, name)
    {
    }
 
  public:
    virtual ~PortElement() { }
 
  protected:
    using NodePtr = shared_ptr<Node>;
    using ConstNodePtr = shared_ptr<const Node>;
 
  public:
 
    void setNodeName(const string& node)
    {
        setAttribute(NODE_NAME_ATTRIBUTE, node);
    }
 
    bool hasNodeName() const
    {
        return hasAttribute(NODE_NAME_ATTRIBUTE);
    }
 
    const string& getNodeName() const
    {
        return getAttribute(NODE_NAME_ATTRIBUTE);
    }
 
 
    void setNodeGraphString(const string& node)
    {
        setAttribute(NODE_GRAPH_ATTRIBUTE, node);
    }
 
    bool hasNodeGraphString() const
    {
        return hasAttribute(NODE_GRAPH_ATTRIBUTE);
    }
 
    const string& getNodeGraphString() const
    {
        return getAttribute(NODE_GRAPH_ATTRIBUTE);
    }
 
 
    void setOutputString(const string& output)
    {
        setAttribute(OUTPUT_ATTRIBUTE, output);
    }
 
    bool hasOutputString() const
    {
        return hasAttribute(OUTPUT_ATTRIBUTE);
    }
 
    void setConnectedOutput(ConstOutputPtr output);
 
    virtual OutputPtr getConnectedOutput() const;
 
    const string& getOutputString() const
    {
        return getAttribute(OUTPUT_ATTRIBUTE);
    }
 
 
    void setConnectedNode(ConstNodePtr node);
 
    virtual NodePtr getConnectedNode() const;
 
 
    bool validate(string* message = nullptr) const override;
 
 
  public:
    static const string NODE_NAME_ATTRIBUTE;
    static const string NODE_GRAPH_ATTRIBUTE;
    static const string OUTPUT_ATTRIBUTE;
};
 
class MX_CORE_API Input : public PortElement
{
  public:
    Input(ElementPtr parent, const string& name) :
        PortElement(parent, CATEGORY, name)
    {
    }
    virtual ~Input() { }
 
  public:
 
    void setDefaultGeomPropString(const string& geomprop)
    {
        setAttribute(DEFAULT_GEOM_PROP_ATTRIBUTE, geomprop);
    }
 
    bool hasDefaultGeomPropString() const
    {
        return hasAttribute(DEFAULT_GEOM_PROP_ATTRIBUTE);
    }
 
    const string& getDefaultGeomPropString() const
    {
        return getAttribute(DEFAULT_GEOM_PROP_ATTRIBUTE);
    }
 
    GeomPropDefPtr getDefaultGeomProp() const;
 
 
    NodePtr getConnectedNode() const override;
 
    void setConnectedInterfaceName(const string& interfaceName);
 
    InputPtr getInterfaceInput() const;
 
 
    bool validate(string* message = nullptr) const override;
 
 
  public:
    static const string CATEGORY;
    static const string DEFAULT_GEOM_PROP_ATTRIBUTE;
};
 
class MX_CORE_API Output : public PortElement
{
  public:
    Output(ElementPtr parent, const string& name) :
        PortElement(parent, CATEGORY, name)
    {
    }
    virtual ~Output() { }
 
  public:
 
    Edge getUpstreamEdge(size_t index = 0) const override;
 
    size_t getUpstreamEdgeCount() const override
    {
        return 1;
    }
 
    bool hasUpstreamCycle() const;
 
 
    bool validate(string* message = nullptr) const override;
 
 
  public:
    static const string CATEGORY;
    static const string DEFAULT_INPUT_ATTRIBUTE;
};
 
class MX_CORE_API InterfaceElement : public TypedElement
{
  protected:
    InterfaceElement(ElementPtr parent, const string& category, const string& name) :
        TypedElement(parent, category, name),
        _inputCount(0),
        _outputCount(0)
    {
    }
 
  public:
    virtual ~InterfaceElement() { }
 
  protected:
    using NodeDefPtr = shared_ptr<NodeDef>;
    using ConstNodeDefPtr = shared_ptr<const NodeDef>;
 
  public:
 
    void setNodeDefString(const string& nodeDef)
    {
        setAttribute(NODE_DEF_ATTRIBUTE, nodeDef);
    }
 
    bool hasNodeDefString() const
    {
        return hasAttribute(NODE_DEF_ATTRIBUTE);
    }
 
    const string& getNodeDefString() const
    {
        return getAttribute(NODE_DEF_ATTRIBUTE);
    }
 
 
    InputPtr addInput(const string& name = EMPTY_STRING,
                      const string& type = DEFAULT_TYPE_STRING)
    {
        InputPtr child = addChild<Input>(name);
        child->setType(type);
        return child;
    }
 
    InputPtr getInput(const string& name) const
    {
        return getChildOfType<Input>(name);
    }
 
    vector<InputPtr> getInputs() const
    {
        return getChildrenOfType<Input>();
    }
 
    size_t getInputCount() const
    {
        return _inputCount;
    }
 
    void removeInput(const string& name)
    {
        removeChildOfType<Input>(name);
    }
 
    InputPtr getActiveInput(const string& name) const;
 
    vector<InputPtr> getActiveInputs() const;
 
 
    OutputPtr addOutput(const string& name = EMPTY_STRING,
                        const string& type = DEFAULT_TYPE_STRING)
    {
        OutputPtr output = addChild<Output>(name);
        output->setType(type);
        return output;
    }
 
    OutputPtr getOutput(const string& name) const
    {
        return getChildOfType<Output>(name);
    }
 
    vector<OutputPtr> getOutputs() const
    {
        return getChildrenOfType<Output>();
    }
 
    size_t getOutputCount() const
    {
        return _outputCount;
    }
 
    void removeOutput(const string& name)
    {
        removeChildOfType<Output>(name);
    }
 
    OutputPtr getActiveOutput(const string& name) const;
 
    vector<OutputPtr> getActiveOutputs() const;
 
    void setConnectedOutput(const string& inputName, OutputPtr output);
 
    OutputPtr getConnectedOutput(const string& inputName) const;
 
 
    TokenPtr addToken(const string& name = EMPTY_STRING)
    {
        return addChild<Token>(name);
    }
 
    TokenPtr getToken(const string& name) const
    {
        return getChildOfType<Token>(name);
    }
 
    vector<TokenPtr> getTokens() const
    {
        return getChildrenOfType<Token>();
    }
 
    void removeToken(const string& name)
    {
        removeChildOfType<Token>(name);
    }
 
    TokenPtr getActiveToken(const string& name) const;
 
    vector<TokenPtr> getActiveTokens() const;
 
 
    ValueElementPtr getValueElement(const string& name) const
    {
        return getChildOfType<ValueElement>(name);
    }
 
    ValueElementPtr getActiveValueElement(const string& name) const;
 
    vector<ValueElementPtr> getActiveValueElements() const;
 
 
    template <class T> InputPtr setInputValue(const string& name,
                                              const T& value,
                                              const string& type = EMPTY_STRING);
 
    ValuePtr getInputValue(const string& name, const string& target = EMPTY_STRING) const;
 
    TokenPtr setTokenValue(const string& name, const string& value)
    {
        TokenPtr token = getToken(name);
        if (!token)
            token = addToken(name);
        token->setValue<string>(value);
        return token;
    }
 
    string getTokenValue(const string& name)
    {
        TokenPtr token = getToken(name);
        return token ? token->getValueString() : EMPTY_STRING;
    }
 
 
    void setTarget(const string& target)
    {
        setAttribute(TARGET_ATTRIBUTE, target);
    }
 
    bool hasTarget() const
    {
        return hasAttribute(TARGET_ATTRIBUTE);
    }
 
    const string& getTarget() const
    {
        return getAttribute(TARGET_ATTRIBUTE);
    }
 
 
    void setVersionString(const string& version)
    {
        setAttribute(VERSION_ATTRIBUTE, version);
    }
 
    bool hasVersionString() const
    {
        return hasAttribute(VERSION_ATTRIBUTE);
    }
 
    const string& getVersionString() const
    {
        return getAttribute(VERSION_ATTRIBUTE);
    }
 
    void setVersionIntegers(int majorVersion, int minorVersion);
 
    virtual std::pair<int, int> getVersionIntegers() const;
 
 
    void setDefaultVersion(bool defaultVersion)
    {
        setTypedAttribute<bool>(DEFAULT_VERSION_ATTRIBUTE, defaultVersion);
    }
 
    bool getDefaultVersion() const
    {
        return getTypedAttribute<bool>(DEFAULT_VERSION_ATTRIBUTE);
    }
 
 
    virtual ConstInterfaceElementPtr getDeclaration(const string& target = EMPTY_STRING) const;
 
    void clearContent() override;
 
    bool hasExactInputMatch(ConstInterfaceElementPtr declaration, string* message = nullptr) const;
 
 
  public:
    static const string NODE_DEF_ATTRIBUTE;
    static const string TARGET_ATTRIBUTE;
    static const string VERSION_ATTRIBUTE;
    static const string DEFAULT_VERSION_ATTRIBUTE;
 
  protected:
    void registerChildElement(ElementPtr child) override;
    void unregisterChildElement(ElementPtr child) override;
 
  private:
    size_t _inputCount;
    size_t _outputCount;
};
 
template <class T> InputPtr InterfaceElement::setInputValue(const string& name,
                                                            const T& value,
                                                            const string& type)
{
    InputPtr input = getChildOfType<Input>(name);
    if (!input)
        input = addInput(name);
    input->setValue(value, type);
    return input;
}
 
MATERIALX_NAMESPACE_END
 
#endif