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;
        }
        return GEOM_PATH_SEPARATOR + joinStrings(_vec, GEOM_PATH_SEPARATOR);
    }

    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