Converter.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/Stack.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/ShaderCompiler.hpp"
#include "CeresEngine/Material/ShaderCompiler/SymbolTable.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/Identifier.hpp"
#include "CeresEngine/Material/ShaderCompiler/AST/TypeDenoter.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/Visitor/VisitorTracker.hpp"
 
namespace CeresEngine::ShaderCompiler {
    class Converter : public VisitorTracker {
    private:
        // Helper class to handle code injection during traversal.
        class StatementScopeHandler {
        private:
            StatementPtr* mStatement = nullptr;
            Vector<StatementPtr>* mStatementList = nullptr;
            std::size_t mIdx = 0;
 
        public:
            StatementScopeHandler(const StatementScopeHandler&) = default;
            StatementScopeHandler& operator=(const StatementScopeHandler&) = default;
 
            StatementScopeHandler(StatementPtr& statement);
            StatementScopeHandler(Vector<StatementPtr>& statements);
 
            // Returns the next statement to visit, or null if there is no more statement.
            Statement* next();
 
            void insertStatementBefore(const StatementPtr& statement);
            void insertStatementAfter(const StatementPtr& statement);
 
        private:
            void ensureStatementList();
 
            void insertStatementAt(const StatementPtr& statement, std::size_t pos);
        };
 
        // Symbol table to determine which variables must be renamed (scope rules are different between HLSL and GLSL).
        SymbolTable<bool> mSymTable;
 
        Program* mProgram = nullptr;
        NameMangling mNameMangling;
 
        // Stack with information of the current 'self' parameter of a member function.
        Vector<VarDeclaration*> mSelfParamStack;
 
        Stack<StatementScopeHandler> mStatementScopeHandlerStack;
        StatementScopeHandler* mStatementScopeHandlerGlobalRef = nullptr;
 
        UInt32 mAnonymCounter = 0;
        UInt32 mObfuscationCounter = 0;
        UInt32 mTempVarCounter = 0;
 
    public:
        // Converts the specified AST for the target language.
        bool convertAST(Program& program, const ShaderInput& inputDesc, const ShaderOutput& outputDesc);
 
    protected:
        virtual void convertASTPrimary(Program& program, const ShaderInput& inputDesc, const ShaderOutput& outputDesc) = 0;
 
    protected: // Symbol table functions
        // Opens a new scope in the smybol table.
        void openScope();
 
        // Closes the current scope in the symbol table.
        void closeScope();
 
        // Registers the AST node in the current scope with the specified identifier.
        void register_(const String& ident);
 
        // Returns the symbol with the specified identifer which is in the deepest scope, or null if there is no such symbol.
        [[nodiscard]] bool fetch(const String& ident) const;
 
        // Returns the symbol with the specified identifer which is in the current scope, or null if there is no such symbol.
        [[nodiscard]] bool fetchFromCurrentScope(const String& ident) const;
 
    protected: // Self parameter
        void pushSelfParameter(VarDeclaration* parameter);
        void popSelfParameter();
 
        [[nodiscard]] VarDeclaration* getActiveSelfParameter() const;
 
    protected: // Name mangling
        // Renames the specified variable declaration with the name mangling temporary-prefix.
        void renameIdent(Identifier& ident);
 
        // Renames the specified identifier to "_{ObfuscationCounter}".
        void renameIdentObfuscated(Identifier& ident);
 
        // Renames the identifier of the specified declaration object.
        void renameIdentOf(Declaration* obj);
 
        // Renames the identifiers of the specified input/output variable declarations.
        void renameIdentOfInOutVarDeclarations(const Vector<VarDeclaration*>& varDeclarations, bool input, bool useSemanticOnly = false);
 
        // Labels the specified anonymous structure.
        void labelAnonymousDeclaration(Declaration* declarationObj);
 
    protected: // Code injection
        // Visits the specified statements, and allows insertion of further statements (i.e. replace the single statement by a code block statement).
        void visitScopedStatement(StatementPtr& statement, void* args = nullptr);
 
        // Visits the specified list of statements, and allows insertion of further statements.
        void visitScopedStatementList(Vector<StatementPtr>& statementList, void* args = nullptr);
 
        // Inserts the specified statement before the current statement.
        void insertStatementBefore(const StatementPtr& statement, bool globalScope = false);
 
        // Inserts the specified statement after the current statement.
        void insertStatementAfter(const StatementPtr& statement, bool globalScope = false);
 
        // Moves all structure declaration within the specified statement list into the respective upper scope.
        void moveNestedStructDeclarations(Vector<StatementPtr>& localStatements, bool globalScope = false);
 
    protected: // Misc
        // Returns true if the variable is a global input/output variable declaration.
        bool isGlobalInOutVarDeclaration(const VarDeclaration* varDeclaration) const;
 
        // Returns true if the specified type denoter is a sampler state type.
        [[nodiscard]] bool isSamplerStateTypeDenoter(const TypeDenoterPtr& typeDenoter) const;
 
        // Removes all statements that are marked as dead code.
        void removeDeadCode(Vector<StatementPtr>& statements);
 
        // Returns an identifier for a new temporary variable.
        String makeTempVarIdent();
 
        // Returns the program AST root node.
        [[nodiscard]] inline Program* getProgram() const { return mProgram; }
 
        // Returns the name mangling settings.
        [[nodiscard]] inline const NameMangling& getNameMangling() const { return mNameMangling; }
 
    private:
        void visitScopedStatementsFromHandler(const StatementScopeHandler& handler, void* args);
 
        StatementScopeHandler& getActiveStatementScopeHandler();
    };
} // namespace CeresEngine::ShaderCompiler