TypeDenoter.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 "ASTEnums.hpp"
#include "Visitor/Visitor.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/Flags.hpp"
#include "CeresEngine/Foundation/SmartPtr.hpp"
#include "CeresEngine/Foundation/String.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/CiString.hpp"
 
#include <memory>
 
namespace CeresEngine::ShaderCompiler {
 
#define DECLARATION_PTR(CLASS_NAME) \
    struct CLASS_NAME;       \
    using CLASS_NAME##Ptr = SPtr<CLASS_NAME>
 
    DECLARATION_PTR(TypeDenoter);
    DECLARATION_PTR(VoidTypeDenoter);
    DECLARATION_PTR(NullTypeDenoter);
    DECLARATION_PTR(BaseTypeDenoter);
    DECLARATION_PTR(BufferTypeDenoter);
    DECLARATION_PTR(SamplerTypeDenoter);
    DECLARATION_PTR(StructTypeDenoter);
    DECLARATION_PTR(AliasTypeDenoter);
    DECLARATION_PTR(ArrayTypeDenoter);
    DECLARATION_PTR(FunctionTypeDenoter);
 
#undef DECLARATION_PTR
 
    // Vector space structure for BaseTypeDenoter, used as language extension for a stronger type system.
    struct VectorSpace {
        using StringType = CiString;
 
        VectorSpace() = default;
        VectorSpace(const StringType& src, const StringType& dst);
        VectorSpace(const StringType& space);
 
        // Returns a descriptive string of this vector space.
        [[nodiscard]] String toString() const;
 
        // Returns true if this vector space is specified, i.e. source and destination are non-empty.
        [[nodiscard]] bool isSpecified() const;
 
        // Returns true if this vector space is a change of basis, i.e. source and destination spaces are different.
        [[nodiscard]] bool isChangeOfBasis() const;
 
        // Returns true if this vector space can be assigned to the specified vector space, i.e. its destination space equals the specified source space.
        [[nodiscard]] bool isAssignableTo(const VectorSpace& rhs) const;
 
        // Sets the source and destination spaces to the specified identifier.
        void set(const StringType& space);
 
        // Sets the source and destination spaces to the specified identifiers.
        void set(const StringType& srcSpace, const StringType& dstSpace);
 
        // Returns the common vector-space from the specified expressions, or throws ASTRuntimeError on failure.
        static VectorSpace findCommonVectorSpace(const Vector<ExpressionPtr>& expressionList, bool ignoreUnspecified = false, const AST* ast = nullptr);
 
        // Copies the vector space of 'srcTypeDen' into 'dstTypeDen' if both types are non-empty and instances of BaseTypeDenoter.
        static void copy(TypeDenoter* dstTypeDen, const TypeDenoter* srcTypeDen);
 
        StringType src; // Source vector space name.
        StringType dst; // Destination vector space name.
    };
 
    bool operator==(const VectorSpace& lhs, const VectorSpace& rhs);
    bool operator!=(const VectorSpace& lhs, const VectorSpace& rhs);
 
    // Type denoter base class.
    struct TypeDenoter : std::enable_shared_from_this<TypeDenoter> {
        // Type denoter class types.
        enum class Types {
            Void,
            Null,
            Base,
            Buffer,
            Sampler,
            Struct,
            Alias,
            Array,
            Function,
        };
 
        // Type denoter comparison flags.
        enum : UInt32 {
            // Ignore generic sub types in a buffer type denoter (for 'Equals' function).
            IgnoreGenericSubType = (1 << 0),
        };
 
        virtual ~TypeDenoter();
 
        // Returns the type (kind) of this type denoter.
        virtual Types getType() const = 0;
 
        // Returns a simple string representation of this type denoter (e.g. "scalar type").
        virtual String toString() const = 0;
 
        // Returns a copy of this type denoter.
        virtual TypeDenoterPtr copy() const = 0;
 
        // Returns true if this (aliased) type denoter is equal to the specified (aliased) type denoter (see GetAliased).
        virtual bool equals(const TypeDenoter& rhs, const RawFlags& compareFlags = 0) const;
 
        // Returns true if this type denoter can be casted to the specified target type denoter (special cases void and base types).
        virtual bool isCastableTo(const TypeDenoter& targetType) const;
 
        // Accumulates the vector size for this type denoter (with a 16 byte boundary), and returns true on success.
        virtual bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr) const;
 
    public: // Shortcuts
        // Shortcut to check if this is a VoidTypeDenoter.
        bool isVoid() const;
 
