GLSLGenerator.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Function.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/Container/InitializerList.hpp"
#include "CeresEngine/Foundation/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Set.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/CiString.hpp"
#include "CeresEngine/Material/ShaderCompiler/ShaderCompiler.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/AST.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/ASTEnums.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/Token.hpp"
#include "CeresEngine/Material/ShaderCompiler/Backend/Generator.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/Visitor/Visitor.hpp"
 
#include <functional>
 
namespace CeresEngine::ShaderCompiler {
    struct TypeDenoter;
    struct BaseTypeDenoter;
 
    // GLSL output code generator.
    class GLSLGenerator : public Generator {
    private:
        struct VertexSemanticLoc {
            Int32 location;
            bool found;
        };
 
        OutputShaderVersion mVersionOut = OutputShaderVersion::GLSL;
        NameMangling mNameMangling;
        Map<CiString, VertexSemanticLoc> mVertexSemanticsMap;
        UniformPacking mUniformPacking;
        String mEntryPointName;
 
        bool mAllowExtensions = false;
        bool mExplicitBinding = false;
        bool mPreserveComments = false;
        bool mAllowLineMarks = false;
        bool mCompactWrappers = false;
        bool mAlwaysBracedScopes = false;
        bool mSeparateShaders = false;
        bool mSeparateSamplers = true;
        bool mAutoBinding = false;
        bool mWriteHeaderComment = true;
 
        Set<int> mUsedInLocationsSet;
        Set<int> mUsedOutLocationsSet;
 
        RawFlags mExtensions; // Flags of all enabled language extensions.
 
    public:
        GLSLGenerator(Log* log);
 
    private:
        // Function callback interface for entries in a layout qualifier.
        using LayoutEntryFunctor = FunctionView<void() const>;
 
        void generateCodePrimary(Program& program, const ShaderInput& inputDesc, const ShaderOutput& outputDesc) override;
 
        // Returns the GLSL keyword for the specified system value semantic (special case is Semantic::Target).
        [[nodiscard]] UPtr<String> systemValueToKeyword(const IndexedSemantic& semantic) const;
 
        // Returns true if there is a wrapper function for the specified intrinsic (e.g. "clip" intrinsic).
        [[nodiscard]] bool isWrappedIntrinsic(const Intrinsic intrinsic) const;
 
        // Returns true if the output shader language is GLSL (for OpenGL 2+).
        [[nodiscard]] bool isGLSL() const;
 
        // Returns true if the output shader language is ESSL (for OpenGL ES 2+).
        [[nodiscard]] bool isESSL() const;
 
        // Returns true if the output shader language is VKSL (for Vulkan/SPIR-V).
        [[nodiscard]] bool isVKSL() const;
 
        // Returns true if the output shader language is either GLSL 120 or ESSL 100 which are on a similar feature level.
        [[nodiscard]] bool isGlsL120OrEssL100() const;
 
        // Returns true if the 'GL_ARB_shading_language_420pack' is explicitly available.
        [[nodiscard]] bool hasShadingLanguage420Pack() const;
 
        // Returns true if separate objects for samplers & textures should be used.
        [[nodiscard]] bool useSeparateSamplers() const;
 
        // Returns the GLSL keyword for the specified buffer type or reports and error.
        const String* bufferTypeToKeyword(const BufferType bufferType, const AST* ast = nullptr);
 
        // Returns the GLSL keyword for the specified sampler type or reports and error.
        const String* samplerTypeToKeyword(const SamplerType samplerType, const AST* ast = nullptr);
 
        // Returns true if the specified type denoter is compatible with the semantic (e.g. 'SV_VertexID' is incompatible with 'UInt').
        bool isTypeCompatibleWithSemantic(const Semantic semantic, const TypeDenoter& typeDenoter);
 
        // Report warning of optional reminaing feedback.
        void reportOptionalFeedback();
 
        // Error for intrinsics, that can not be mapped to GLSL keywords.
        void errorIntrinsic(const String& intrinsicName, const AST* ast = nullptr);
 
