GLSLConverter.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/Container/Set.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/Backend/Converter.hpp"
 
#include <functional>
 
namespace CeresEngine::ShaderCompiler {
 
    class GLSLConverter : public Converter {
    private:
        ShaderTarget mShaderTarget = ShaderTarget::VertexShader;
        OutputShaderVersion mOutputVersion = OutputShaderVersion::GLSL;
 
        Options mOptions;
        bool mAutoBinding = false;
        Int32 mAutoBindingStartSlot = 0;
        Map<UInt32, Int32> mAutoBindingSlotPerSet;
        bool mSeparateSamplers = true;
 
        Vector<const Declaration*> mGlobalReservedDeclarations;
 
    public:
        static bool convertVarDeclarationType(VarDeclaration& varDeclaration);
        static bool convertVarDeclarationBaseTypeDenoter(VarDeclaration& varDeclaration, const DataType dataType);
 
    private:
        void convertASTPrimary(Program& program, const ShaderInput& inputDesc, const ShaderOutput& outputDesc) override;
 
        // Returns true if the output shader version is VKSL (GLSL for Vulkan).
        [[nodiscard]] bool isVKSL() const;
 
        // Returns true if separate objects for samplers & textures should be used.
        [[nodiscard]] bool useSeparateSamplers() const;
 
    private: // Visitor implementation
        DECLARATION_VISIT_PROC(Program);
        DECLARATION_VISIT_PROC(CodeBlock);
        DECLARATION_VISIT_PROC(SwitchCase);
        DECLARATION_VISIT_PROC(TypeSpecifier);
 
        DECLARATION_VISIT_PROC(VarDeclaration);
        DECLARATION_VISIT_PROC(BufferDeclaration);
        DECLARATION_VISIT_PROC(SamplerDeclaration);
        DECLARATION_VISIT_PROC(StructDeclaration);
 
        DECLARATION_VISIT_PROC(FunctionDeclaration);
        DECLARATION_VISIT_PROC(UniformBufferDeclaration);
        DECLARATION_VISIT_PROC(VarDeclarationStatement);
        DECLARATION_VISIT_PROC(AliasDeclarationStatement);
 
        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(ReturnStatement);
 
        DECLARATION_VISIT_PROC(CastExpression);
        DECLARATION_VISIT_PROC(CallExpression);
        DECLARATION_VISIT_PROC(ObjectExpression);
 
    private: // Scope functions
        // Renames the identifier of the specified declaration object (if required) and registers its identifier.
        void registerDeclarationIdent(Declaration* obj, bool global = false);
 
        // Registers the identifiers of all specified variables (see RegisterDeclIdent).
        void registerGlobalDeclarationIdents(const Vector<VarDeclaration*>& varDeclarations);
 
    private: // Helper functions for conversion
        // Returns true if the specified variable declaration must be renamed.
        bool mustRenameDeclarationIdent(const Declaration* obj) const;
 
        // Removes all variable declarations which have a sampler state type.
        void removeSamplerStateVarDeclarationStatements(Vector<VarDeclarationStatementPtr>& statements);
 
        // Renames the specified identifier if it equals a reserved GLSL intrinsic or function name.
        bool renameReservedKeyword(Identifier& ident);
 
    private: // Function declaration
        void convertFunctionDeclaration(FunctionDeclaration* ast);
        void convertFunctionDeclarationDefault(FunctionDeclaration* ast);
        void convertFunctionDeclarationEntryPoint(FunctionDeclaration* ast);
 
    private: // Call expressions
        void convertIntrinsicCall(CallExpression* ast);
        void convertIntrinsicCallSaturate(CallExpression* ast);
        void convertIntrinsicCallTextureLod(CallExpression* ast);
        void convertIntrinsicCallTextureSample(CallExpression* ast);
        void convertIntrinsicCallTextureSampleLevel(CallExpression* ast);
        void convertIntrinsicCallTextureLoad(CallExpression* ast);
        void convertIntrinsicCallImageAtomic(CallExpression* ast);
        void convertIntrinsicCallGather(CallExpression* ast);
        void convertIntrinsicCallSampleCmp(CallExpression* ast);
        void convertIntrisicCallF32toF16(CallExpression* ast);
        void convertFunctionCall(CallExpression* ast);
 
    private: // Entry point
        void convertEntryPointStructPrefix(ExpressionPtr& expression, ObjectExpression* objectExpression);
        void convertEntryPointStructPrefixObject(ExpressionPtr& expression, const ObjectExpression* prefixExpression, ObjectExpression* objectExpression);
        void convertEntryPointStructPrefixArray(ExpressionPtr& expression, const ArrayExpression* prefixExpression, ObjectExpression* objectExpression);
        void convertEntryPointReturnStatement(ReturnStatement& ast, StructDeclaration* structDeclaration, const TypeDenoterPtr& typeDen, const ExpressionPtr& typeConstructor);
        void convertEntryPointReturnStatementSequenceExpression(ReturnStatement& ast, StructDeclaration* structDeclaration, const TypeDenoterPtr& typeDen,
            const SequenceExpression& typeConstructor);
        void convertEntryPointReturnStatementCommonExpression(ReturnStatement& ast, StructDeclaration* structDeclaration, const TypeDenoterPtr& typeDen,
            const ExpressionPtr& typeConstructor);
 
        //TODO: this should be replaced by the code-injection functionality.
        void convertEntryPointReturnStatementToCodeBlock(StatementPtr& statement);
 
        void addMissingInterpModifiers(const Vector<VarDeclaration*>& varDeclarations);
 
    private: // Object expressions
        void convertObjectExpression(ObjectExpression* objectExpression);
        void convertObjectExpressionStaticVar(ObjectExpression* objectExpression);
        void convertObjectExpressionDefault(ObjectExpression* objectExpression);
        void convertObjectPrefixStructMember(ExpressionPtr& prefixExpression, const StructDeclaration* ownerStructDeclaration, const StructDeclaration* callerStructDeclaration, bool useSelfParam);
        void convertObjectPrefixSelfParam(ExpressionPtr& prefixExpression, const ObjectExpression* objectExpression);
        void convertObjectPrefixBaseStruct(ExpressionPtr& prefixExpression, const ObjectExpression* objectExpression);
        void convertObjectPrefixNamespace(const ExpressionPtr& prefixExpression, ObjectExpression* objectExpression);
        void convertObjectPrefixNamespaceStruct(ObjectExpression* prefixObjectExpression, ObjectExpression* objectExpression, const StructDeclaration* baseStructDeclaration,
            const StructDeclaration* activeStructDeclaration);
 
        void insertBaseMemberPrefixes(ExpressionPtr& prefixExpression, const StructDeclaration* ownerStructDeclaration, const StructDeclaration* callerStructDeclaration);
 
    private: // Unrolling
        void unrollStatements(Vector<StatementPtr>& statements);
        void unrollStatementsVarDeclaration(Vector<StatementPtr>& unrolledStatements, const VarDeclarationStatement* ast);
        void unrollStatementsVarDeclarationInitializer(Vector<StatementPtr>& unrolledStatements, VarDeclaration* varDeclaration);
 
    private:
        void convertSlotRegisters(const Statement* ast, Vector<RegisterPtr>& slotRegisters);
    };
 
} // namespace CeresEngine::ShaderCompiler