        // Shortcut to check if this is a NullTypeDenoter.
        bool isNull() const;
 
        // Shortcut to check if this is a BaseTypeDenoter.
        bool isBase() const;
 
        // Shortcut to check if this is a BaseTypeDenoter of a scalar data type (see global function IsScalarType).
        bool isScalar() const;
 
        // Shortcut to check if this is a BaseTypeDenoter of a vector data type (see global function IsVectorType).
        bool isVector() const;
 
        // Shortcut to check if this is a BaseTypeDenoter of a matrix data type (see global function IsMatrixType).
        bool isMatrix() const;
 
        // Shortcut to check if this is a SamplerTypeDenoter.
        bool isSampler() const;
 
        // Shortcut to check if this is a BufferTypeDenoter.
        bool isBuffer() const;
 
        // Shortcut to check if this is a StructTypeDenoter.
        bool isStruct() const;
 
        // Shortcut to check if this is an AliasTypeDenoter.
        bool isAlias() const;
 
        // Shortcut to check if this is an ArrayTypeDenoter.
        bool isArray() const;
 
        // Shortcut to check if this is a FunctionTypeDenoter.
        bool isFunction() const;
 
        // Returns this type denoter as the specified sub class if this type denoter has the correct type. Otherwise, null is returned.
        template<typename T> T* as() { return (getType() == T::classType ? static_cast<T*>(this) : nullptr); }
 
        // Returns this constant type denoter as the specified sub class if this type denoter has the correct type. Otherwise, null is returned.
        template<typename T> const T* as() const { return (getType() == T::classType ? static_cast<const T*>(this) : nullptr); }
 
    public: // Type Derivation
        virtual TypeDenoterPtr getSub(const Expression* expression = nullptr);
 
        // Returns a sub type denoter for the identifier of the specified object expression.
        virtual TypeDenoterPtr getSubObject(const String& ident, const AST* ast = nullptr);
 
        // Returns a sub type denoter for the array indices of the specified array access expression.
        virtual TypeDenoterPtr getSubArray(const std::size_t numArrayIndices, const AST* ast = nullptr);
 
        // Returns either this type denoter or an aliased type.
        virtual const TypeDenoter& getAliased() const;
 
    public: // Type specific functions
        // Returns the type identifier (if it has one), e.g. for structs and type aliases.
        virtual String getIdent() const;
 
        // Sets the identifier of this type denoter if the aliased type is anonymous.
        virtual void setIdentIfAnonymous(const String& ident);
 
        // Returns the number of array dimensions. By default 0.
        virtual UInt32 numDimensions() const;
 
        // Returns a pointer to the AST symbol reference or null if there is no such reference.
        virtual AST* symbolRef() const;
 
        // Returns either this type denoter (if 'arrayDimensions' is empty), or this type denoter as array with the specified dimension expressions.
        virtual TypeDenoterPtr asArray(const Vector<ArrayDimensionPtr>& arrayDimensions);
 
        // Returns the sub type denoter, or null if there is no sub type denoter.
        virtual TypeDenoter* fetchSubTypeDenoter() const;
 
    public:
        // Find the best suitable common type denoter for both left and right hand side type denoters.
        static TypeDenoterPtr findCommonTypeDenoter(const TypeDenoterPtr& lhsTypeDen, const TypeDenoterPtr& rhsTypeDen, bool useMinDimension = false);
 
        // Find the best suitable common type denoter from the left and right hand side expressions, and throws an ASTRuntimeError on failure.
        static TypeDenoterPtr findCommonTypeDenoterFrom(const ExpressionPtr& lhsExpression, const ExpressionPtr& rhsExpression, bool useMinDimension = false, const AST* ast = nullptr);
 
        // Makes a boolean type denoter with the dimension of the specified type denoter.
        static BaseTypeDenoterPtr makeBoolTypeWithDimensionOf(const TypeDenoter& typeDen);
 
