ShaderNode.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_SHADERNODE_H
#define MATERIALX_SHADERNODE_H
 
 
#include <MaterialXGenShader/Export.h>
 
#include <MaterialXGenShader/ShaderNodeImpl.h>
#include <MaterialXGenShader/TypeDesc.h>
#include <MaterialXGenShader/GenUserData.h>
 
#include <MaterialXCore/Node.h>
 
MATERIALX_NAMESPACE_BEGIN
 
class ShaderNode;
class ShaderPort;
class ShaderInput;
class ShaderOutput;
class ShaderGraph;
 
using ShaderPortPtr = shared_ptr<class ShaderPort>;
using ShaderInputPtr = shared_ptr<class ShaderInput>;
using ShaderOutputPtr = shared_ptr<class ShaderOutput>;
using ShaderNodePtr = shared_ptr<class ShaderNode>;
using ShaderInputVec = vector<ShaderInput*>;
 
struct MX_GENSHADER_API ShaderMetadata
{
    string name;
    const TypeDesc* type;
    ValuePtr value;
    ShaderMetadata(const string& n, const TypeDesc* t, ValuePtr v = nullptr) :
        name(n),
        type(t),
        value(v)
    {
    }
};
using ShaderMetadataVec = vector<ShaderMetadata>;
using ShaderMetadataVecPtr = shared_ptr<ShaderMetadataVec>;
 
class MX_GENSHADER_API ShaderMetadataRegistry : public GenUserData
{
  public:
    static const string USER_DATA_NAME;
 
    void addMetadata(const string& name, const TypeDesc* type, ValuePtr value = nullptr)
    {
        if (_entryIndex.count(name) == 0)
        {
            _entryIndex[name] = _entries.size();
            _entries.emplace_back(name, type, value);
        }
    }
 
    const ShaderMetadata* findMetadata(const string& name) const
    {
        auto it = _entryIndex.find(name);
        return it != _entryIndex.end() ? &_entries[it->second] : nullptr;
    }
 
    ShaderMetadata* findMetadata(const string& name)
    {
        auto it = _entryIndex.find(name);
        return it != _entryIndex.end() ? &_entries[it->second] : nullptr;
    }
 
    const ShaderMetadataVec& getAllMetadata() const
    {
        return _entries;
    }
 
    void clear()
    {
        _entryIndex.clear();
        _entries.clear();
    }
 
  protected:
    vector<ShaderMetadata> _entries;
    std::unordered_map<string, size_t> _entryIndex;
};
 
using ShaderMetadataRegistryPtr = shared_ptr<ShaderMetadataRegistry>;
 
class MX_GENSHADER_API ShaderPortFlag
{
  public:
    static const uint32_t UNIFORM    = 1u << 0;
    static const uint32_t EMITTED    = 1u << 1;
    static const uint32_t BIND_INPUT = 1u << 2;
};
 
class MX_GENSHADER_API ShaderPort : public std::enable_shared_from_this<ShaderPort>
{
  public:
    ShaderPort(ShaderNode* node, const TypeDesc* type, const string& name, ValuePtr value = nullptr);
 
    ShaderPortPtr getSelf()
    {
        return shared_from_this();
    }
 
    ShaderNode* getNode() { return _node; }
 
    const ShaderNode* getNode() const { return _node; }
 
    void setType(const TypeDesc* type) { _type = type; }
 
    const TypeDesc* getType() const { return _type; }
 
    void setName(const string& name) { _name = name; }
 
    const string& getName() const { return _name; }
 
    string getFullName() const;
 
    void setVariable(const string& name) { _variable = name; }
 
    const string& getVariable() const { return _variable; }
 
    void setSemantic(const string& semantic) { _semantic = semantic; }
 
    const string& getSemantic() const { return _semantic; }
 
    void setValue(ValuePtr value) { _value = value; }
 
    ValuePtr getValue() const { return _value; }
 
    void setColorSpace(const string& colorspace) { _colorspace = colorspace; }
 
    const string& getColorSpace() const { return _colorspace; }
 
    void setUnit(const string& unit) { _unit = unit; }
 
    const string& getUnit() const { return _unit; }
 
    void setGeomProp(const string& geomprop) { _geomprop = geomprop; }
 
