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 <MaterialXGenShader/ShaderGenerator.h>
 
#include <MaterialXFormat/File.h>
 
MATERIALX_NAMESPACE_BEGIN

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;
    }

    TypeDesc getTypeDesc(const string& name) const
    {
        return _sg->getTypeSystem()->getType(name);
    }

    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 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<ConstNodePtr> _parentNodes;
 
    ApplicationVariableHandler _applicationVariableHandler;
};

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