ExpressionConverter.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 "VisitorTracker.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/Container/Set.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/ShaderCompiler.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/AST/TypeDenoter.hpp"
 
#include <functional>
 
namespace CeresEngine::ShaderCompiler {
 
    class ExpressionConverter : public VisitorTracker {
    private:
        RawFlags mConversionFlags;
        NameMangling mNameMangling;
 
    public:
        // Conversion flags enumeration.
        enum : UInt32 {
            ConvertVectorSubscripts = (1 << 0), // Converts certain vector subscripts to type constructors.
            ConvertVectorCompare = (1 << 1),
            ConvertImageAccess = (1 << 2),
            ConvertImplicitCasts = (1 << 3), // Converts implicit type casts to explicit type casts.
            ConvertInitializerToCtor = (1 << 4), // Converts initializer expressions to type constructors (e.g. "{ 1, 2, 3 }" to "float3(1, 2, 3)").
            ConvertLog10 = (1 << 5), // Converts "log10(x)" to "(log(x) / log(10))".
            ConvertUnaryExpression = (1 << 6), // Wraps an unary expression if it's parent expression is also an unary expression (e.g. "-+x" to "-(+x)").
            ConvertSamplerBufferAccess = (1 << 7),
            ConvertMatrixLayout = (1 << 8), // Converts expressions that depend on the matrix layout (e.g. the argument order of "mul" intrinsic calls).
            ConvertTextureBracketOp = (1 << 9), // Converts Texture Operator[] accesses into "Load" intrinsic calls.
            ConvertTextureIntrinsicVec4 = (1 << 10), // Converts Texture intrinsic calls whose return type is a non-4D-vector.
            ConvertMatrixSubscripts = (1 << 11), // Converts matrix subscripts into function calls to the respective wrapper function.
            ConvertCompatibleStructs = (1 << 12), // Converts type denoters and struct members when the underlying struct type has a compatible struct.
            ConvertLiteralHalfToFloat = (1 << 13), // Converts all half literals to float literals (e.g. "1.5h to 1.5f").
 
            // All conversion flags commonly used before visiting the sub nodes.
            AllPreVisit = (ConvertVectorCompare | ConvertImageAccess | ConvertLog10 | ConvertSamplerBufferAccess | ConvertTextureBracketOp |
                ConvertCompatibleStructs),
 
            // All conversion flags commonly used after visiting the sub nodes.
            AllPostVisit = (ConvertVectorSubscripts | ConvertMatrixSubscripts | ConvertTextureIntrinsicVec4),
 
            // All conversion flags.
            All = (~0u),
        };
 
        // Converts the expressions in the specified AST.
        void convert(Program& program, const RawFlags& conversionFlags, const NameMangling& nameMangling);
 
        static void convertExpressionIfCastRequired(ExpressionPtr& expression, const DataType targetType, bool matchTypeSize = true);
        static void convertExpressionIfCastRequired(ExpressionPtr& expression, const TypeDenoter& targetTypeDen, bool matchTypeSize = true);
 
        // Returns the texture dimension of the specified expression.
        static Int32 getTextureDimFromExpression(Expression* expression, const AST* ast = nullptr);
 
        // Returns the identifier used for matrix subscript wrapper functions.
        static String getMatrixSubscriptWrapperIdent(const NameMangling& nameMangling, const MatrixSubscriptUsage& subscriptUsage);
 
    private: // Visitor implementation
        DECLARATION_VISIT_PROC(VarDeclaration);
 
        DECLARATION_VISIT_PROC(FunctionDeclaration);
 
        DECLARATION_VISIT_PROC(ForLoopStatement);
        DECLARATION_VISIT_PROC(WhileLoopStatement);
        DECLARATION_VISIT_PROC(DoWhileLoopStatement);
        DECLARATION_VISIT_PROC(IfStatement);
        DECLARATION_VISIT_PROC(SwitchStatement);
        DECLARATION_VISIT_PROC(ExpressionStatement);
        DECLARATION_VISIT_PROC(ReturnStatement);
 
