GenContext.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_GENCONTEXT_H
#define MATERIALX_GENCONTEXT_H
 
 
#include <MaterialXGenShader/Export.h>
 
#include <MaterialXGenShader/GenOptions.h>
#include <MaterialXGenShader/GenUserData.h>
#include <MaterialXGenShader/ShaderNode.h>
 
#include <MaterialXFormat/File.h>
 
MATERIALX_NAMESPACE_BEGIN
 
class ClosureContext;
 
using ApplicationVariableHandler = std::function<void(ShaderNode*, GenContext&)>;
 
class MX_GENSHADER_API GenContext
{
  public:
    GenContext(ShaderGeneratorPtr sg);
 
    ShaderGenerator& getShaderGenerator()
    {
        return *_sg;
    }
 
    GenOptions& getOptions()
    {
        return _options;
    }
 
    const GenOptions& getOptions() const
    {
        return _options;
    }
 
    void registerSourceCodeSearchPath(const FilePath& path)
    {
        _sourceCodeSearchPath.append(path);
    }
 
    void registerSourceCodeSearchPath(const FileSearchPath& path)
    {
        _sourceCodeSearchPath.append(path);
    }
 
    FilePath resolveSourceFile(const FilePath& filename, const FilePath& localPath) const
    {
        FileSearchPath searchPath = _sourceCodeSearchPath;
        if (!localPath.isEmpty())
        {
            searchPath.prepend(localPath);
        }
        return searchPath.find(filename).getNormalized();
    }
 
    void addReservedWords(const StringSet& names)
    {
        _reservedWords.insert(names.begin(), names.end());
    }
 
    const StringSet& getReservedWords() const
    {
        return _reservedWords;
    }
 
    void addNodeImplementation(const string& name, ShaderNodeImplPtr impl);
 
    ShaderNodeImplPtr findNodeImplementation(const string& name) const;
 
    void getNodeImplementationNames(StringSet& names);
 
    void clearNodeImplementations();
 
    void pushClosureContext(ClosureContext* cct)
    {
        _closureContexts.push_back(cct);
    }
 
    void popClosureContext()
    {
        if (_closureContexts.size())
        {
            _closureContexts.pop_back();
        }
    }
 
    ClosureContext* getClosureContext()
    {
        return _closureContexts.size() ? _closureContexts.back() : nullptr;
    }
 
    void pushParentNode(ConstNodePtr node)
    {
        _parentNodes.push_back(node);
    }
 
    void popParentNode()
    {
        _parentNodes.pop_back();
    }
 
    const vector<ConstNodePtr>& getParentNodes()
    {
        return _parentNodes;
    }
 
    void pushUserData(const string& name, GenUserDataPtr data)
    {
        auto it = _userData.find(name);
        if (it != _userData.end())
        {
            it->second.push_back(data);
        }
        else
        {
            _userData[name] = { data };
        }
    }
 
    void popUserData(const string& name)
    {
        auto it = _userData.find(name);
        if (it != _userData.end())
        {
            it->second.pop_back();
        }
    }
 
    void clearUserData();
 
    template <class T>
    std::shared_ptr<T> getUserData(const string& name)
    {
        auto it = _userData.find(name);
        return it != _userData.end() && !it->second.empty() ? it->second.back()->asA<T>() : nullptr;
    }
 
    void addInputSuffix(const ShaderInput* input, const string& suffix);
 
    void removeInputSuffix(const ShaderInput* input);
 
    void getInputSuffix(const ShaderInput* input, string& suffix) const;
 
    void addOutputSuffix(const ShaderOutput* output, const string& suffix);
 
    void removeOutputSuffix(const ShaderOutput* output);
 
    void getOutputSuffix(const ShaderOutput* output, string& suffix) const;
 
    void setApplicationVariableHandler(ApplicationVariableHandler handler)
    {
        _applicationVariableHandler = handler;
    }
 
    ApplicationVariableHandler getApplicationVariableHandler() const
    {
        return _applicationVariableHandler;
    }
 