        // Returns the number of binding locations required by the specified type, or -1 if type is invalid.
        Int32 getNumBindingLocations(const TypeDenoter* typeDenoter);
 
        // Attempts to find an empty binding location for the specified type, or returns -1 if it cannot find one.
        Int32 getBindingLocation(const TypeDenoter* typeDenoter, bool input);
 
    private: // Visitor implementation
        DECLARATION_VISIT_PROC(Program);
        DECLARATION_VISIT_PROC(CodeBlock);
        DECLARATION_VISIT_PROC(SwitchCase);
        DECLARATION_VISIT_PROC(ArrayDimension);
        DECLARATION_VISIT_PROC(TypeSpecifier);
 
        DECLARATION_VISIT_PROC(VarDeclaration);
        DECLARATION_VISIT_PROC(StructDeclaration);
        DECLARATION_VISIT_PROC(SamplerDeclaration);
 
        DECLARATION_VISIT_PROC(FunctionDeclaration);
        DECLARATION_VISIT_PROC(UniformBufferDeclaration);
        DECLARATION_VISIT_PROC(BufferDeclarationStatement);
        DECLARATION_VISIT_PROC(SamplerDeclarationStatement);
        DECLARATION_VISIT_PROC(VarDeclarationStatement);
        DECLARATION_VISIT_PROC(AliasDeclarationStatement);
        DECLARATION_VISIT_PROC(BasicDeclarationStatement);
 
        DECLARATION_VISIT_PROC(NullStatement);
        DECLARATION_VISIT_PROC(CodeBlockStatement);
        DECLARATION_VISIT_PROC(ForLoopStatement);
        DECLARATION_VISIT_PROC(WhileLoopStatement);
        DECLARATION_VISIT_PROC(DoWhileLoopStatement);
        DECLARATION_VISIT_PROC(IfStatement);
        DECLARATION_VISIT_PROC(ElseStatement);
        DECLARATION_VISIT_PROC(SwitchStatement);
        DECLARATION_VISIT_PROC(ExpressionStatement);
        DECLARATION_VISIT_PROC(ReturnStatement);
        DECLARATION_VISIT_PROC(CtrlTransferStatement);
 
        DECLARATION_VISIT_PROC(SequenceExpression);
        DECLARATION_VISIT_PROC(LiteralExpression);
        DECLARATION_VISIT_PROC(TypeSpecifierExpression);
        DECLARATION_VISIT_PROC(TernaryExpression);
        DECLARATION_VISIT_PROC(BinaryExpression);
        DECLARATION_VISIT_PROC(UnaryExpression);
        DECLARATION_VISIT_PROC(PostUnaryExpression);
        DECLARATION_VISIT_PROC(CallExpression);
        DECLARATION_VISIT_PROC(BracketExpression);
        DECLARATION_VISIT_PROC(ObjectExpression);
        DECLARATION_VISIT_PROC(AssignExpression);
        DECLARATION_VISIT_PROC(ArrayExpression);
        DECLARATION_VISIT_PROC(CastExpression);
        DECLARATION_VISIT_PROC(InitializerExpression);
 
        // -----------------------------------------------------------------------------------------
 
    private: // Pre processing AST
        void preProcessAST(const ShaderInput& inputDesc, const ShaderOutput& outputDesc);
        void preProcessStructParameterAnalyzer(const ShaderInput& inputDesc);
        void preProcessTypeConverter();
        void preProcessExpressionConverterPrimary();
        void preProcessGLSLConverter(const ShaderInput& inputDesc, const ShaderOutput& outputDesc);
        void preProcessFuncNameConverter();
        void preProcessReferenceAnalyzer(const ShaderInput& inputDesc);
        void preProcessExpressionConverterSecondary();
        void preProcessPackedUniforms();
 
    private: // Basics
        // Writes a comment (single or multi-line comments).
        void writeComment(const String& text);
 
        void writeLineMark(int lineNumber);
        void writeLineMark(const TokenPtr& token);
        void writeLineMark(const AST* ast);
 