        DECLARATION_VISIT_PROC(LiteralExpression);
        DECLARATION_VISIT_PROC(TernaryExpression);
        DECLARATION_VISIT_PROC(BinaryExpression);
        DECLARATION_VISIT_PROC(UnaryExpression);
        DECLARATION_VISIT_PROC(CallExpression);
        DECLARATION_VISIT_PROC(BracketExpression);
        DECLARATION_VISIT_PROC(CastExpression);
        DECLARATION_VISIT_PROC(ObjectExpression);
        DECLARATION_VISIT_PROC(AssignExpression);
        DECLARATION_VISIT_PROC(ArrayExpression);
 
    private: // Conversion
        // Converts the expression according to the specified flags (if enabled in the current conversion).
        void convertExpression(ExpressionPtr& expression, const RawFlags& flags);
 
        // Converts the list of expressions (see ConvertExpression).
        void convertExpressionList(Vector<ExpressionPtr>& expressionList, const RawFlags& flags);
 
        // Converts the expression if a vector subscript is used on a scalar type expression.
        void convertExpressionVectorSubscript(ExpressionPtr& expression);
        void convertExpressionVectorSubscriptObject(ExpressionPtr& expression, const ObjectExpression* objectExpression);
 
        // Converts the expression if a matrix subscript is used.
        void convertExpressionMatrixSubscript(ExpressionPtr& expression);
        void convertExpressionMatrixSubscriptObject(ExpressionPtr& expression, ObjectExpression* objectExpression);
 
        // Converts the expression from a vector comparison to the respective intrinsic call (e.g. "a < b" -> "lessThan(a, b)").
        void convertExpressionVectorCompare(ExpressionPtr& expression);
        void convertExpressionVectorCompareUnary(ExpressionPtr& expression, UnaryExpression* unaryExpression);
        void convertExpressionVectorCompareBinary(ExpressionPtr& expression, BinaryExpression* binaryExpression);
        void convertExpressionVectorCompareTernary(ExpressionPtr& expression, TernaryExpression* ternaryExpression);
 
        // Converts the expression from an image access to the respective intrinsic call (e.g. "image[int2(1, 2)]" -> "imageLoad(image, ivec2(1, 2))").
        void convertExpressionImageAccess(ExpressionPtr& expression);
        void convertExpressionImageAccessAssign(ExpressionPtr& expression, const AssignExpression* assignExpression);
        void convertExpressionImageAccessArray(ExpressionPtr& expression, ArrayExpression* arrayExpression, const AssignExpression* assignExpression = nullptr);
 
        // Converts the expression from a sampler buffer access to the texelFetch intrinsic call (e.g. "buffer[2]" -> "texelFetch(buffer, 2)").
        void convertExpressionSamplerBufferAccess(ExpressionPtr& expression);
        void convertExpressionSamplerBufferAccessArray(ExpressionPtr& expression, ArrayExpression* arrayExpression);
 
        // Converts the expression by moving its sub expression into a bracket (e.g. "-+x" -> "-(+x)").
        void convertExpressionIntoBracket(ExpressionPtr& expression);
 
        // Converts the expression if this is an intrinsic call to "log10" (e.g. "log10(x)" to "(log(x) / log(10))").
        void convertExpressionIntrinsicCallLog10(ExpressionPtr& expression);
 
        // Converts the expression to the specified target type and according to the specified flags (if enabled in the current conversion).
        void convertExpressionTargetType(ExpressionPtr& expression, const TypeDenoter& targetTypeDen, bool matchTypeSize = true);
 
        // Converts the expression from an initializer list to a type constructor.
        void convertExpressionTargetTypeInitializer(ExpressionPtr& expression, const InitializerExpression* initExpression, const TypeDenoter& targetTypeDen);
 
        // Converts the initializer into GLSL-ready form.
        void convertExpressionFormatInitializer(ExpressionPtr& expression, InitializerExpression* initExpression, const TypeDenoter& targetTypeDen);
 
        // Converts the expression from array access to texture object into a "Load" intrinsic call.
        void convertExpressionTextureBracketOp(ExpressionPtr& expression);
 
        // Appends vector subscripts to a texture intrinsic call if the intrinsic return type is not a 4D-vector.
        void convertExpressionTextureIntrinsicVec4(ExpressionPtr& expression);
 
        // Converts the specified expression when it refers to a member variable of a struct that has a compatible struct.
        void convertExpressionCompatibleStruct(const ExpressionPtr& expression);
    };
 
} // namespace CeresEngine::ShaderCompiler