Geom.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_GEOM_H
#define MATERIALX_GEOM_H
 
 
#include <MaterialXCore/Export.h>
 
#include <MaterialXCore/Element.h>
 
MATERIALX_NAMESPACE_BEGIN
 
extern MX_CORE_API const string GEOM_PATH_SEPARATOR;
extern MX_CORE_API const string UNIVERSAL_GEOM_NAME;
extern MX_CORE_API const string UDIM_TOKEN;
extern MX_CORE_API const string UV_TILE_TOKEN;
extern MX_CORE_API const string UDIM_SET_PROPERTY;
 
class GeomElement;
class GeomInfo;
class GeomProp;
class GeomPropDef;
class Collection;
class CollectionAdd;
class CollectionRemove;
 
using GeomElementPtr = shared_ptr<GeomElement>;
using ConstGeomElementPtr = shared_ptr<const GeomElement>;
 
using GeomInfoPtr = shared_ptr<GeomInfo>;
using ConstGeomInfoPtr = shared_ptr<const GeomInfo>;
 
using GeomPropPtr = shared_ptr<GeomProp>;
using ConstGeomPropPtr = shared_ptr<const GeomProp>;
 
using GeomPropDefPtr = shared_ptr<GeomPropDef>;
using ConstGeomPropDefPtr = shared_ptr<const GeomPropDef>;
 
using CollectionPtr = shared_ptr<Collection>;
using ConstCollectionPtr = shared_ptr<const Collection>;
 
class MX_CORE_API GeomPath
{
  public:
    GeomPath() :
        _empty(true)
    {
    }
    ~GeomPath() { }
 
    bool operator==(const GeomPath& rhs) const
    {
        return _vec == rhs._vec &&
               _empty == rhs._empty;
    }
    bool operator!=(const GeomPath& rhs) const
    {
        return !(*this == rhs);
    }
 
    explicit GeomPath(const string& geom) :
        _vec(splitString(geom, GEOM_PATH_SEPARATOR)),
        _empty(geom.empty())
    {
    }
 
    operator string() const
    {
        if (_vec.empty())
        {
            return _empty ? EMPTY_STRING : UNIVERSAL_GEOM_NAME;
        }
        string geom;
        for (size_t i = 0; i < _vec.size(); i++)
        {
            geom += _vec[i];
            if (i + 1 < _vec.size())
            {
                geom += GEOM_PATH_SEPARATOR;
            }
        }
        return geom;
    }
 
    bool isMatching(const GeomPath& rhs, bool contains = false) const
    {
        if (_empty || rhs._empty)
        {
            return false;
        }
        if (contains && _vec.size() > rhs._vec.size())
        {
            return false;
        }
        size_t minSize = std::min(_vec.size(), rhs._vec.size());
        for (size_t i = 0; i < minSize; i++)
        {
            if (_vec[i] != rhs._vec[i])
            {
                return false;
            }
        }
        return true;
    }
 
    bool isEmpty() const
    {
        return _empty;
    }
 
    bool isUniversal() const
    {
        return _vec.empty() && !_empty;
    }
 
  private:
    StringVec _vec;
    bool _empty;
};
 
class MX_CORE_API GeomElement : public Element
{
  protected:
    GeomElement(ElementPtr parent, const string& category, const string& name) :
        Element(parent, category, name)
    {
    }
 
  public:
    virtual ~GeomElement() { }
 
 
    void setGeom(const string& geom)
    {
        setAttribute(GEOM_ATTRIBUTE, geom);
    }
 
    bool hasGeom() const
    {
        return hasAttribute(GEOM_ATTRIBUTE);
    }
 
    const string& getGeom() const
    {
        return getAttribute(GEOM_ATTRIBUTE);
    }
 
    string getActiveGeom() const
    {
        return hasGeom() ?
               createStringResolver()->resolve(getGeom(), GEOMNAME_TYPE_STRING) :
               EMPTY_STRING;
    }
 
 
    void setCollectionString(const string& collection)
    {
        setAttribute(COLLECTION_ATTRIBUTE, collection);
    }
 
    bool hasCollectionString() const
    {
        return hasAttribute(COLLECTION_ATTRIBUTE);
    }
 
    const string& getCollectionString() const
    {
        return getAttribute(COLLECTION_ATTRIBUTE);
    }
 
    void setCollection(ConstCollectionPtr collection);
 
    CollectionPtr getCollection() const;
 
 
    bool validate(string* message = nullptr) const override;
 
 
  public:
    static const string GEOM_ATTRIBUTE;
    static const string COLLECTION_ATTRIBUTE;
};
 
class MX_CORE_API GeomInfo : public GeomElement
{
  public:
    GeomInfo(ElementPtr parent, const string& name) :
        GeomElement(parent, CATEGORY, name)
    {
    }
    virtual ~GeomInfo() { }
 
 
    GeomPropPtr addGeomProp(const string& name = EMPTY_STRING)
    {
        return addChild<GeomProp>(name);
    }
 
    GeomPropPtr getGeomProp(const string& name) const
    {
        return getChildOfType<GeomProp>(name);
    }
 
    vector<GeomPropPtr> getGeomProps() const
    {
        return getChildrenOfType<GeomProp>();
    }
 