    private: // Program
        void writeProgramHeader();
        void writeProgramHeaderVersion();
        void writeProgramHeaderComment();
        void writeProgramHeaderExtension(const String& extensionName);
 
    private: // Global layouts
        void writeGlobalLayouts();
        bool writeGlobalLayoutsTessControl(const Program::LayoutTessControlShader& layout);
        bool writeGlobalLayoutsTessEvaluation(const Program::LayoutTessEvaluationShader& layout);
        bool writeGlobalLayoutsGeometry(const Program::LayoutGeometryShader& layout);
        bool writeGlobalLayoutsFragment(const Program::LayoutFragmentShader& layout);
        bool writeGlobalLayoutsCompute(const Program::LayoutComputeShader& layout);
 
    private: // Built-in block redeclarations
        void writeBuiltinBlockRedeclarations();
        void writeBuiltinBlockRedeclarationsPerVertex(bool input, const String& name = "");
 
    private: // Layout
        void writeLayout(const InitializerList<LayoutEntryFunctor>& entryFunctors);
        void writeLayout(const String& value);
        void writeLayoutGlobal(const InitializerList<LayoutEntryFunctor>& entryFunctors, const LayoutEntryFunctor& varFunctor, const String& modifier);
        void writeLayoutGlobalIn(const InitializerList<LayoutEntryFunctor>& entryFunctors, const LayoutEntryFunctor& varFunctor = nullptr);
        void writeLayoutGlobalOut(const InitializerList<LayoutEntryFunctor>& entryFunctors, const LayoutEntryFunctor& varFunctor = nullptr);
        void writeLayoutBinding(const Vector<RegisterPtr>& slotRegisters);
        void writeLayoutBindingOrLocation(const Vector<RegisterPtr>& slotRegisters);
        void writeLayoutSet(const Vector<RegisterPtr>& slotRegisters);
 
    private: // Input semantics
        void writeLocalInputSemantics(FunctionDeclaration* entryPoint);
        void writeLocalInputSemanticsVarDeclaration(VarDeclaration* varDeclaration);
        void writeLocalInputSemanticsStructDeclarationParam(VarDeclarationStatement* param, StructDeclaration* structDeclaration);
 
        void writeGlobalInputSemantics(const FunctionDeclaration* entryPoint);
        void writeGlobalInputSemanticsVarDeclaration(VarDeclaration* varDeclaration);
 
    private: // Output semantics
        void writeLocalOutputSemantics(const FunctionDeclaration* entryPoint);
        void writeLocalOutputSemanticsStructDeclarationParam(VarDeclarationStatement* param, const StructDeclaration* structDeclaration);
 
        void writeGlobalOutputSemantics(FunctionDeclaration* entryPoint);
        void writeGlobalOutputSemanticsVarDeclaration(VarDeclaration* varDeclaration, bool useSemanticName = false);
        void writeGlobalOutputSemanticsSlot(TypeSpecifier* typeSpecifier, IndexedSemantic& semantic, const String& ident,
            const VarDeclaration* varDeclaration = nullptr);
 
        void writeOutputSemanticsAssignment(Expression* expression, bool writeAsListedExpression = false);
        void writeOutputSemanticsAssignmentStructDeclarationParam(const FunctionDeclaration::ParameterStructure& paramStruct,
            bool writeAsListedExpression = false,
            const String& tempIdent = "output");
 
    private: // Uniforms
        void writeGlobalUniforms();
        void writeGlobalUniformsParameter(const VarDeclarationStatement* param);
 
        // Writes the specified variable identifier or a system value if the identifier has a system value semantic.
        void writeVarDeclarationIdentOrSystemValue(const VarDeclaration* varDeclaration, Int32 arrayIndex = -1);
 
    private: // Object expression
        void writeObjectExpression(const ObjectExpression& objectExpression);
        void writeObjectExpressionIdent(const ObjectExpression& objectExpression, bool writePrefix = true);
        void writeObjectExpressionIdentOrSystemValue(const ObjectExpression& objectExpression, Declaration* symbol);
 
