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;
    TypeDesc type;
    ValuePtr value;
    ShaderMetadata(const string& n, 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, 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;
    static const uint32_t AUTHORED_VALUE = 1u << 3;
};

class MX_GENSHADER_API ShaderPort : public std::enable_shared_from_this<ShaderPort>
{
  public:
    ShaderPort(ShaderNode* node, 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(TypeDesc type) { _type = type; }

    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, bool authoredValue = true)
    {
        _value = value;
        setFlag(ShaderPortFlag::AUTHORED_VALUE, authoredValue);
    }

    ValuePtr getValue() const { return _value; }

    string getValueString() const;

    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; }
 
    // Has the value been overridden.
    bool hasAuthoredValue() const { return (_flags & ShaderPortFlag::AUTHORED_VALUE) != 0; }

    void setMetadata(ShaderMetadataVecPtr metadata) { _metadata = metadata; }

    ShaderMetadataVecPtr getMetadata() { return _metadata; }

    const ShaderMetadataVecPtr& getMetadata() const { return _metadata; }
 
  protected:
    ShaderNode* _node;
    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, TypeDesc type, const string& name);

    ShaderOutput* getConnection() { return _connection; }

    const ShaderOutput* getConnection() const { return _connection; }

    void makeConnection(ShaderOutput* src);

    void breakConnection();

    ShaderNode* getConnectedSibling() const;
 
  protected:
    ShaderOutput* _connection;
    string _channels;
    friend class ShaderOutput;
};

class MX_GENSHADER_API ShaderOutput : public ShaderPort
{
  public:
    ShaderOutput(ShaderNode* node, 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 MIX           = 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 BACKSURFACESHADER;
    static const string BSDF_R;
    static const string BSDF_T;
    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 string& getUniqueId() const
    {
        return _uniqueId;
    }

    const ShaderNodeImpl& getImplementation() const
    {
        return *_impl;
    }

    void initialize(const Node& node, const NodeDef& nodeDef, GenContext& context);

    ShaderInput* addInput(const string& name, TypeDesc type);
    ShaderOutput* addOutput(const string& name, 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;
    string _uniqueId;
    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