  protected:
    GenContext() = delete;
 
    ShaderGeneratorPtr _sg;
    GenOptions _options;
    FileSearchPath _sourceCodeSearchPath;
    StringSet _reservedWords;
 
    std::unordered_map<string, ShaderNodeImplPtr> _nodeImpls;
    std::unordered_map<string, vector<GenUserDataPtr>> _userData;
    std::unordered_map<const ShaderInput*, string> _inputSuffix;
    std::unordered_map<const ShaderOutput*, string> _outputSuffix;
 
    vector<ClosureContext*> _closureContexts;
    vector<ConstNodePtr> _parentNodes;
 
    ApplicationVariableHandler _applicationVariableHandler;
};
 
class MX_GENSHADER_API ClosureContext
{
  public:
    using Argument = std::pair<TypeDesc, string>;
    using Arguments = vector<Argument>;
 
    using ClosureParams = std::unordered_map<string, const ShaderInput*>;
 
    ClosureContext(int type = 0) :
        _type(type) { }
 
    int getType() const { return _type; }
 
    void addArgument(TypeDesc nodeType, const Argument& arg)
    {
        _arguments[nodeType].push_back(arg);
    }
    [[deprecated]] void addArgument(const TypeDesc* nodeType, const Argument& arg) { addArgument(*nodeType, arg); }
 
    const Arguments& getArguments(TypeDesc nodeType) const
    {
        auto it = _arguments.find(nodeType);
        return it != _arguments.end() ? it->second : EMPTY_ARGUMENTS;
    }
    [[deprecated]] const Arguments& getArguments(const TypeDesc* nodeType) const { return getArguments(*nodeType); }
 
    void setSuffix(TypeDesc nodeType, const string& suffix)
    {
        _suffix[nodeType] = suffix;
    }
    [[deprecated]] void setSuffix(const TypeDesc* nodeType, const string& suffix) { setSuffix(*nodeType, suffix); }
 
    const string& getSuffix(TypeDesc nodeType) const
    {
        auto it = _suffix.find(nodeType);
        return it != _suffix.end() ? it->second : EMPTY_STRING;
    }
    [[deprecated]] const string& getSuffix(const TypeDesc* nodeType) const { return getSuffix(*nodeType); }
 
    void setClosureParams(const ShaderNode* closure, const ClosureParams* params)
    {
        if (params)
        {
            _params[closure] = params;
        }
        else
        {
            _params.erase(closure);
        }
    }
 
    const ClosureParams* getClosureParams(const ShaderNode* closure) const
    {
        auto it = _params.find(closure);
        return it != _params.end() ? it->second : nullptr;
    }
 
  protected:
    const int _type;
    std::unordered_map<TypeDesc, Arguments, TypeDesc::Hasher> _arguments;
    std::unordered_map<TypeDesc, string, TypeDesc::Hasher> _suffix;
    std::unordered_map<const ShaderNode*, const ClosureParams*> _params;
 
    static const Arguments EMPTY_ARGUMENTS;
};
 
class MX_GENSHADER_API ScopedSetClosureParams
{
  public:
    ScopedSetClosureParams(const ClosureContext::ClosureParams* params, const ShaderNode* node, ClosureContext* cct);
 
    ScopedSetClosureParams(const ShaderNode* fromNode, const ShaderNode* toNode, ClosureContext* cct);
 
    ~ScopedSetClosureParams();
 
  private:
    ClosureContext* _cct;
    const ShaderNode* _node;
    const ClosureContext::ClosureParams* _oldParams;
};
 
class MX_GENSHADER_API ScopedSetVariableName
{
  public:
    ScopedSetVariableName(const string& name, ShaderPort* port);
 
    ~ScopedSetVariableName();
 
  private:
    ShaderPort* _port;
    string _oldName;
};
 
MATERIALX_NAMESPACE_END
 
#endif // MATERIALX_GENCONTEXT_H