Look.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_LOOK_H
#define MATERIALX_LOOK_H
 
 
#include <MaterialXCore/Export.h>
 
#include <MaterialXCore/Material.h>
#include <MaterialXCore/Property.h>
#include <MaterialXCore/Variant.h>
 
MATERIALX_NAMESPACE_BEGIN
 
class Look;
class LookGroup;
class LookInherit;
class MaterialAssign;
class Visibility;
 
using LookPtr = shared_ptr<Look>;
using ConstLookPtr = shared_ptr<const Look>;
 
using LookGroupPtr = shared_ptr<LookGroup>;
using ConstLookGroupPtr = shared_ptr<const LookGroup>;
 
using MaterialAssignPtr = shared_ptr<MaterialAssign>;
using ConstMaterialAssignPtr = shared_ptr<const MaterialAssign>;
 
using VisibilityPtr = shared_ptr<Visibility>;
using ConstVisibilityPtr = shared_ptr<const Visibility>;
 
class MX_CORE_API Look : public Element
{
  public:
    Look(ElementPtr parent, const string& name) :
        Element(parent, CATEGORY, name)
    {
    }
    virtual ~Look() { }
 
 
    MaterialAssignPtr addMaterialAssign(const string& name = EMPTY_STRING,
                                        const string& material = EMPTY_STRING);
 
    MaterialAssignPtr getMaterialAssign(const string& name) const
    {
        return getChildOfType<MaterialAssign>(name);
    }
 
    vector<MaterialAssignPtr> getMaterialAssigns() const
    {
        return getChildrenOfType<MaterialAssign>();
    }
 
    vector<MaterialAssignPtr> getActiveMaterialAssigns() const;
 
    void removeMaterialAssign(const string& name)
    {
        removeChildOfType<MaterialAssign>(name);
    }
 
 
    PropertyAssignPtr addPropertyAssign(const string& name = EMPTY_STRING)
    {
        return addChild<PropertyAssign>(name);
    }
 
    PropertyAssignPtr getPropertyAssign(const string& name) const
    {
        return getChildOfType<PropertyAssign>(name);
    }
 
    vector<PropertyAssignPtr> getPropertyAssigns() const
    {
        return getChildrenOfType<PropertyAssign>();
    }
 
    vector<PropertyAssignPtr> getActivePropertyAssigns() const;
 
    void removePropertyAssign(const string& name)
    {
        removeChildOfType<PropertyAssign>(name);
    }
 
 
    PropertySetAssignPtr addPropertySetAssign(const string& name = EMPTY_STRING)
    {
        return addChild<PropertySetAssign>(name);
    }
 
    PropertySetAssignPtr getPropertySetAssign(const string& name) const
    {
        return getChildOfType<PropertySetAssign>(name);
    }
 
    vector<PropertySetAssignPtr> getPropertySetAssigns() const
    {
        return getChildrenOfType<PropertySetAssign>();
    }
 
    vector<PropertySetAssignPtr> getActivePropertySetAssigns() const;
 
    void removePropertySetAssign(const string& name)
    {
        removeChildOfType<PropertySetAssign>(name);
    }
 
 
    VariantAssignPtr addVariantAssign(const string& name = EMPTY_STRING)
    {
        return addChild<VariantAssign>(name);
    }
 
    VariantAssignPtr getVariantAssign(const string& name) const
    {
        return getChildOfType<VariantAssign>(name);
    }
 
    vector<VariantAssignPtr> getVariantAssigns() const
    {
        return getChildrenOfType<VariantAssign>();
    }
 
    vector<VariantAssignPtr> getActiveVariantAssigns() const;
 
    void removeVariantAssign(const string& name)
    {
        removeChildOfType<VariantAssign>(name);
    }
 
 
    VisibilityPtr addVisibility(const string& name = EMPTY_STRING)
    {
        return addChild<Visibility>(name);
    }
 
    VisibilityPtr getVisibility(const string& name) const
    {
        return getChildOfType<Visibility>(name);
    }
 
    vector<VisibilityPtr> getVisibilities() const
    {
        return getChildrenOfType<Visibility>();
    }
 
    vector<VisibilityPtr> getActiveVisibilities() const;
 
    void removeVisibility(const string& name)
    {
        removeChildOfType<Visibility>(name);
    }
 
 
  public:
    static const string CATEGORY;
};
 
class MX_CORE_API LookGroup : public Element
{
  public:
    LookGroup(ElementPtr parent, const string& name) :
        Element(parent, CATEGORY, name)
    {
    }
    virtual ~LookGroup() { }
 
    void setLooks(const string& looks)
    {
        setAttribute(LOOKS_ATTRIBUTE, looks);
    }
 
