HLSLAnalyzer.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/Container/Map.hpp"
#include "CeresEngine/Foundation/Container/Set.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/ShaderVersion.hpp"
#include "CeresEngine/Material/ShaderCompiler/Variant.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/Frontend/Analyzer.hpp"
 
namespace CeresEngine::ShaderCompiler {
 
    struct HLSLIntrinsicEntry;
 
    // HLSL context analyzer.
    class HLSLAnalyzer : public Analyzer {
    private:
        Program* mProgram = nullptr;
 
        String mEntryPoint;
        String mSecondaryEntryPoint;
        bool mSecondaryEntryPointFound = false;
 
        ShaderTarget mShaderTarget = ShaderTarget::VertexShader;
        InputShaderVersion mVersionIn = InputShaderVersion::HLSL5;
        ShaderVersion mShaderModel = {5, 0};
        bool mPreferWrappers = false;
 
        Set<VarDeclaration*> mVarDeclarationSM3Semantics;
        RawFlags mExtensions;
 
    public:
        HLSLAnalyzer(Log* log = nullptr);
 
    private:
        using OnOverrideProc = ASTSymbolTable::OnOverrideProc;
        using OnValidAttributeValueProc = UniqueFunction<bool(const AttributeValue) const>;
        using OnAssignTypeDenoterProc = UniqueFunction<void(const TypeDenoterPtr&) const>;
 
        struct PrefixArgs {
            bool inIsPostfixStatic;
            StructDeclaration* outPrefixBaseStruct;
        };
 
        void decorateASTPrimary(Program& program, const ShaderInput& inputDesc, const ShaderOutput& outputDesc) override;
 
        void errorIfAttributeNotFound(bool found, const String& attribDesc);
 
        // Returns true, if the input shader version if either HLSL3 or Cg.
        [[nodiscard]] bool isD3D9ShaderModel() const;
 
    private: // Visitor implementation
        DECLARATION_VISIT_PROC(Program);
        DECLARATION_VISIT_PROC(CodeBlock);
        DECLARATION_VISIT_PROC(Attribute);
        DECLARATION_VISIT_PROC(ArrayDimension);
        DECLARATION_VISIT_PROC(TypeSpecifier);
 
        DECLARATION_VISIT_PROC(VarDeclaration);
        DECLARATION_VISIT_PROC(BufferDeclaration);
        DECLARATION_VISIT_PROC(SamplerDeclaration);
        DECLARATION_VISIT_PROC(StructDeclaration);
        DECLARATION_VISIT_PROC(AliasDeclaration);
        DECLARATION_VISIT_PROC(FunctionDeclaration);
 
        DECLARATION_VISIT_PROC(BufferDeclarationStatement);
        DECLARATION_VISIT_PROC(UniformBufferDeclaration);
        DECLARATION_VISIT_PROC(VarDeclarationStatement);
        DECLARATION_VISIT_PROC(BasicDeclarationStatement);
 
        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(UnaryExpression);
        DECLARATION_VISIT_PROC(PostUnaryExpression);
        DECLARATION_VISIT_PROC(CallExpression);
        DECLARATION_VISIT_PROC(AssignExpression);
        DECLARATION_VISIT_PROC(ObjectExpression);
        DECLARATION_VISIT_PROC(ArrayExpression);
 
    private: // Declarations
        void analyzeVarDeclaration(VarDeclaration* varDeclaration);
        void analyzeVarDeclarationLocal(VarDeclaration* varDeclaration, bool registerVarIdent = true);
        void analyzeVarDeclarationStaticMember(VarDeclaration* varDeclaration);
 
    private: // Call expressions
        void analyzeCallExpression(CallExpression* callExpression);
        void analyzeCallExpressionPrimary(CallExpression* callExpression, const TypeDenoter* prefixTypeDenoter = nullptr);
        void analyzeCallExpressionFunction(CallExpression* callExpression, bool isStatic = false, const Expression* prefixExpression = nullptr, const TypeDenoter* prefixTypeDenoter = nullptr);
        void analyzeCallExpressionIntrinsic(CallExpression* callExpression, const HLSLIntrinsicEntry& intr, bool isStatic = false, const TypeDenoter* prefixTypeDenoter = nullptr);
        void analyzeCallExpressionIntrinsicPrimary(CallExpression* callExpression, const HLSLIntrinsicEntry& intr);
        void analyzeCallExpressionIntrinsicFromBufferType(const CallExpression* callExpression, const BufferType bufferType);
 
        void analyzeIntrinsicWrapperInlining(CallExpression* callExpression);
 
    private: // Object expressions
        void analyzeObjectExpression(ObjectExpression* expression, PrefixArgs* args);
        void analyzeObjectExpressionVarDeclarationFromStruct(ObjectExpression* expression, StructDeclaration* baseStructDeclaration, const StructTypeDenoter& structTypeDen);
        void analyzeObjectExpressionBaseStructDeclarationFromStruct(ObjectExpression* expression, PrefixArgs& outputArgs, const StructTypeDenoter& structTypeDen);
 
        bool analyzeStaticAccessExpression(const Expression* prefixExpression, bool isStatic, const AST* ast = nullptr);
        bool analyzeStaticTypeSpecifier(const TypeSpecifier* typeSpecifier, const String& ident, const Expression* expression, bool isStatic);
 
