ShaderStage.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_SHADERSTAGE_H
#define MATERIALX_SHADERSTAGE_H
 
 
#include <MaterialXGenShader/Export.h>
 
#include <MaterialXGenShader/GenOptions.h>
#include <MaterialXGenShader/ShaderGraph.h>
#include <MaterialXGenShader/Syntax.h>
 
#include <MaterialXFormat/File.h>
 
#include <MaterialXCore/Node.h>
 
#include <sstream>
 
// Restrict a scoped block of statements to a specific shader stage, as
// is required for multi-stage shading languages.  Statements within
// the block will only be emitted when processing the given stage.
#define DEFINE_SHADER_STAGE(stage, name) if (stage.getName() == name)
 
// These macros are deprecated, and should be replaced with DEFINE_SHADER_STAGE.
#define BEGIN_SHADER_STAGE(stage, name) \
    if (stage.getName() == name)        \
    {
#define END_SHADER_STAGE(stage, name) }
 
MATERIALX_NAMESPACE_BEGIN
 
namespace Stage
{
 
extern MX_GENSHADER_API const string PIXEL;
 
} // namespace Stage
 
class VariableBlock;
using VariableBlockPtr = std::shared_ptr<VariableBlock>;
using VariableBlockMap = std::unordered_map<string, VariableBlockPtr>;
using ShaderPortPredicate = std::function<bool(ShaderPort*)>;
 
class MX_GENSHADER_API VariableBlock
{
  public:
    VariableBlock(const string& name, const string& instance) :
        _name(name),
        _instance(instance)
    {
    }
 
    const string& getName() const { return _name; }
 
    void setName(const string& name) { _name = name; }
 
    const string& getInstance() const { return _instance; }
 
    void setInstance(const string& instance) { _instance = instance; }
 
    bool empty() const { return _variableOrder.empty(); }
 
    size_t size() const { return _variableOrder.size(); }
 
    ShaderPort* operator[](size_t index) { return _variableOrder[index]; }
 
    const ShaderPort* operator[](size_t index) const { return _variableOrder[index]; }
 
    const vector<ShaderPort*>& getVariableOrder() const { return _variableOrder; }
 
    ShaderPort* operator[](const string& name);
 
    const ShaderPort* operator[](const string& name) const;
 
    ShaderPort* find(const string& name);
 
    const ShaderPort* find(const string& name) const;
 
    ShaderPort* find(const ShaderPortPredicate& predicate);
 
    ShaderPort* add(TypeDesc type, const string& name, ValuePtr value = nullptr, bool shouldWiden = false);
 
    void add(ShaderPortPtr port);
 
  private:
    string _name;
    string _instance;
    std::unordered_map<string, ShaderPortPtr> _variableMap;
    vector<ShaderPort*> _variableOrder;
};
 
class MX_GENSHADER_API ShaderStage
{
  public:
    using FunctionCallId = std::pair<const ShaderNode*, int>;
    struct Scope
    {
        Syntax::Punctuation punctuation;
        std::set<FunctionCallId> functions;
        Scope(Syntax::Punctuation p) :
            punctuation(p) { }
    };
 
  public:
    ShaderStage(const string& name, ConstSyntaxPtr syntax);
 
    const string& getName() const { return _name; }
 
    const string& getFunctionName() const { return _functionName; }
 
    void setSourceCode(const string& code) { _code = code; }
 
    const string& getSourceCode() const { return _code; }
 
    VariableBlockPtr createUniformBlock(const string& name, const string& instance = EMPTY_STRING);
 
    VariableBlockPtr createInputBlock(const string& name, const string& instance = EMPTY_STRING);
 
    VariableBlockPtr createOutputBlock(const string& name, const string& instance = EMPTY_STRING);
 
    VariableBlock& getUniformBlock(const string& name);
 
    const VariableBlock& getUniformBlock(const string& name) const;
 
    VariableBlock& getInputBlock(const string& name);
 
    const VariableBlock& getInputBlock(const string& name) const;
 
    VariableBlock& getOutputBlock(const string& name);
 
    const VariableBlock& getOutputBlock(const string& name) const;
 
    VariableBlock& getConstantBlock();
 
    const VariableBlock& getConstantBlock() const;
 
    const VariableBlockMap& getUniformBlocks() const
    {
        return _uniforms;
    }
 
    const VariableBlockMap& getInputBlocks() const
    {
        return _inputs;
    }
 
    const VariableBlockMap& getOutputBlocks() const
    {
        return _outputs;
    }
 
    const StringSet& getIncludes() const
    {
        return _includes;
    }
 
    const StringSet& getSourceDependencies() const
    {
        return _sourceDependencies;
    }
 
    void beginScope(Syntax::Punctuation punc = Syntax::CURLY_BRACKETS);
 
    void endScope(bool semicolon = false, bool newline = true);
 
    void beginLine();
 
    void endLine(bool semicolon = true);
 
    void newLine();
 
    void addString(const string& str);
 
    void addLine(const string& str, bool semicolon = true);
 
    void addComment(const string& str);
 
    void addBlock(const string& str, const FilePath& sourceFilename, GenContext& context);
 
    void addInclude(const FilePath& includeFilename, const FilePath& sourceFilename, GenContext& context);
 
    bool hasSourceDependency(const FilePath& file);
 
    void addSourceDependency(const FilePath& file);
 
    template <typename T>
    void addValue(const T& value)
    {
        StringStream str;
        str << value;
        _code += str.str();
    }
 
    void addFunctionDefinition(const ShaderNode& node, GenContext& context);
 
    void addFunctionCall(const ShaderNode& node, GenContext& context, bool emitCode = true);
 
    bool isEmitted(const ShaderNode& node, GenContext& context) const;
 
    void setFunctionName(const string& functionName)
    {
        _functionName = functionName;
    }
 
  private:
    const string _name;
 
    string _functionName;
 
    ConstSyntaxPtr _syntax;
 
    int _indentations;
 
    vector<Scope> _scopes;
 
    StringSet _includes;
 
    StringSet _sourceDependencies;
 
    std::set<size_t> _definedFunctions;
 
    VariableBlock _constants;
 
    VariableBlockMap _uniforms;
 
    VariableBlockMap _inputs;
 
    VariableBlockMap _outputs;
 
    string _code;
 
    friend class ShaderGenerator;
};
 
using ShaderStagePtr = std::shared_ptr<ShaderStage>;
 
inline ShaderPort* addStageUniform(const string& block,
                                   TypeDesc type,
                                   const string& name,
                                   ShaderStage& stage)
{
    VariableBlock& uniforms = stage.getUniformBlock(block);
    return uniforms.add(type, name);
}
[[deprecated]] inline ShaderPort* addStageUniform(const string& block,
                                                  const TypeDesc* type,
                                                  const string& name,
                                                  ShaderStage& stage)
{
    return addStageUniform(block, *type, name, stage);
}
 
inline ShaderPort* addStageInput(const string& block,
                                 TypeDesc type,
                                 const string& name,
                                 ShaderStage& stage,
                                 bool shouldWiden = false)
{
    VariableBlock& inputs = stage.getInputBlock(block);
    return inputs.add(type, name, {}, shouldWiden);
}
[[deprecated]] inline ShaderPort* addStageInput(const string& block,
                                                const TypeDesc* type,
                                                const string& name,
                                                ShaderStage& stage,
                                                bool shouldWiden = false)
{
    return addStageInput(block, *type, name, stage, shouldWiden);
}
 
inline ShaderPort* addStageOutput(const string& block,
                                  TypeDesc type,
                                  const string& name,
                                  ShaderStage& stage,
                                  bool shouldWiden = false)
{
    VariableBlock& outputs = stage.getOutputBlock(block);
    return outputs.add(type, name, {}, shouldWiden);
}
[[deprecated]] inline ShaderPort* addStageOutput(const string& block,
                                                 const TypeDesc* type,
                                                 const string& name,
                                                 ShaderStage& stage,
                                                 bool shouldWiden = false)
{
    return addStageOutput(block, *type, name, stage, shouldWiden);
}
 
inline void addStageConnectorBlock(const string& block,
                                   const string& instance,
                                   ShaderStage& from,
                                   ShaderStage& to)
{
    from.createOutputBlock(block, instance);
    to.createInputBlock(block, instance);
}
 
inline void addStageConnector(const string& block,
                              TypeDesc type,
                              const string& name,
                              ShaderStage& from,
                              ShaderStage& to,
                              bool shouldWiden = false)
{
    addStageOutput(block, type, name, from, shouldWiden);
    addStageInput(block, type, name, to, shouldWiden);
}
[[deprecated]] inline void addStageConnector(const string& block,
                                             const TypeDesc* type,
                                             const string& name,
                                             ShaderStage& from,
                                             ShaderStage& to,
                                             bool shouldWiden = false)
{
    addStageConnector(block, *type, name, from, to, shouldWiden);
}
 
MATERIALX_NAMESPACE_END
 
#endif