Definition.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_DEFINITION_H
#define MATERIALX_DEFINITION_H

 
#include <MaterialXCore/Export.h>
 
#include <MaterialXCore/Interface.h>
 
MATERIALX_NAMESPACE_BEGIN
 
extern MX_CORE_API const string COLOR_SEMANTIC;
extern MX_CORE_API const string SHADER_SEMANTIC;
 
class NodeDef;
class Implementation;
class TypeDef;
class TargetDef;
class Member;
class Unit;
class UnitDef;
class UnitTypeDef;
class AttributeDef;

using NodeDefPtr = shared_ptr<NodeDef>;
using ConstNodeDefPtr = shared_ptr<const NodeDef>;

using ImplementationPtr = shared_ptr<Implementation>;
using ConstImplementationPtr = shared_ptr<const Implementation>;

using TypeDefPtr = shared_ptr<TypeDef>;
using ConstTypeDefPtr = shared_ptr<const TypeDef>;

using TargetDefPtr = shared_ptr<TargetDef>;
using ConstTargetDefPtr = shared_ptr<const TargetDef>;

using MemberPtr = shared_ptr<Member>;
using ConstMemberPtr = shared_ptr<const Member>;

using UnitPtr = shared_ptr<Unit>;
using ConstUnitPtr = shared_ptr<const Unit>;

using UnitDefPtr = shared_ptr<UnitDef>;
using ConstUnitDefPtr = shared_ptr<const UnitDef>;

using UnitTypeDefPtr = shared_ptr<UnitTypeDef>;
using ConstUnitTypeDefPtr = shared_ptr<const UnitTypeDef>;

using AttributeDefPtr = shared_ptr<AttributeDef>;
using AttributeDefDefPtr = shared_ptr<const AttributeDef>;

class MX_CORE_API NodeDef : public InterfaceElement
{
  public:
    NodeDef(ElementPtr parent, const string& name) :
        InterfaceElement(parent, CATEGORY, name)
    {
    }
    virtual ~NodeDef() { }


    void setNodeString(const string& node)
    {
        setAttribute(NODE_ATTRIBUTE, node);
    }

    bool hasNodeString() const
    {
        return hasAttribute(NODE_ATTRIBUTE);
    }

    const string& getNodeString() const
    {
        return getAttribute(NODE_ATTRIBUTE);
    }

    const string& getType() const override;


    void setNodeGroup(const string& category)
    {
        setAttribute(NODE_GROUP_ATTRIBUTE, category);
    }

    bool hasNodeGroup() const
    {
        return hasAttribute(NODE_GROUP_ATTRIBUTE);
    }

    const string& getNodeGroup() const
    {
        return getAttribute(NODE_GROUP_ATTRIBUTE);
    }


    InterfaceElementPtr getImplementation(const string& target = EMPTY_STRING) const;


    StringMap getInputHints() const;


    bool validate(string* message = nullptr) const override;


    bool isVersionCompatible(const string& version) const;

    ConstInterfaceElementPtr getDeclaration(const string& target = EMPTY_STRING) const override;

 
  public:
    static const string CATEGORY;
    static const string NODE_ATTRIBUTE;
    static const string NODE_GROUP_ATTRIBUTE;
 
    static const string TEXTURE_NODE_GROUP;
    static const string PROCEDURAL_NODE_GROUP;
    static const string GEOMETRIC_NODE_GROUP;
    static const string ADJUSTMENT_NODE_GROUP;
    static const string CONDITIONAL_NODE_GROUP;
    static const string CHANNEL_NODE_GROUP;
    static const string ORGANIZATION_NODE_GROUP;
    static const string TRANSLATION_NODE_GROUP;
};

class MX_CORE_API Implementation : public InterfaceElement
{
  public:
    Implementation(ElementPtr parent, const string& name) :
        InterfaceElement(parent, CATEGORY, name)
    {
    }
    virtual ~Implementation() { }


    void setFile(const string& file)
    {
        setAttribute(FILE_ATTRIBUTE, file);
    }

    bool hasFile() const
    {
        return hasAttribute(FILE_ATTRIBUTE);
    }

    const string& getFile() const
    {
        return getAttribute(FILE_ATTRIBUTE);
    }


    void setFunction(const string& function)
    {
        setAttribute(FUNCTION_ATTRIBUTE, function);
    }

    bool hasFunction() const
    {
        return hasAttribute(FUNCTION_ATTRIBUTE);
    }

    const string& getFunction() const
    {
        return getAttribute(FUNCTION_ATTRIBUTE);
    }


    void setNodeGraph(const string& nodegraph)
    {
        setAttribute(NODE_GRAPH_ATTRIBUTE, nodegraph);
    }

    bool hasNodeGraph() const
    {
        return hasAttribute(NODE_GRAPH_ATTRIBUTE);
    }

    const string& getNodeGraph() const
    {
        return getAttribute(PortElement::NODE_GRAPH_ATTRIBUTE);
    }


    void setNodeDef(ConstNodeDefPtr nodeDef);

    NodeDefPtr getNodeDef() const;


    bool validate(string* message = nullptr) const override;


    ConstInterfaceElementPtr getDeclaration(const string& target = EMPTY_STRING) const override;

 
  public:
    static const string CATEGORY;
    static const string FILE_ATTRIBUTE;
    static const string FUNCTION_ATTRIBUTE;
    static const string NODE_GRAPH_ATTRIBUTE;
};

class MX_CORE_API TypeDef : public Element
{
  public:
    TypeDef(ElementPtr parent, const string& name) :
        Element(parent, CATEGORY, name)
    {
    }
    virtual ~TypeDef() { }


    void setSemantic(const string& semantic)
    {
        setAttribute(SEMANTIC_ATTRIBUTE, semantic);
    }