        void analyzeLValueExpression(Expression* expression, const AST* ast = nullptr, VarDeclaration* param = nullptr);
        void analyzeLValueExpressionObject(ObjectExpression* objectExpression, const AST* ast = nullptr, VarDeclaration* param = nullptr);
 
    private: // Array expressions
        void analyzeArrayExpression(ArrayExpression* expression);
 
    private: // Entry point
        void analyzeEntryPoint(FunctionDeclaration* funcDeclaration);
        void analyzeEntryPointInputOutput(FunctionDeclaration* funcDeclaration);
        //void analyzeEntryPointInputOutputGeometryShader(FunctionDecl* funcDecl);
 
        void analyzeEntryPointParameter(FunctionDeclaration* funcDeclaration, const VarDeclarationStatement* param);
        void analyzeEntryPointParameterInOut(FunctionDeclaration* funcDeclaration, VarDeclaration* varDeclaration, bool input, TypeDenoterPtr varTypeDen = nullptr);
        void analyzeEntryPointParameterInOutVariable(FunctionDeclaration* funcDeclaration, VarDeclaration* varDeclaration, bool input);
        void analyzeEntryPointParameterInOutStruct(FunctionDeclaration* funcDeclaration, StructDeclaration* structDeclaration, bool input);
        void analyzeEntryPointParameterInOutBuffer(FunctionDeclaration* funcDeclaration, VarDeclaration* varDeclaration, const BufferTypeDenoter* bufferTypeDen, bool input);
 
        void analyzeEntryPointAttributes(const Vector<AttributePtr>& attribs);
        void analyzeEntryPointAttributesTessControlShader(const Vector<AttributePtr>& attribs);
        void analyzeEntryPointAttributesTessEvaluationShader(const Vector<AttributePtr>& attribs);
        void analyzeEntryPointAttributesGeometryShader(const Vector<AttributePtr>& attribs);
        void analyzeEntryPointAttributesFragmentShader(const Vector<AttributePtr>& attribs);
        void analyzeEntryPointAttributesComputeShader(const Vector<AttributePtr>& attribs);
 
        void analyzeEntryPointSemantics(FunctionDeclaration* funcDeclaration, const Vector<Semantic>& inSemantics, const Vector<Semantic>& outSemantics);
 
        void analyzeEntryPointOutput(Expression* expression);
 
    private: // Secondary entry point
        void analyzeSecondaryEntryPoint(FunctionDeclaration* funcDeclaration, bool isPatchConstantFunc = false);
        void analyzeSecondaryEntryPointAttributes(const Vector<AttributePtr>& attribs);
        void analyzeSecondaryEntryPointAttributesTessEvaluationShader(const Vector<AttributePtr>& attribs);
 
    private: // Attributes
        bool analyzeNumArgsAttribute(const Attribute* attrib, std::size_t minNumArgs, std::size_t maxNumArgs, bool required);
        bool analyzeNumArgsAttribute(const Attribute* attrib, std::size_t expectedNumArgs, bool required = true);
 
        void analyzeAttributeDomain(const Attribute* attrib, bool required = true);
        void analyzeAttributeOutputTopology(const Attribute* attrib, bool required = true);
        void analyzeAttributePartitioning(const Attribute* attrib, bool required = true);
        void analyzeAttributeOutputControlPoints(const Attribute* attrib);
        void analyzeAttributePatchConstantFunc(const Attribute* attrib);
 
        void analyzeAttributeMaxVertexCount(const Attribute* attrib);
 
        void analyzeAttributeNumThreads(const Attribute* attrib);
        void analyzeAttributeNumThreadsArgument(Expression* expression, UInt32& value);
 
        void analyzeAttributeValue(Expression* argExpression, AttributeValue& value, const OnValidAttributeValueProc& expectedValueFunc, const String& expectationDesc,
            bool required = true);
 
        bool analyzeAttributeValuePrimary(Expression* argExpression, AttributeValue& value, const OnValidAttributeValueProc& expectedValueFunc, String& literalValue);
 
    private: // Semantic
        void analyzeSemantic(IndexedSemantic& semantic);
        void analyzeSemanticSM3(IndexedSemantic& semantic, bool input);
        void analyzeSemanticSM3Remaining();
        void analyzeSemanticVarDeclaration(IndexedSemantic& semantic, VarDeclaration* varDeclaration);
        void analyzeSemanticFunctionReturn(IndexedSemantic& semantic);
 
    private: // Language extensions
        void analyzeExtAttributes(const Vector<AttributePtr>& attribs, const TypeDenoterPtr& typeDen);
 
        void analyzeAttributeLayout(const Attribute* attrib, const TypeDenoterPtr& typeDen);
 
        void analyzeAttributeSpace(const Attribute* attrib, const TypeDenoterPtr& typeDen);
        bool analyzeAttributeSpaceIdent(const Attribute* attrib, std::size_t argIndex, String& ident);
 
        void analyzeVectorSpaceAssign(TypedAST* lhs, const TypeDenoter& rhsTypeDen, const OnAssignTypeDenoterProc& assignTypeDenProc = nullptr,
            bool swapAssignOrder = false);
 
    private: // Misc
        void analyzeArrayDimensionList(const Vector<ArrayDimensionPtr>& arrayDimensions);
        void analyzeParameter(VarDeclarationStatement* param);
    };
 
} // namespace CeresEngine::ShaderCompiler