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;
 
 
    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 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 TypedElement
{
  public:
    Member(ElementPtr parent, const string& name) :
        TypedElement(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
    {
        if (!hasValue())
            return ValuePtr();
        return Value::createValueFromStrings(getValueString(), getType());
    }
 
 
    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