    const string& getGeomProp() const { return _geomprop; }
 
    void setPath(const string& path) { _path = path; }
 
    const string& getPath() const { return _path; }
 
    void setFlags(uint32_t flags) { _flags = flags; }
 
    uint32_t getFlags() const { return _flags; }
 
    void setFlag(uint32_t flag, bool value)
    {
        _flags = value ? (_flags | flag) : (_flags & ~flag);
    }
 
    bool getFlag(uint32_t flag) const
    {
        return ((_flags & flag) != 0);
    }
 
    void setUniform() { _flags |= ShaderPortFlag::UNIFORM; }
 
    bool isUniform() const { return (_flags & ShaderPortFlag::UNIFORM) != 0; }
 
    void setEmitted() { _flags |= ShaderPortFlag::EMITTED; }
 
    bool isEmitted() const { return (_flags & ShaderPortFlag::EMITTED) != 0; }
 
    void setBindInput() { _flags |= ShaderPortFlag::BIND_INPUT; }
 
    bool isBindInput() const { return (_flags & ShaderPortFlag::BIND_INPUT) != 0; }
 
    void setMetadata(ShaderMetadataVecPtr metadata) { _metadata = metadata; }
 
    ShaderMetadataVecPtr getMetadata() { return _metadata; }
 
    const ShaderMetadataVecPtr& getMetadata() const { return _metadata; }
 
  protected:
    ShaderNode* _node;
    const TypeDesc* _type;
    string _name;
    string _path;
    string _semantic;
    string _variable;
    ValuePtr _value;
    string _unit;
    string _colorspace;
    string _geomprop;
    ShaderMetadataVecPtr _metadata;
    uint32_t _flags;
};
 
class MX_GENSHADER_API ShaderInput : public ShaderPort
{
  public:
    ShaderInput(ShaderNode* node, const TypeDesc* type, const string& name);
 
    ShaderOutput* getConnection() { return _connection; }
 
    const ShaderOutput* getConnection() const { return _connection; }
 
    void makeConnection(ShaderOutput* src);
 
    void breakConnection();
 
    void setChannels(const string& channels) { _channels = channels; }
 
    const string& getChannels() const { return _channels; }
 
    ShaderNode* getConnectedSibling() const;
 
  protected:
    ShaderOutput* _connection;
    string _channels;
    friend class ShaderOutput;
};
 
class MX_GENSHADER_API ShaderOutput : public ShaderPort
{
  public:
    ShaderOutput(ShaderNode* node, const TypeDesc* type, const string& name);
 
    const ShaderInputVec& getConnections() const { return _connections; }
 
    void makeConnection(ShaderInput* dst);
 
    void breakConnection(ShaderInput* dst);
 
    void breakConnections();
 
  protected:
    ShaderInputVec _connections;
    friend class ShaderInput;
};
 
class MX_GENSHADER_API ShaderNode
{
  public:
    virtual ~ShaderNode() { }
 
    class Classification
    {
      public:
        // Node classes
        static const uint32_t TEXTURE       = 1 << 0;  
        static const uint32_t CLOSURE       = 1 << 1;  
        static const uint32_t SHADER        = 1 << 2;  
        static const uint32_t MATERIAL      = 1 << 3;  
        // Specific texture node types
        static const uint32_t FILETEXTURE   = 1 << 4;  
        static const uint32_t CONDITIONAL   = 1 << 5;  
        static const uint32_t CONSTANT      = 1 << 6;  
        // Specific closure types
        static const uint32_t BSDF          = 1 << 7;  
        static const uint32_t BSDF_R        = 1 << 8;  
        static const uint32_t BSDF_T        = 1 << 9;  
        static const uint32_t EDF           = 1 << 10; 
        static const uint32_t VDF           = 1 << 11; 
        static const uint32_t LAYER         = 1 << 12; 
        static const uint32_t THINFILM      = 1 << 13; 
        // Specific shader types
        static const uint32_t SURFACE       = 1 << 14; 
        static const uint32_t VOLUME        = 1 << 15; 
        static const uint32_t LIGHT         = 1 << 16; 
        static const uint32_t UNLIT         = 1 << 17; 
        // Types based on nodegroup
        static const uint32_t SAMPLE2D      = 1 << 18; 
        static const uint32_t SAMPLE3D      = 1 << 19; 
        static const uint32_t GEOMETRIC     = 1 << 20; 
        static const uint32_t DOT           = 1 << 21; 
    };
 