    bool hasSemantic() const
    {
        return hasAttribute(SEMANTIC_ATTRIBUTE);
    }

    const string& getSemantic() const
    {
        return getAttribute(SEMANTIC_ATTRIBUTE);
    }


    void setContext(const string& context)
    {
        setAttribute(CONTEXT_ATTRIBUTE, context);
    }

    bool hasContext() const
    {
        return hasAttribute(CONTEXT_ATTRIBUTE);
    }

    const string& getContext() const
    {
        return getAttribute(CONTEXT_ATTRIBUTE);
    }


    MemberPtr addMember(const string& name = EMPTY_STRING)
    {
        return addChild<Member>(name);
    }

    MemberPtr getMember(const string& name) const
    {
        return getChildOfType<Member>(name);
    }

    vector<MemberPtr> getMembers() const
    {
        return getChildrenOfType<Member>();
    }

    void removeMember(const string& name)
    {
        removeChildOfType<Member>(name);
    }

 
  public:
    static const string CATEGORY;
    static const string SEMANTIC_ATTRIBUTE;
    static const string CONTEXT_ATTRIBUTE;
};

class MX_CORE_API TargetDef : public TypedElement
{
  public:
    TargetDef(ElementPtr parent, const string& name) :
        TypedElement(parent, CATEGORY, name)
    {
    }
    virtual ~TargetDef() { }

    StringVec getMatchingTargets() const;
 
  public:
    static const string CATEGORY;
};

class MX_CORE_API Member : public ValueElement
{
  public:
    Member(ElementPtr parent, const string& name) :
        ValueElement(parent, CATEGORY, name)
    {
    }
    virtual ~Member() { }
 
  public:
    static const string CATEGORY;
};

class MX_CORE_API Unit : public Element
{
  public:
    Unit(ElementPtr parent, const string& name) :
        Element(parent, CATEGORY, name)
    {
    }
    virtual ~Unit() { }
 
  public:
    static const string CATEGORY;
};

class MX_CORE_API UnitDef : public Element
{
  public:
    UnitDef(ElementPtr parent, const string& name) :
        Element(parent, CATEGORY, name)
    {
    }
    virtual ~UnitDef() { }


    void setUnitType(const string& type)
    {
        setAttribute(UNITTYPE_ATTRIBUTE, type);
    }

    bool hasUnitType() const
    {
        return hasAttribute(UNITTYPE_ATTRIBUTE);
    }

    const string& getUnitType() const
    {
        return getAttribute(UNITTYPE_ATTRIBUTE);
    }


    UnitPtr addUnit(const string& name)
    {
        if (name.empty())
        {
            throw Exception("A unit definition name cannot be empty");
        }
        return addChild<Unit>(name);
    }

    UnitPtr getUnit(const string& name) const
    {
        return getChildOfType<Unit>(name);
    }

    vector<UnitPtr> getUnits() const
    {
        return getChildrenOfType<Unit>();
    }

    void removeUnit(const string& name)
    {
        removeChildOfType<Unit>(name);
    }

 
  public:
    static const string CATEGORY;
    static const string UNITTYPE_ATTRIBUTE;
};

class MX_CORE_API UnitTypeDef : public Element
{
  public:
    UnitTypeDef(ElementPtr parent, const string& name) :
        Element(parent, CATEGORY, name)
    {
    }
    virtual ~UnitTypeDef() { }

    vector<UnitDefPtr> getUnitDefs() const;
 
  public:
    static const string CATEGORY;
};

class MX_CORE_API AttributeDef : public TypedElement
{
  public:
    AttributeDef(ElementPtr parent, const string& name) :
        TypedElement(parent, CATEGORY, name)
    {
    }
    virtual ~AttributeDef() { }


    void setAttrName(const string& name)
    {
        setAttribute(ATTRNAME_ATTRIBUTE, name);
    }

    bool hasAttrName() const
    {
        return hasAttribute(ATTRNAME_ATTRIBUTE);
    }

    const string& getAttrName() const
    {
        return getAttribute(ATTRNAME_ATTRIBUTE);
    }


    void setValueString(const string& value)
    {
        setAttribute(VALUE_ATTRIBUTE, value);
    }

    bool hasValueString() const
    {
        return hasAttribute(VALUE_ATTRIBUTE);
    }

    const string& getValueString() const
    {
        return getAttribute(VALUE_ATTRIBUTE);
    }


    template <class T> void setValue(const T& value, const string& type = EMPTY_STRING)
    {
        setType(!type.empty() ? type : getTypeString<T>());
        setValueString(toValueString(value));
    }

    void setValue(const char* value, const string& type = EMPTY_STRING)
    {
        setValue(value ? string(value) : EMPTY_STRING, type);
    }

    bool hasValue() const
    {
        return hasAttribute(VALUE_ATTRIBUTE);
    }

    ValuePtr getValue() const;


    void setElements(const string& elements)
    {
        setAttribute(ELEMENTS_ATTRIBUTE, elements);
    }

    bool hasElements() const
    {
        return hasAttribute(ELEMENTS_ATTRIBUTE);
    }

    const string& getElements() const
    {
        return getAttribute(ELEMENTS_ATTRIBUTE);
    }


    void setExportable(bool value)
    {
        setTypedAttribute<bool>(EXPORTABLE_ATTRIBUTE, value);
    }

    bool getExportable() const
    {
        return getTypedAttribute<bool>(EXPORTABLE_ATTRIBUTE);
    }

 
  public:
    static const string CATEGORY;
    static const string ATTRNAME_ATTRIBUTE;
    static const string VALUE_ATTRIBUTE;
    static const string ELEMENTS_ATTRIBUTE;
    static const string EXPORTABLE_ATTRIBUTE;
};
 
MATERIALX_NAMESPACE_END
 
#endif