        // Returns true if the specified types have an implicit vector truncation (i.e. .
        static Int32 findVectorTruncation(const TypeDenoter& sourceTypeDen, const TypeDenoter& destTypeDen, int& sourceVecSize, int& destVecSize);
    };
 
    // Void type denoter.
    struct VoidTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Void;
 
        Types getType() const override;
        String toString() const override;
        TypeDenoterPtr copy() const override;
 
        // Returns always false, since void type can not be casted to anything.
        bool isCastableTo(const TypeDenoter& targetType) const override;
    };
 
    // Null type denoter.
    struct NullTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Null;
 
        Types getType() const override;
        String toString() const override;
        TypeDenoterPtr copy() const override;
 
        bool isCastableTo(const TypeDenoter& targetType) const override;
    };
 
    // Base type denoter.
    struct BaseTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Base;
 
        BaseTypeDenoter() = default;
        BaseTypeDenoter(const DataType dataType);
 
        Types getType() const override;
        String toString() const override;
        TypeDenoterPtr copy() const override;
 
        bool equals(const TypeDenoter& rhs, const RawFlags& compareFlags = 0) const override;
        bool isCastableTo(const TypeDenoter& targetType) const override;
        bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr) const override;
 
        TypeDenoterPtr getSubObject(const String& ident, const AST* ast = nullptr) override;
        TypeDenoterPtr getSubArray(const std::size_t numArrayIndices, const AST* ast = nullptr) override;
 
        DataType dataType = DataType::Undefined; // Data type of this base type denoter. By default DataType::Undefined.
        VectorSpace vectorSpace; // Vector space of this type denoter.
    };
 
    struct BufferTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Buffer;
 
        BufferTypeDenoter() = default;
        BufferTypeDenoter(const BufferType bufferType);
        BufferTypeDenoter(BufferDeclaration* bufferDeclarationRef);
 
        Types getType() const override;
        String toString() const override;
        TypeDenoterPtr copy() const override;
 
        bool equals(const TypeDenoter& rhs, const RawFlags& compareFlags = 0) const override;
 
        TypeDenoterPtr getSubObject(const String& ident, const AST* ast = nullptr) override;
        TypeDenoterPtr getSubArray(const std::size_t numArrayIndices, const AST* ast = nullptr) override;
 
        AST* symbolRef() const override;
 
        // Returns the generic type denoter of this buffer type.
        TypeDenoter* fetchSubTypeDenoter() const override;
 
        // Always returns a valid generic type denoter. By default BaseTypeDenoter(Float4).
        TypeDenoterPtr getGenericTypeDenoter() const;
 
        BufferType bufferType = BufferType::Undefined;
        TypeDenoterPtr genericTypeDenoter; // May be null
        Int32 genericSize = 1; // Either number of samples in [1, 128) (for multi-sampled textures), or patch size. By default 1.
 
        BufferDeclaration* bufferDeclarationRef = nullptr;
        ImageLayoutFormat layoutFormat = ImageLayoutFormat::Undefined;
    };
 
    // Sampler type denoter.
    struct SamplerTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Sampler;
 
        SamplerTypeDenoter() = default;
        SamplerTypeDenoter(const SamplerType samplerType);
        SamplerTypeDenoter(SamplerDeclaration* samplerDeclarationRef);
 
        Types getType() const override;
        String toString() const override;
        TypeDenoterPtr copy() const override;
 
        bool equals(const TypeDenoter& rhs, const RawFlags& compareFlags = 0) const override;
 
        AST* symbolRef() const override;
 
        SamplerType samplerType = SamplerType::Undefined;
        SamplerDeclaration* samplerDeclarationRef = nullptr;
    };
 
    // Struct type denoter.
    struct StructTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Struct;
 
        StructTypeDenoter() = default;
        StructTypeDenoter(const String& ident);
        StructTypeDenoter(StructDeclaration* structDeclarationRef);
 
        Types getType() const override;
        String toString() const override;
        TypeDenoterPtr copy() const override;
 
        void setIdentIfAnonymous(const String& ident) override;
 
        bool equals(const TypeDenoter& rhs, const RawFlags& compareFlags = 0) const override;
        bool isCastableTo(const TypeDenoter& targetType) const override;
        bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr) const override;
 
        String getIdent() const override;
 
        AST* symbolRef() const override;
 
        TypeDenoterPtr getSubObject(const String& ident, const AST* ast = nullptr) override;
 
        StructDeclaration* getStructDeclarationOrThrow(const AST* ast = nullptr) const;
 
        String ident; // Type identifier
 
        StructDeclaration* structDeclarationRef = nullptr; // Reference to the StructDecl AST node
    };
 
    // Alias type denoter.
    struct AliasTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Alias;
 
        AliasTypeDenoter() = default;
        AliasTypeDenoter(const String& ident);
        AliasTypeDenoter(AliasDeclaration* aliasDeclarationRef);
 
        Types getType() const override;
        String toString() const override;
        TypeDenoterPtr copy() const override;
 
        void setIdentIfAnonymous(const String& ident) override;
 
        bool equals(const TypeDenoter& rhs, const RawFlags& compareFlags = 0) const override;
        bool isCastableTo(const TypeDenoter& targetType) const override;
        bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr) const override;
 
        String getIdent() const override;
 
        TypeDenoterPtr getSub(const Expression* expression = nullptr) override;
        TypeDenoterPtr getSubObject(const String& ident, const AST* ast = nullptr) override;
        TypeDenoterPtr getSubArray(const std::size_t numArrayIndices, const AST* ast = nullptr) override;
 
        const TypeDenoter& getAliased() const override;
 
        // Returns the type denoter of the aliased type, or throws an ASTRuntimeError on failure.
        const TypeDenoterPtr& getAliasedTypeOrThrow(const AST* ast = nullptr) const;
 
        UInt32 numDimensions() const override;
 
        AST* symbolRef() const override;
 
        String ident; // Type identifier
 
        AliasDeclaration* aliasDeclarationRef = nullptr; // Reference to the AliasDecl AST node.
    };
 
    // Array type denoter.
    struct ArrayTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Array;
 
        ArrayTypeDenoter() = default;
 
        ArrayTypeDenoter(const TypeDenoterPtr& subTypeDenoter);
        ArrayTypeDenoter(const TypeDenoterPtr& subTypeDenoter, const Vector<ArrayDimensionPtr>& arrayDimensions);
 
        ArrayTypeDenoter(const TypeDenoterPtr& subTypeDenoter, const Vector<ArrayDimensionPtr>& baseArrayDimensions, const Vector<ArrayDimensionPtr>& subArrayDimensions);
 
        Types getType() const override;
 
        // Throws std::runtime_error if 'subTypeDenoter' is null.
        String toString() const override;
 
        TypeDenoterPtr copy() const override;
 
        TypeDenoterPtr getSubArray(const std::size_t numArrayIndices, const AST* ast = nullptr) override;
 
        bool equals(const TypeDenoter& rhs, const RawFlags& compareFlags = 0) const override;
        bool isCastableTo(const TypeDenoter& targetType) const override;
        bool accumulateAlignedVectorSize(UInt32& size, UInt32& padding, UInt32* offset = nullptr) const override;
 
        // Returns the number if dimensions for this array plus its sub type (if it's also an array).
        UInt32 numDimensions() const override;
 
        AST* symbolRef() const override;
 
        // Returns true if the dimensions of the specified array type denoter are equal to the dimension of this array type denoter.
        bool equalsDimensions(const ArrayTypeDenoter& rhs) const;
 
        // Returns a copy of this type denoter with the accumulated array dimensions.
        TypeDenoterPtr asArray(const Vector<ArrayDimensionPtr>& subArrayDimensions) override;
 
        // Returns the sub type denoter of this struct type.
        TypeDenoter* fetchSubTypeDenoter() const override;
 
        // Inserts the specified sub array type denoter to this type denoter, with all its array dimension, and replaces the base type denoter.
        void insertSubArray(const ArrayTypeDenoter& subArrayTypeDenoter);
 
        // Returns the array dimension sizes.
        Vector<int> getDimensionSizes() const;
 
        // Returns the number of array elements, or 0 if a dynamic array dimension is contained.
        Int32 numArrayElements() const;
 
        TypeDenoterPtr subTypeDenoter; // Sub type denoter
        Vector<ArrayDimensionPtr> arrayDimensions; // Entries may be null
    };
 
    // Function type denoter (currently only used for enhanced error reports).
    struct FunctionTypeDenoter : public TypeDenoter {
        static const Types classType = Types::Function;
 
        FunctionTypeDenoter() = default;
        FunctionTypeDenoter(FunctionDeclaration* funcDeclarationRef);
        FunctionTypeDenoter(const String& ident, const Vector<FunctionDeclaration*>& funcDeclarationRefs);
 
        Types getType() const override;
        String toString() const override;
        TypeDenoterPtr copy() const override;
 
        bool equals(const TypeDenoter& rhs, const RawFlags& compareFlags = 0) const override;
        bool isCastableTo(const TypeDenoter& targetType) const override;
 
        String getIdent() const override;
 
        String ident; // Type identifier
 
        Vector<FunctionDeclaration*> funcDeclarationRefs; // Reference to all function candidates.
    };
 
} // namespace CeresEngine::ShaderCompiler