    private: // Array expression
        void writeArrayExpression(const ArrayExpression& arrayExpression);
        void writeArrayIndices(const Vector<ExpressionPtr>& arrayIndices);
 
    private: // Type denoter
        void writeStorageClasses(const Set<StorageClass>& storageClasses, const AST* ast = nullptr);
        void writeInterpModifiers(const Set<InterpModifier>& interpModifiers, const AST* ast = nullptr);
        void writeTypeModifiers(const Set<TypeModifier>& typeModifiers, const TypeDenoterPtr& typeDenoter = nullptr);
        void writeTypeModifiersFrom(const TypeSpecifierPtr& typeSpecifier);
 
        void writeDataType(DataType dataType, bool writePrecisionSpecifier = false, const AST* ast = nullptr);
 
        void writeTypeDenoter(const TypeDenoter& typeDenoter, bool writePrecisionSpecifier = false, const AST* ast = nullptr);
 
    private: // Function declaration
        void writeFunction(const FunctionDeclaration* ast);
        void writeFunctionEntryPoint(FunctionDeclaration* ast);
        void writeFunctionEntryPointBody(FunctionDeclaration* ast);
        void writeFunctionSecondaryEntryPoint(FunctionDeclaration* ast);
 
    private: // Call expressions
        void assertIntrinsicNumArgs(CallExpression* callExpression, std::size_t numArgsMin, std::size_t numArgsMax = ~0);
 
        void writeCallExpressionStandard(const CallExpression* callExpression);
        void writeCallExpressionIntrinsicMul(CallExpression* callExpression);
        void writeCallExpressionIntrinsicRcp(CallExpression* callExpression);
        void writeCallExpressionIntrinsicClip(CallExpression* callExpression);
        void writeCallExpressionIntrinsicAtomic(CallExpression* callExpression);
        void writeCallExpressionIntrinsicAtomicCompSwap(CallExpression* callExpression);
        void writeCallExpressionIntrinsicImageAtomic(CallExpression* callExpression);
        void writeCallExpressionIntrinsicImageAtomicCompSwap(CallExpression* callExpression);
        void writeCallExpressionIntrinsicStreamOutputAppend(CallExpression* callExpression);
        void writeCallExpressionIntrinsicTextureQueryLod(CallExpression* callExpression, bool clamped);
 
        void writeCallExpressionArguments(const CallExpression* callExpression, std::size_t firstArgIndex = 0, std::size_t numWriteArgs = ~0u);
 
    private: // Intrinsics wrapper
        // Writes all required wrapper functions for referenced intrinsics.
        void writeWrapperIntrinsics();
        void writeWrapperIntrinsicsClip(const IntrinsicUsage& usage);
        void writeWrapperIntrinsicsLit(const IntrinsicUsage& usage);
        void writeWrapperIntrinsicsSinCos(const IntrinsicUsage& usage);
        void writeWrapperIntrinsicsMemoryBarrier(const Intrinsic intrinsic, bool groupSync);
        void writeWrapperIntrinsicsF16toF32();
 
        void writeWrapperMatrixSubscript(const MatrixSubscriptUsage& usage);
 
    private: // Structure
        bool writeStructDeclaration(const StructDeclaration* structDeclaration, bool endWithSemicolon);
 
    private: // BufferDecl
        void writeBufferDeclaration(BufferDeclaration* bufferDeclaration);
        void writeBufferDeclarationTexture(const BufferDeclaration* bufferDeclaration);
        void writeBufferDeclarationStorageBuffer(BufferDeclaration* bufferDeclaration);
 
    private: // SamplerDecl
        void writeSamplerDeclaration(const SamplerDeclaration& samplerDeclaration);
 
    private:
        void writeStatementComment(const Statement* ast, bool insertBlank = false);
 
        template<typename T> void writeStatementList(const Vector<T>& statements, bool isGlobalScope = false);
 
        void writeParameter(const VarDeclarationStatement* ast);
        void writeScopedStatement(Statement* ast);
 
        void writeLiteral(const String& value, const DataType& dataType, const AST* ast = nullptr);
    };
} // namespace CeresEngine::ShaderCompiler