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 <map>
#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::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 = const ShaderNode*;
    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