    static const ShaderNodePtr NONE;
 
    static const string CONSTANT;
    static const string DOT;
    static const string IMAGE;
    static const string SURFACESHADER;
    static const string SCATTER_MODE;
    static const string BSDF_R;
    static const string BSDF_T;
    static const string TRANSFORM_POINT;
    static const string TRANSFORM_VECTOR;
    static const string TRANSFORM_NORMAL;
    static const string TEXTURE2D_GROUPNAME;
    static const string TEXTURE3D_GROUPNAME;
    static const string PROCEDURAL2D_GROUPNAME;
    static const string PROCEDURAL3D_GROUPNAME;
    static const string GEOMETRIC_GROUPNAME;
 
  public:
    ShaderNode(const ShaderGraph* parent, const string& name);
 
    static ShaderNodePtr create(const ShaderGraph* parent, const string& name, const NodeDef& nodeDef,
                                GenContext& context);
 
    static ShaderNodePtr create(const ShaderGraph* parent, const string& name, ShaderNodeImplPtr impl,
                                unsigned int classification = Classification::TEXTURE);
 
    virtual bool isAGraph() const { return false; }
 
    const ShaderGraph* getParent() const
    {
        return _parent;
    }
 
    void setClassification(uint32_t c)
    {
        _classification = c;
    }
 
    uint32_t getClassification() const
    {
        return _classification;
    }
 
    void addClassification(uint32_t c)
    {
        _classification |= c;
    }
 
    bool hasClassification(uint32_t c) const
    {
        return (_classification & c) == c;
    }
 
    const string& getName() const
    {
        return _name;
    }
 
    const ShaderNodeImpl& getImplementation() const
    {
        return *_impl;
    }
 
    void initialize(const Node& node, const NodeDef& nodeDef, GenContext& context);
 
    ShaderInput* addInput(const string& name, const TypeDesc* type);
    ShaderOutput* addOutput(const string& name, const TypeDesc* type);
 
    size_t numInputs() const { return _inputOrder.size(); }
    size_t numOutputs() const { return _outputOrder.size(); }
 
    ShaderInput* getInput(size_t index) { return _inputOrder[index]; }
    ShaderOutput* getOutput(size_t index = 0) { return _outputOrder[index]; }
    const ShaderInput* getInput(size_t index) const { return _inputOrder[index]; }
    const ShaderOutput* getOutput(size_t index = 0) const { return _outputOrder[index]; }
 
    ShaderInput* getInput(const string& name);
    ShaderOutput* getOutput(const string& name);
    const ShaderInput* getInput(const string& name) const;
    const ShaderOutput* getOutput(const string& name) const;
 
    const vector<ShaderInput*>& getInputs() const { return _inputOrder; }
    const vector<ShaderOutput*>& getOutputs() const { return _outputOrder; }
 
    void setMetadata(ShaderMetadataVecPtr metadata) { _metadata = metadata; }
 
    ShaderMetadataVecPtr getMetadata() { return _metadata; }
 
    const ShaderMetadataVecPtr& getMetadata() const { return _metadata; }
 
    bool isEditable(const ShaderInput& input) const
    {
        return (!_impl || _impl->isEditable(input));
    }
 
    bool isEditable(const ShaderGraphInputSocket& input) const
    {
        return (!_impl || _impl->isEditable(input));
    }
 
  protected:
    void createMetadata(const NodeDef& nodeDef, GenContext& context);
 
    const ShaderGraph* _parent;
    string _name;
    uint32_t _classification;
 
    std::unordered_map<string, ShaderInputPtr> _inputMap;
    vector<ShaderInput*> _inputOrder;
 
    std::unordered_map<string, ShaderOutputPtr> _outputMap;
    vector<ShaderOutput*> _outputOrder;
 
    ShaderNodeImplPtr _impl;
    ShaderMetadataVecPtr _metadata;
 
    friend class ShaderGraph;
};
 
MATERIALX_NAMESPACE_END
 
#endif