    const string& getLooks() const
    {
        return getAttribute(LOOKS_ATTRIBUTE);
    }
 
    void setActiveLook(const string& look)
    {
        setAttribute(ACTIVE_ATTRIBUTE, look);
    }
 
    const string& getActiveLook() const
    {
        return getAttribute(ACTIVE_ATTRIBUTE);
    }
 
  public:
    static const string CATEGORY;
    static const string LOOKS_ATTRIBUTE;
    static const string ACTIVE_ATTRIBUTE;
};
 
class MX_CORE_API MaterialAssign : public GeomElement
{
  public:
    MaterialAssign(ElementPtr parent, const string& name) :
        GeomElement(parent, CATEGORY, name)
    {
    }
    virtual ~MaterialAssign() { }
 
 
    void setMaterial(const string& material)
    {
        setAttribute(MATERIAL_ATTRIBUTE, material);
    }
 
    bool hasMaterial() const
    {
        return hasAttribute(MATERIAL_ATTRIBUTE);
    }
 
    const string& getMaterial() const
    {
        return getAttribute(MATERIAL_ATTRIBUTE);
    }
 
    vector<OutputPtr> getMaterialOutputs() const;
 
 
    void setExclusive(bool value)
    {
        setTypedAttribute<bool>(EXCLUSIVE_ATTRIBUTE, value);
    }
 
    bool getExclusive() const
    {
        return getTypedAttribute<bool>(EXCLUSIVE_ATTRIBUTE);
    }
 
 
    NodePtr getReferencedMaterial() const;
 
 
    VariantAssignPtr addVariantAssign(const string& name = EMPTY_STRING)
    {
        return addChild<VariantAssign>(name);
    }
 
    VariantAssignPtr getVariantAssign(const string& name) const
    {
        return getChildOfType<VariantAssign>(name);
    }
 
    vector<VariantAssignPtr> getVariantAssigns() const
    {
        return getChildrenOfType<VariantAssign>();
    }
 
    vector<VariantAssignPtr> getActiveVariantAssigns() const;
 
    void removeVariantAssign(const string& name)
    {
        removeChildOfType<VariantAssign>(name);
    }
 
  public:
    static const string CATEGORY;
    static const string MATERIAL_ATTRIBUTE;
    static const string EXCLUSIVE_ATTRIBUTE;
};
 
class MX_CORE_API Visibility : public GeomElement
{
  public:
    Visibility(ElementPtr parent, const string& name) :
        GeomElement(parent, CATEGORY, name)
    {
    }
    virtual ~Visibility() { }
 
 
    void setViewerGeom(const string& geom)
    {
        setAttribute(VIEWER_GEOM_ATTRIBUTE, geom);
    }
 
    bool hasViewerGeom() const
    {
        return hasAttribute(VIEWER_GEOM_ATTRIBUTE);
    }
 
    const string& getViewerGeom() const
    {
        return getAttribute(VIEWER_GEOM_ATTRIBUTE);
    }
 
 
    void setViewerCollection(const string& collection)
    {
        setAttribute(VIEWER_COLLECTION_ATTRIBUTE, collection);
    }
 
    bool hasViewerCollection() const
    {
        return hasAttribute(VIEWER_COLLECTION_ATTRIBUTE);
    }
 
    const string& getViewerCollection() const
    {
        return getAttribute(VIEWER_COLLECTION_ATTRIBUTE);
    }
 
 
    void setVisibilityType(const string& type)
    {
        setAttribute(VISIBILITY_TYPE_ATTRIBUTE, type);
    }
 
    bool hasVisibilityType() const
    {
        return hasAttribute(VISIBILITY_TYPE_ATTRIBUTE);
    }
 
    const string& getVisibilityType() const
    {
        return getAttribute(VISIBILITY_TYPE_ATTRIBUTE);
    }
 
 
    void setVisible(bool visible)
    {
        setTypedAttribute<bool>(VISIBLE_ATTRIBUTE, visible);
    }
 
    bool getVisible() const
    {
        return getTypedAttribute<bool>(VISIBLE_ATTRIBUTE);
    }
 
 
  public:
    static const string CATEGORY;
    static const string VIEWER_GEOM_ATTRIBUTE;
    static const string VIEWER_COLLECTION_ATTRIBUTE;
    static const string VISIBILITY_TYPE_ATTRIBUTE;
    static const string VISIBLE_ATTRIBUTE;
};
 
MX_CORE_API vector<MaterialAssignPtr> getGeometryBindings(ConstNodePtr materialNode, const string& geom = UNIVERSAL_GEOM_NAME);
 
MATERIALX_NAMESPACE_END
 
#endif