ShaderGenerator.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_SHADERGENERATOR_H
#define MATERIALX_SHADERGENERATOR_H

 
#include <MaterialXGenShader/Export.h>
 
#include <MaterialXGenShader/ColorManagementSystem.h>
#include <MaterialXGenShader/Exception.h>
#include <MaterialXGenShader/Factory.h>
#include <MaterialXGenShader/ShaderGraphRefactor.h>
#include <MaterialXGenShader/ShaderStage.h>
#include <MaterialXGenShader/Syntax.h>
 
#include <MaterialXFormat/File.h>
 
 
MATERIALX_NAMESPACE_BEGIN

class MX_GENSHADER_API ShaderGenerator
{
  public:
    virtual ~ShaderGenerator() { }

    virtual const string& getTarget() const
    {
        return EMPTY_STRING;
    }

    virtual ShaderPtr generate(const string&, ElementPtr, GenContext&) const
    {
        return nullptr;
    }

    virtual void emitScopeBegin(ShaderStage& stage, Syntax::Punctuation punc = Syntax::CURLY_BRACKETS) const;

    virtual void emitScopeEnd(ShaderStage& stage, bool semicolon = false, bool newline = true) const;

    virtual void emitLineBegin(ShaderStage& stage) const;

    virtual void emitLineEnd(ShaderStage& stage, bool semicolon = true) const;

    virtual void emitLineBreak(ShaderStage& stage) const;

    virtual void emitString(const string& str, ShaderStage& stage) const;

    virtual void emitLine(const string& str, ShaderStage& stage, bool semicolon = true) const;

    virtual void emitComment(const string& str, ShaderStage& stage) const;

    virtual void emitBlock(const string& str, const FilePath& sourceFilename, GenContext& context, ShaderStage& stage) const;

    virtual void emitLibraryInclude(const FilePath& filename, GenContext& context, ShaderStage& stage) const;

    template <typename T>
    void emitValue(const T& value, ShaderStage& stage) const
    {
        stage.addValue<T>(value);
    }

    virtual void emitFunctionDefinition(const ShaderNode& node, GenContext& context, ShaderStage& stage) const;
 
    // Emit the connected variable name for an input and output in a function definition (Used by CompoundNode)
    virtual void emitFunctionDefinitionParameter(const ShaderPort* shaderPort, bool isOutput, GenContext& context, ShaderStage& stage) const;

    virtual void emitFunctionDefinitions(const ShaderGraph& graph, GenContext& context, ShaderStage& stage) const;

    virtual void emitFunctionCall(const ShaderNode& node, GenContext& context, ShaderStage& stage) const;
    [[deprecated]] virtual void emitFunctionCall(const ShaderNode& node, GenContext& context, ShaderStage& stage, bool checkScope) const;

    virtual void emitFunctionCalls(const ShaderGraph& graph, GenContext& context, ShaderStage& stage, uint32_t classification = 0u) const;

    virtual void emitDependentFunctionCalls(const ShaderNode& node, GenContext& context, ShaderStage& stage, uint32_t classification = 0u) const;

    virtual void emitFunctionBodyBegin(const ShaderNode& node, GenContext& context, ShaderStage& stage, Syntax::Punctuation punc = Syntax::CURLY_BRACKETS) const;

    virtual void emitFunctionBodyEnd(const ShaderNode& node, GenContext& context, ShaderStage& stage) const;

    virtual void emitTypeDefinitions(GenContext& context, ShaderStage& stage) const;

    virtual void emitInput(const ShaderInput* input, GenContext& context, ShaderStage& stage) const;

    virtual void emitOutput(const ShaderOutput* output, bool includeType, bool assignValue, GenContext& context, ShaderStage& stage) const;

    virtual void emitVariableDeclarations(const VariableBlock& block, const string& qualifier, const string& separator, GenContext& context, ShaderStage& stage,
                                          bool assignValue = true) const;

    virtual void emitVariableDeclaration(const ShaderPort* variable, const string& qualifier, GenContext& context, ShaderStage& stage,
                                         bool assignValue = true) const;

    virtual bool nodeNeedsClosureData(const ShaderNode& /*node*/) const { return false; }

    virtual void emitClosureDataArg(const ShaderNode& /*node*/, GenContext& /*context*/, ShaderStage& /*stage*/) const {}

    virtual void emitClosureDataParameter(const ShaderNode& /*node*/, GenContext& /*context*/, ShaderStage& /*stage*/) const {}

    virtual string getUpstreamResult(const ShaderInput* input, GenContext& context) const;

    const Syntax& getSyntax() const { return *_syntax; }

    void registerImplementation(const string& name, CreatorFunction<ShaderNodeImpl> creator);

    void registerImplementation(const StringVec& nameVec, CreatorFunction<ShaderNodeImpl> creator);

    bool implementationRegistered(const string& name) const;

    virtual ShaderNodeImplPtr createShaderNodeImplForNodeGraph(const NodeGraph& nodegraph) const;

    virtual ShaderNodeImplPtr createShaderNodeImplForImplementation(const Implementation& implementation) const;

    virtual ShaderNodeImplPtr getImplementation(const NodeDef& nodedef, GenContext& context) const;

    void setColorManagementSystem(ColorManagementSystemPtr colorManagementSystem)
    {
        _colorManagementSystem = colorManagementSystem;
    }

    ColorManagementSystemPtr getColorManagementSystem() const
    {
        return _colorManagementSystem;
    }

    void setUnitSystem(UnitSystemPtr unitSystem)
    {
        _unitSystem = unitSystem;
    }

    UnitSystemPtr getUnitSystem() const
    {
        return _unitSystem;
    }

    TypeSystemPtr getTypeSystem() const
    {
        return _typeSystem;
    }

    const StringMap& getTokenSubstitutions() const
    {
        return _tokenSubstitutions;
    }

    void registerRefactor(ShaderGraphRefactorPtr refactor)
    {
        _refactors.push_back(refactor);
    }

    const vector<ShaderGraphRefactorPtr>& getRefactors() const
    {
        return _refactors;
    }

    virtual void applyDefaultOptions(GenOptions& options) const;

    virtual void registerTypeDefs(const DocumentPtr& doc);

    virtual void registerShaderMetadata(const DocumentPtr& doc, GenContext& context) const;
 
    // Retrieve the string used for the LightData.type member variable
    virtual const string& getLightDataTypevarString() const { return LIGHTDATA_TYPEVAR_STRING; }
 
  protected:
    ShaderGenerator(TypeSystemPtr typeSystem, SyntaxPtr syntax);

    virtual ShaderStagePtr createStage(const string& name, Shader& shader) const;

    void setFunctionName(const string& functionName, ShaderStage& stage) const
    {
        stage.setFunctionName(functionName);
    }

    void replaceTokens(const StringMap& substitutions, ShaderStage& stage) const;

    void createVariables(ShaderGraphPtr graph, GenContext& context, Shader& shader) const;
 
  protected:
    static const string T_FILE_TRANSFORM_UV;
    static const string LIGHTDATA_TYPEVAR_STRING;
 
    TypeSystemPtr _typeSystem;
    SyntaxPtr _syntax;
    Factory<ShaderNodeImpl> _implFactory;
    ColorManagementSystemPtr _colorManagementSystem;
    UnitSystemPtr _unitSystem;
    mutable StringMap _tokenSubstitutions;
    vector<ShaderGraphRefactorPtr> _refactors;
 
    friend ShaderGraph;
};
 
MATERIALX_NAMESPACE_END
 
#endif // MATERIALX_SHADERGENERATOR_H