    void removeGeomProp(const string& name)
    {
        removeChildOfType<GeomProp>(name);
    }
 
 
    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);
    }
 
 
    template <class T> GeomPropPtr setGeomPropValue(const string& name,
                                                    const T& value,
                                                    const string& type = EMPTY_STRING);
 
    TokenPtr setTokenValue(const string& name, const string& value)
    {
        TokenPtr token = getToken(name);
        if (!token)
            token = addToken(name);
        token->setValue<string>(value);
        return token;
    }
 
 
  public:
    static const string CATEGORY;
};
 
class MX_CORE_API GeomProp : public ValueElement
{
  public:
    GeomProp(ElementPtr parent, const string& name) :
        ValueElement(parent, CATEGORY, name)
    {
    }
    virtual ~GeomProp() { }
 
  public:
    static const string CATEGORY;
};
 
class MX_CORE_API GeomPropDef : public TypedElement
{
  public:
    GeomPropDef(ElementPtr parent, const string& name) :
        TypedElement(parent, CATEGORY, name)
    {
    }
    virtual ~GeomPropDef() { }
 
 
    void setGeomProp(const string& node)
    {
        setAttribute(GEOM_PROP_ATTRIBUTE, node);
    }
 
    bool hasGeomProp() const
    {
        return hasAttribute(GEOM_PROP_ATTRIBUTE);
    }
 
    const string& getGeomProp() const
    {
        return getAttribute(GEOM_PROP_ATTRIBUTE);
    }
 
 
    void setSpace(const string& space)
    {
        setAttribute(SPACE_ATTRIBUTE, space);
    }
 
    bool hasSpace() const
    {
        return hasAttribute(SPACE_ATTRIBUTE);
    }
 
    const string& getSpace() const
    {
        return getAttribute(SPACE_ATTRIBUTE);
    }
 
 
    void setIndex(const string& space)
    {
        setAttribute(INDEX_ATTRIBUTE, space);
    }
 
    bool hasIndex() const
    {
        return hasAttribute(INDEX_ATTRIBUTE);
    }
 
    const string& getIndex() const
    {
        return getAttribute(INDEX_ATTRIBUTE);
    }
 
 
  public:
    static const string CATEGORY;
    static const string GEOM_PROP_ATTRIBUTE;
    static const string SPACE_ATTRIBUTE;
    static const string INDEX_ATTRIBUTE;
};
 
class MX_CORE_API Collection : public Element
{
  public:
    Collection(ElementPtr parent, const string& name) :
        Element(parent, CATEGORY, name)
    {
    }
    virtual ~Collection() { }
 
 
    void setIncludeGeom(const string& geom)
    {
        setAttribute(INCLUDE_GEOM_ATTRIBUTE, geom);
    }
 
    bool hasIncludeGeom() const
    {
        return hasAttribute(INCLUDE_GEOM_ATTRIBUTE);
    }
 
    const string& getIncludeGeom() const
    {
        return getAttribute(INCLUDE_GEOM_ATTRIBUTE);
    }
 
    string getActiveIncludeGeom() const
    {
        return hasIncludeGeom() ?
               createStringResolver()->resolve(getIncludeGeom(), GEOMNAME_TYPE_STRING) :
               EMPTY_STRING;
    }
 
 
    void setExcludeGeom(const string& geom)
    {
        setAttribute(EXCLUDE_GEOM_ATTRIBUTE, geom);
    }
 
    bool hasExcludeGeom() const
    {
        return hasAttribute(EXCLUDE_GEOM_ATTRIBUTE);
    }
 
    const string& getExcludeGeom() const
    {
        return getAttribute(EXCLUDE_GEOM_ATTRIBUTE);
    }
 
    string getActiveExcludeGeom() const
    {
        return hasExcludeGeom() ?
               createStringResolver()->resolve(getExcludeGeom(), GEOMNAME_TYPE_STRING) :
               EMPTY_STRING;
    }
 
 
    void setIncludeCollectionString(const string& collection)
    {
        setAttribute(INCLUDE_COLLECTION_ATTRIBUTE, collection);
    }
 
    bool hasIncludeCollectionString() const
    {
        return hasAttribute(INCLUDE_COLLECTION_ATTRIBUTE);
    }
 
    const string& getIncludeCollectionString() const
    {
        return getAttribute(INCLUDE_COLLECTION_ATTRIBUTE);
    }
 
    void setIncludeCollection(ConstCollectionPtr collection);
 
    void setIncludeCollections(const vector<ConstCollectionPtr>& collections);
 
    vector<CollectionPtr> getIncludeCollections() const;
 
    bool hasIncludeCycle() const;
 
 
    bool matchesGeomString(const string& geom) const;
 
 
    bool validate(string* message = nullptr) const override;
 
 
  public:
    static const string CATEGORY;
    static const string INCLUDE_GEOM_ATTRIBUTE;
    static const string EXCLUDE_GEOM_ATTRIBUTE;
    static const string INCLUDE_COLLECTION_ATTRIBUTE;
};
 
template <class T> GeomPropPtr GeomInfo::setGeomPropValue(const string& name,
                                                          const T& value,
                                                          const string& type)
{
    GeomPropPtr geomProp = getChildOfType<GeomProp>(name);
    if (!geomProp)
        geomProp = addGeomProp(name);
    geomProp->setValue(value, type);
    return geomProp;
}
 
MX_CORE_API bool geomStringsMatch(const string& geom1, const string& geom2, bool contains = false);
 
MATERIALX_NAMESPACE_END
 
#endif