ASTEnums.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/String.hpp"
#include "CeresEngine/Foundation/Container/Pair.hpp"
#include "CeresEngine/Foundation/Container/Set.hpp"
#include "CeresEngine/Foundation/Container/Vector.hpp"
 
#include "CeresEngine/Material/ShaderCompiler/Reflection.hpp"
 
namespace CeresEngine::ShaderCompiler {
    class Token;
 
    // Assignment operator enumeration:
    // =, +=, -=, *=, /=, %=, <<=, >>=, |= , &=, ^=
    enum class AssignOp {
        Undefined,
 
        Set,
        // =
        Add,
        // +=
        Sub,
        // -=
        Mul,
        // *=
        Div,
        // /=
        Mod,
        // %=
        LShift,
        // <<=
        RShift,
        // >>=
        Or,
        // |=
        And,
        // &=
        Xor,
        // ^=
    };
 
    String assignOpToString(const AssignOp o);
    AssignOp stringToAssignOp(const String& s);
 
    bool isBitwiseOp(const AssignOp o);
 
    // Binary operator enumeration:
    // &&, ||, |, ^, &, <<, >>, +, -, *, /, %, ==, !=, <, >, <=, >=
    enum class BinaryOp {
        Undefined,
 
        LogicalAnd,
        // &&
        LogicalOr,
        // ||
        Or,
        // |
        Xor,
        // ^
        And,
        // &
        LShift,
        // <<
        RShift,
        // >>
        Add,
        // +
        Sub,
        // -
        Mul,
        // *
        Div,
        // /
        Mod,
        // %
        Equal,
        // ==
        NotEqual,
        // !=
        Less,
        // <
        Greater,
        // >
        LessEqual,
        // <=
        GreaterEqual,
        // >=
    };
 
    String binaryOpToString(const BinaryOp o);
    BinaryOp stringToBinaryOp(const String& s);
 
    // Converts the specified assignment operator to an equivalent binary operator, or returns BinaryOp::Undefined if no conversion is possible.
    BinaryOp assignOpToBinaryOp(const AssignOp op);
 
    // Returns true if the specified binary operator is a logical operator (&&, ||).
    bool isLogicalOp(const BinaryOp o);
 
    // Returns true if the specified binary operator is a bitwise operator (|, ^, &, <<, >>).
    bool isBitwiseOp(const BinaryOp o);
 
    // Returns true if the specified binary operator is a comparison operator (==, !=, <, >, <=, >=).
    bool isCompareOp(const BinaryOp o);
 
    // Returns true if the specified binary operator is a boolean operator, i.e. either logical or compare operator.
    bool isBooleanOp(const BinaryOp o);
 
    // Unary operator enumeration:
    // !, ~, +, -, ++, --
    enum class UnaryOp {
        Undefined,
 
        LogicalNot,
        // Logical not (e.g. !x)
        Not,
        // Bitwise not (e.g. ~x)
        Nop,
        // No-op (e.g. +x is equal to x)
        Negate,
        // Negate (e.g. -x)
        Inc,
        // Increment (e.g. ++x)
        Dec,
        // Decrement (e.g. --x)
    };
 
    String unaryOpToString(const UnaryOp o);
    UnaryOp stringToUnaryOp(const String& s);
 
    bool isLogicalOp(const UnaryOp o);
    bool isBitwiseOp(const UnaryOp o);
 
    // Returns true if the specified unary operator is only for l-values (e.g. ++x or --x).
    bool isLValueOp(const UnaryOp o);
 
    // Control transfer enumeration:
    // break, continue, discard
    enum class CtrlTransfer {
        Undefined,
 
        Break,
        Continue,
        Discard,
    };
 
    String ctrlTransformToString(const CtrlTransfer ct);
    CtrlTransfer stringToCtrlTransfer(const String& s);
 
    // Base data type enumeration.
    enum class DataType {
        Undefined,
 
        // MARK: String types
        // HLSL         GLSL
        // -----------------------------------------------------------------------------------------
        String,
        // string       n/a
 
        // MARK: Scalar types
        // HLSL         GLSL
        // -----------------------------------------------------------------------------------------
        Bool,
        // bool         bool
        Int,
        // int          int
        UInt,
        // uint         uint
        Half,
        // half         float
        Float,
        // float        float
        Double,
        // double       double
 
        // MARK: Vector types
        // HLSL         GLSL
        // -----------------------------------------------------------------------------------------
        Bool2,
        // bool2        bvec2
        Bool3,
        // bool3        bvec3
        Bool4,
        // bool4        bvec4
        Int2,
        // int2         ivec2
        Int3,
        // int3         ivec3
        Int4,
        // int4         ivec4
        UInt2,
        // uint2        uvec2
        UInt3,
        // uint3        uvec3
        UInt4,
        // uint4        uvec4
        Half2,
        // half2        vec2
        Half3,
        // half3        vec3
        Half4,
        // half4        vec4
        Float2,
        // float2       vec2
        Float3,
        // float3       vec3
        Float4,
        // float4       vec4
        Double2,
        // double2      dvec2
        Double3,
        // double3      dvec3
        Double4,
        // double4      dvec4
 
        // MARK: Matrix types
        // HLSL         GLSL
        // -----------------------------------------------------------------------------------------
        Bool2x2,
        // bool2x2      n/a
        Bool2x3,
        // bool2x3      n/a
        Bool2x4,
        // bool2x4      n/a
        Bool3x2,
        // bool3x2      n/a
        Bool3x3,
        // bool3x3      n/a
        Bool3x4,
        // bool3x4      n/a
        Bool4x2,
        // bool4x2      n/a
        Bool4x3,
        // bool4x3      n/a
        Bool4x4,
        // bool4x4      n/a
        Int2x2,
        // int2x2       n/a
        Int2x3,
        // int2x3       n/a
        Int2x4,
        // int2x4       n/a
        Int3x2,
        // int3x2       n/a
        Int3x3,
        // int3x3       n/a
        Int3x4,
        // int3x4       n/a
        Int4x2,
        // int4x2       n/a
        Int4x3,
        // int4x3       n/a
        Int4x4,
        // int4x4       n/a
        UInt2x2,
        // uint2x2      n/a
        UInt2x3,
        // uint2x3      n/a
        UInt2x4,
        // uint2x4      n/a
        UInt3x2,
        // uint3x2      n/a
        UInt3x3,
        // uint3x3      n/a
        UInt3x4,
        // uint3x4      n/a
        UInt4x2,
        // uint4x2      n/a
        UInt4x3,
        // uint4x3      n/a
        UInt4x4,
        // uint4x4      n/a
        Half2x2,
        // half2x2      mat2
        Half2x3,
        // half2x3      mat2x3
        Half2x4,
        // half2x4      mat2x4
        Half3x2,
        // half3x2      mat3x2
        Half3x3,
        // half3x3      mat3
        Half3x4,
        // half3x4      mat3x4
        Half4x2,
        // half4x2      mat4x2
        Half4x3,
        // half4x3      mat4x3
        Half4x4,
        // half4x4      mat4
        Float2x2,
        // float2x2     mat2
        Float2x3,
        // float2x3     mat2x3
        Float2x4,
        // float2x4     mat2x4
        Float3x2,
        // float3x2     mat3x2
        Float3x3,
        // float3x3     mat3
        Float3x4,
        // float3x4     mat3x4
        Float4x2,
        // float4x2     mat4x2
        Float4x3,
        // float4x3     mat4x3
        Float4x4,
        // float4x4     mat4
        Double2x2,
        // double2x2    dmat2
        Double2x3,
        // double2x3    dmat2x3
        Double2x4,
        // double2x4    dmat2x4
        Double3x2,
        // double3x2    dmat3x2
        Double3x3,
        // double3x3    dmat3
        Double3x4,
        // double3x4    dmat3x4
        Double4x2,
        // double4x2    dmat4x2
        Double4x3,
        // double4x3    dmat4x3
        Double4x4,
        // double4x4    dmat4
    };
 
    // Container structure for all kinds of matrix subscript usages.
    struct MatrixSubscriptUsage {
        MatrixSubscriptUsage() = default;
        MatrixSubscriptUsage(const DataType dataTypeIn, const String& subscript);
 
        // Strict-weak-order (SWP) comparison.
        bool operator<(const MatrixSubscriptUsage& rhs) const;
 
        // Returns the indices to a unique string.
        [[nodiscard]] String indicesToString() const;
 
        Vector<Pair<int, int>> indices;
        DataType dataTypeIn = DataType::Undefined;
        DataType dataTypeOut = DataType::Undefined;
    };
 
    // Returns a descriptive string of the specified data type.
    String dataTypeToString(const DataType t, bool useTemplateSyntax = false);
 
    // Returns the size (in bytes) of the specified data type, or 0 if the data type is invalid, undefined, or equal to DataType::String.
    UInt32 dataTypeSize(const DataType t);
 
    // Returns true if the specified data type is a scalar type.
    bool isScalarType(const DataType t);
 
    // Returns true if the specified data type is a vector type.
    bool isVectorType(const DataType t);
 
    // Returns true if the specified data type is a matrix type.
    bool isMatrixType(const DataType t);
 
    // Returns true if the specified data type is a boolean type (i.e. bool, and all vectors and matrices of these).
    bool isBooleanType(const DataType t);
 
    // Returns true if the specified data type is a real type (i.e. half, float, double, and all vectors and matrices of these).
    bool isRealType(const DataType t);
 
    // Returns true if the specified data type is a half-precision real type (i.e. half, half2, half4x4 etc.).
    bool isHalfRealType(const DataType t);
 
    // Returns true if the specified data type is a single-precision real type (i.e. float, float2, float4x4 etc.).
    bool isSingleRealType(const DataType t);
 
    // Returns true if the specified data type is a double-precision real type (i.e. double, double2, double4x4 etc.).
    bool isDoubleRealType(const DataType t);
 
    // Returns true if the specified data type is an integral type (i.e. int, uint, and all vectors and matrices of these).
    bool isIntegralType(const DataType t);
 
    // Returns true if the specified data type is an integer type (i.e. int, and all vectors and matrices of these).
    bool isIntType(const DataType t);
 
    // Returns true if the specified data type is an unsigned-integer type (i.e. uint, and all vectors and matrices of these).
    bool isUIntType(const DataType t);
 
    Int32 vectorTypeDim(const DataType t);
 
    Pair<int, int> matrixTypeDim(const DataType t);
 
    // Returns the base data type for the specified type or DataType::Undefined on failure.
    DataType baseDataType(const DataType t);
 
    // Returns the vector data type for the specified type and vector size.
    DataType vectorDataType(const DataType baseDataType, Int32 vectorSize);
 
    // Returns the matrix data type for the specified type, rows, and columns.
    DataType matrixDataType(const DataType baseDataType, Int32 rows, Int32 columns);
 
    // Returns the data type for the specified swizzle operator or throws and std::invalid_argument on failure.
    DataType subscriptDataType(const DataType dataType, const String& subscript, Vector<Pair<int, int>>* indices = nullptr);
 
    // Returns the data type for the specified literal token (BoolLiteral, IntLiteral, FloatLiteral, and StringLiteral).
    DataType tokenToDataType(const Token& token);
 
    // Returns the data type as non-double (i.e. replaces doubles by floats).
    DataType doubleToFloatDataType(const DataType dataType);
 
    // Returns the remaining size (in bytes) of a vector slot with the specified alignment.
    UInt32 remainingVectorSize(UInt32 vectorSize, UInt32 alignment = 16u);
 
    // Accumulates the vector size for the specified data type (with a 16 byte boundary), and returns true on success.
    bool accumulateAlignedVectorSize(const DataType dataType, UInt32& size, UInt32& padding, UInt32* offset = nullptr);
 
    // Primitive type enumeration.
    enum class PrimitiveType {
        Undefined,
 
        Point,
        // Point
        Line,
        // Line
        LineAdj,
        // Line adjacency
        Triangle,
        // Triangle
        TriangleAdj,
        // Triangle adjacency
    };
 
    // Variable storage class enumeration.
    enum class StorageClass {
        Undefined,
 
        Extern,
        Precise,
        Shared,
        GroupShared,
        Static,
        Volatile,
    };
 
    // Variable interpolation modifier enumeration.
    enum class InterpModifier {
        Undefined,
 
        // HLSL             GLSL
        // -----------------------------------------------------------------------------------------
        Centroid,
        // centroid         centroid
        Linear,
        // linear           smooth
        NoInterpolation,
        // nointerpolation  flat
        NoPerspective,
        // noperspective    noperspective
        Sample,
        // sample           sample
    };
 
    // Variable type modifier enumeration.
    enum class TypeModifier {
        Undefined,
 
        Const,
        RowMajor,
        ColumnMajor,
 
        SNorm,
        UNorm,
    };
 
    enum class UniformBufferType {
        Undefined,
 
        ConstantBuffer,
        // Constant buffer ("cbuffer" in HLSL; "uniform" in GLSL).
        TextureBuffer,
        // Texture buffer ("tbuffer" in HLSL).
    };
 
    // Buffer (and texture) object type enumeration.
    enum class BufferType {
        Undefined,
 
        // MARK: Storage Buffers
        Buffer,
        StructuredBuffer,
        ByteAddressBuffer,
 
        RWBuffer,
        RWStructuredBuffer,
        RWByteAddressBuffer,
        AppendStructuredBuffer,
        ConsumeStructuredBuffer,
 
        // MARK: Textures
        RWTexture1D,
        RWTexture1DArray,
        RWTexture2D,
        RWTexture2DArray,
        RWTexture3D,
 
        Texture1D,
        Texture1DArray,
        Texture2D,
        Texture2DArray,
        Texture3D,
        TextureCube,
        TextureCubeArray,
        Texture2DMS,
        Texture2DMSArray,
 
        GenericTexture,
        // Texture of unspecified dimension (used in DX9 effect files: "texture" keyword).
 
        // MARK: Patches
        InputPatch,
        OutputPatch,
 
        // MARK: Streams
        PointStream,
        LineStream,
        TriangleStream,
 
        // MARK: Generic Buffers
        GenericBuffer,
        // GLSL "buffer"
    };
 
    // Converts the specified BufferType enumeration entry into a string.
    String bufferTypeToString(const BufferType t);
 
    // Returns true if the specified buffer type is a storage buffer type (i.e. gets converted to a 'buffer' block in GLSL).
    bool isStorageBufferType(const BufferType t);
 
    // Returns true if the specified buffer type is a RW (read/write) buffer type (for storage buffers and textures).
    bool isRwBufferType(const BufferType t);
 
    // Returns true if the specified buffer type is a texture buffer.
    bool isTextureBufferType(const BufferType t);
 
    // Returns true if the specified buffer type is a multi-sampled texture buffer (i.e. Texture2DMS or Texture2DMSArray).
    bool isTextureMsBufferType(const BufferType t);
 
    // Returns true if the specified buffer type is an image buffer (i.e. gets converted to an 'imageBuffer' in GLSL).
    bool isImageBufferType(const BufferType t);
 
    // Returns true if the specified buffer type is a RW (read/write) texture buffer type (represented in GLSL with 'image...').
    bool isRwImageBufferType(const BufferType t);
 
    // Returns true if the specified buffer type is an input or output patch.
    bool isPatchBufferType(const BufferType t);
 
    // Returns true if the specified buffer type is either a point-, line-, or triangle stream.
    bool isStreamBufferType(const BufferType t);
 
    // Returns the texture dimension of the specified buffer type in the range [1, 4] or 0 if the type is not a texture type.
    Int32 getBufferTypeTextureDim(const BufferType t);
 
    // Sampler type enumeration.
    enum class SamplerType {
        Undefined,
 
        // MARK: Samplers
        // HLSL3            HLSL4+                  GLSL
        // -----------------------------------------------------------------------------------------
        Sampler1D,
        // sampler1D        n/a                     sampler1D
        Sampler2D,
        // sampler2D        n/a                     sampler2D
        Sampler3D,
        // sampler3D        n/a                     sampler3D
        SamplerCube,
        // samplerCUBE      n/a                     samplerCube
        Sampler2DRect,
        // n/a              n/a                     sampler2DRect
        Sampler1DArray,
        // n/a              n/a                     sampler1DArray
        Sampler2DArray,
        // n/a              n/a                     sampler2DArray
        SamplerCubeArray,
        // n/a              n/a                     samplerCubeArray
        SamplerBuffer,
        // n/a              n/a                     samplerBuffer
        Sampler2DMS,
        // n/a              n/a                     sampler2DMS
        Sampler2DMSArray,
        // n/a              n/a                     sampler2DMSArray
        Sampler1DShadow,
        // sampler1DShadow  n/a                     sampler1DShadow
        Sampler2DShadow,
        // sampler2DShadow  n/a                     sampler2DShadow
        SamplerCubeShadow,
        // n/a              n/a                     samplerCubeShadow
        Sampler2DRectShadow,
        // n/a              n/a                     sampler2DRectShadow
        Sampler1DArrayShadow,
        // n/a              n/a                     sampler1DArrayShadow
        Sampler2DArrayShadow,
        // n/a              n/a                     sampler2DArrayShadow
        SamplerCubeArrayShadow,
        // n/a              n/a                     samplerCubeArrayShadow
 
        // MARK: Sampler states
        // HLSL3            HLSL4+                  GLSL
        // -----------------------------------------------------------------------------------------
        SamplerState,
        // sampler_state    SamplerState            sampler
        SamplerComparisonState,
        // sampler_state    SamplerComparisonState  samplerShadow
    };
 
    // Returns true if the specified sampler type is sampler state (i.e. SamplerState or SamplerComparisonState).
    bool isSamplerStateType(const SamplerType t);
 
    // Returns true if the specified sampler type is a shadow sampler (e.g. Sampler1DShadow).
    bool isSamplerTypeShadow(const SamplerType t);
 
    // Returns true if the specified sampler type is an array sampler (e.g. Sampler1DArray).
    bool isSamplerTypeArray(const SamplerType t);
 
    // Returns the texture dimension of the specified sampler type in the range [1, 4] or 0 if the type is not a texture sampler (e.g. a sampler state).
    Int32 getSamplerTypeTextureDim(const SamplerType t);
 
    // Maps a texture type to an appropriate sampler type.
    SamplerType textureTypeToSamplerType(const BufferType t);
 
    // Converts a non-shadow sampler variant into a shadow one, if possible.
    SamplerType samplerTypeToShadowSamplerType(const SamplerType t);
 
    // Image layout format enumeration.
    enum class ImageLayoutFormat {
        Undefined,
 
        // MARK: Float formats
        F32X4,
        // rgba32f
        F32X2,
        // rg32f
        F32X1,
        // r32f
        F16X4,
        // rgba16f
        F16X2,
        // rg16f
        F16X1,
        // r16f
        F11R11G10B,
        // r11f_g11f_b10f
 
        // MARK: Unsigned normalized formats
        UN32X4,
        // rgba16
        UN16X2,
        // rg16
        UN16X1,
        // r16
        UN10R10G10B2A,
        // rgb10_a2
        UN8X4,
        // rgba8
        UN8X2,
        // rg8
        UN8X1,
        // r8
 
        // MARK: Signed normalized formats
        SN16X4,
        // rgba16_snorm
        SN16X2,
        // rg16_snorm
        SN16X1,
        // r16_snorm
        SN8X4,
        // rgba8_snorm
        SN8X2,
        // rg8_snorm
        SN8X1,
        // r8_snorm
 
        // MARK: Signed integer formats
        I32X4,
        // rgba32i
        I32X2,
        // rg32i
        I32X1,
        // r32i
        I16X4,
        // rgba16i
        I16X2,
        // rg16i
        I16X1,
        // r16i
        I8X4,
        // rgba8i
        I8X2,
        // rg8i
        I8X1,
        // r8i
 
        // MARK: UInt32eger formats
        UI32X4,
        // rgba32ui
        UI32X2,
        // rg32ui
        UI32X1,
        // r32ui
        UI16X4,
        // rgba16ui
        UI16X2,
        // rg16ui
        UI16X1,
        // r16ui
        UI10R10G10B2A,
        // rgb10_a2ui
        UI8X4,
        // rgba8ui
        UI8X2,
        // rg8ui
        UI8X1,
        // r8ui
    };
 
    // Returns the base type of a single component in the specified image layout format.
    DataType getImageLayoutFormatBaseType(const ImageLayoutFormat format);
 
    // Returns the image layout format for the specified data type or ImageLayoutFormat::Undefined.
    ImageLayoutFormat dataTypeToImageLayoutFormat(const DataType t);
 
    // Register type enumeration.
    enum class RegisterType {
        Undefined,
 
        ConstantBuffer,
        // 'b'-register
        TextureBuffer,
        // 't'-register
        BufferOffset,
        // 'c'-register
        Sampler,
        // 's'-register
        UnorderedAccessView,
        // 'u'-register
    };
 
    // Returns the register type for the specified register character (e.g. 'b' for ConstantBuffer).
    RegisterType charToRegisterType(char c);
 
    // Returns the respective register character for the specified register type (e.g. 'b' for ConstantBuffer).
    char registerTypeToChar(const RegisterType t);
 
    // Returns a descriptive string for the specified register type.
    String registerTypeToString(const RegisterType t);
 
    // Attribute type enumeration (TODO: incomplete list).
    enum class AttributeType {
        Undefined,
 
        // MARK: HLSL 3 attributes
        Branch,
        // [branch]
        Call,
        // [call]
        Flatten,
        // [flatten]
        IfAll,
        // [ifAll]
        IfAny,
        // [ifAny]
        Isolate,
        // [isolate]
        Loop,
        // [loop]
        MaxExports,
        // [maxexports(N)]
        MaxInstructionCount,
        // [maxInstructionCount(N)]
        MaxTempReg,
        // [maxtempreg(N)]
        NoExpressionOptimizations,
        // [noExpressionOptimizations]
        Predicate,
        // [predicate]
        PredicateBlock,
        // [predicateBlock]
        ReduceTempRegUsage,
        // [reduceTempRegUsage(N)]
        RemoveUnusedInputs,
        // [removeUnusedInputs]
        SampReg,
        // [sampreg(N, M)]
        Unroll,
        // [unroll(MaxIterationCount)]
        Unused,
        // [unused]
        Xps,
        // [xps]
 
        // MARK: HLSL 4+ attributes
        Domain,
        // [domain(STRING)]
        EarlyDepthStencil,
        // [earlydepthstencil]
        Instance,
        // [instance(N)]
        MaxTessFactor,
        // [maxtessfactor(X)]
        MaxVertexCount,
        // [maxvertexcount(N)]
        NumThreads,
        // [numthreads(X, Y, Z)]
        OutputControlPoints,
        // [outputcontrolpoints(N)]
        OutputTopology,
        // [outputtopology(STRING)]
        Partitioning,
        // [partitioning(STRING)]
        PatchSize,
        // [patchsize(N)]
        PatchConstantFunc,
        // [patchconstantfunc(STRING)]
 
        // MARK: GLSL Layout Attributes
        Align,
        // layout(align = <EXPRESSION>)
        Binding,
        // layout(binding = <EXPRESSION>)
        CW,
        // layout(cw)
        CCW,
        // layout(ccw)
        ColumnMajor,
        // layout(column_major)
        Component,
        // layout(component = <EXPRESSION>)
        DepthAny,
        // layout(depth_any)
        DepthGreater,
        // layout(depth_greater)
        DepthLess,
        // layout(depth_less)
        DepthUnchanged,
        // layout(depth_unchanged)
        EarlyFragmentTests,
        // layout(early_fragment_tests)
        EqualSpacing,
        // layout(equal_spacing)
        FractionalEvenSpacing,
        // layout(fractional_even_spacing)
        FractionalOddSpacing,
        // layout(fractional_odd_spacing)
        Index,
        // layout(index = <EXPRESSION>)
        Invocations,
        // layout(invocations = <EXPRESSION>)
        Isolines,
        // layout(isolines)
        Lines,
        // layout(lines)
        LinesAdjacency,
        // layout(lines_adjacency)
        LineStrip,
        // layout(line_strip)
        LocalSizeX,
        // layout(local_size_x = <EXPRESSION>)
        LocalSizeY,
        // layout(local_size_y = <EXPRESSION>)
        LocalSizeZ,
        // layout(local_size_z = <EXPRESSION>)
        Location,
        // layout(location = <EXPRESSION>)
        MaxVertices,
        // layout(max_vertices = <EXPRESSION>)
        OriginUpperLeft,
        // layout(origin_upper_left)
        Offset,
        // layout(offset = <EXPRESSION>)
        Packed,
        // layout(packed)
        PixelCenterInteger,
        // layout(pixel_center_integer)
        Points,
        // layout(points)
        PointMode,
        // layout(point_mode)
        Quads,
        // layout(quads)
        RowMajor,
        // layout(row_major)
        Shared,
        // layout(shared)
        Std140,
        // layout(std140)
        Std430,
        // layout(std430)
        Stream,
        // layout(stream = <EXPRESSION>)
        Triangles,
        // layout(triangles)
        TrianglesAdjacency,
        // layout(triangles_adjacency)
        TriangleStrip,
        // layout(triangle_strip)
        Vertices,
        // layout(vertices = <EXPRESSION>)
        XfbBuffer,
        // layout(xfb_buffer = <EXPRESSION>)
        XfbOffset,
        // layout(xfb_offset = <EXPRESSION>)
        XfbStride,
        // layout(xfb_stride = <EXPRESSION>)
        Set,
        // layout(set = <EXPRESSION>)
 
        // MARK: Extended Attributes
        Space,
        // Extended attribute to specify a vector space.
        Layout,
        // Extended attribute to specify a layout format.
    };
 
    // Returns true if the specified attribute is supported since shader model 3.
    bool isShaderModel3AttributeType(const AttributeType t);
 
    // Returns true if the specified attribute is supported since shader model 5.
    bool isShaderModel5AttributeType(const AttributeType t);
 
    // Returns true if the specified attribute is supported only in HLSL, e.g. [ATTRIBUTE].
    bool isHLSLAttributeType(const AttributeType t);
 
    // Returns true if the specified attribute is supported only in GLSL, e.g. layout(ATTRIBUTE).
    bool isGLSLAttributeType(const AttributeType t);
 
    // Returns true if the specified attribute is an extended attribute, i.e. AttributeType::Space, AttributeType::Layout.
    bool isExtAttributeType(const AttributeType t);
 
    // Value enumeration of required attributes (e.g. domain types for tess.-control shader).
    enum class AttributeValue {
        Undefined,
 
        DomainTri,
        DomainQuad,
        DomainIsoline,
 
        OutputTopologyPoint,
        OutputTopologyLine,
        OutputTopologyTriangleCW,
        OutputTopologyTriangleCCW,
 
        PartitioningInteger,
        PartitioningPow2,
        PartitioningFractionalEven,
        PartitioningFractionalOdd,
    };
 
    // Returns true if the specified attribute value belongs to the 'domain' attribute.
    bool isAttributeValueDomain(const AttributeValue t);
 
    // Returns true if the specified attribute value belongs to the 'outputtopology' attribute.
    bool isAttributeValueOutputTopology(const AttributeValue t);
 
    // Returns true if the specified attribute value belongs to the 'partitioning' attribute.
    bool isAttributeValuePartitioning(const AttributeValue t);
 
    // Returns true if the specified attribute value is a triangle 'partitioning' attribute, i.e. either OutputTopologyTriangleCW or OutputTopologyTriangleCCW.
    bool isAttributeValueTrianglePartitioning(const AttributeValue t);
 
    enum class Intrinsic {
        Undefined,
 
        // MARK: Common global intrinsics
        // HLSL                                 GLSL
        // -----------------------------------------------------------------------------------------
        Abort,
        // abort                                n/a
        Abs,
        // abs                                  abs
        ACos,
        // acos                                 acos
        All,
        // all                                  all
        AllMemoryBarrier,
        // AllMemoryBarrier                     memoryBarrier
        AllMemoryBarrierWithGroupSync,
        // AllMemoryBarrierWithGroupSync        n/a
        Any,
        // any                                  any
        AsDouble,
        // asdouble                             uint64BitsToDouble
        AsFloat,
        // asfloat                              uintBitsToFloat
        ASin,
        // asin                                 asin
        AsInt,
        // asint                                floatBitsToInt
        AsUInt1,
        // asuint                               floatBitsToUint
        AsUInt3,
        // asuint                               n/a
        ATan,
        // atan                                 atan
        ATan2,
        // atan2                                atan
        Ceil,
        // ceil                                 cail
        CheckAccessFullyMapped,
        // CheckAccessFullyMapped               n/a
        Clamp,
        // clamp                                clamp
        Clip,
        // clip                                 n/a
        Cos,
        // cos                                  cos
        CosH,
        // cosh                                 cosh
        CountBits,
        // countbits                            bitCount
        Cross,
        // cross                                cross
        D3DCOLORtoUBYTE4,
        // D3DCOLORtoUBYTE4                     n/a
        DDX,
        // ddx                                  dFdx
        DDXCoarse,
        // ddx_coarse                           dFdxCoarse
        DDXFine,
        // ddx_fine                             dFdxFine
        DDY,
        // ddy                                  dFdy
        DDYCoarse,
        // ddy_coarse                           dFdyCoarse
        DDYFine,
        // ddy_fine                             dFdyFine
        Degrees,
        // degrees                              degrees
        Determinant,
        // determinant                          determinant
        DeviceMemoryBarrier,
        // DeviceMemoryBarrier                  n/a
        DeviceMemoryBarrierWithGroupSync,
        // DeviceMemoryBarrierWithGroupSync     n/a
        Distance,
        // distance                             distance
        Dot,
        // dot                                  dot
        Dst,
        // dst                                  n/a
        Equal,
        // n/a                                  equal
        ErrorF,
        // errorf                               n/a
        EvaluateAttributeAtCentroid,
        // EvaluateAttributeAtCentroid          interpolateAtCentroid
        EvaluateAttributeAtSample,
        // EvaluateAttributeAtSample            interpolateAtSample
        EvaluateAttributeSnapped,
        // EvaluateAttributeSnapped             interpolateAtOffset
        Exp,
        // exp                                  exp
        Exp2,
        // exp2                                 exp2
        F16toF32,
        // f16tof32                             n/a
        F32toF16,
        // f32tof16                             n/a
        FaceForward,
        // faceforward                          faceforward
        FirstBitHigh,
        // firstbithigh                         findMSB
        FirstBitLow,
        // firstbitlow                          findLSB
        Floor,
        // floor                                floor
        FMA,
        // fma                                  fma
        FMod,
        // fmod                                 mod
        Frac,
        // frac                                 fract
        FrExp,
        // frexp                                frexp
        FWidth,
        // fwidth                               fwidth
        GetRenderTargetSampleCount,
        // GetRenderTargetSampleCount           n/a
        GetRenderTargetSamplePosition,
        // GetRenderTargetSamplePosition        n/a
        GreaterThan,
        // n/a                                  greaterThan
        GreaterThanEqual,
        // n/a                                  greaterThanEqual
        GroupMemoryBarrier,
        // GroupMemoryBarrier                   groupMemoryBarrier
        GroupMemoryBarrierWithGroupSync,
        // GroupMemoryBarrierWithGroupSync      n/a
        InterlockedAdd,
        // InterlockedAdd                       atomicAdd
        InterlockedAnd,
        // InterlockedAnd                       atomicAnd
        InterlockedCompareExchange,
        // InterlockedCompareExchange           atomicCompSwap
        InterlockedCompareStore,
        // InterlockedCompareStore              n/a
        InterlockedExchange,
        // InterlockedExchange                  atomicExchange
        InterlockedMax,
        // InterlockedMax                       atomicMax
        InterlockedMin,
        // InterlockedMin                       atomicMin
        InterlockedOr,
        // InterlockedOr                        atomicOr
        InterlockedXor,
        // InterlockedXor                       atomicXor
        IsFinite,
        // isfinite                             n/a
        IsInf,
        // isinf                                isinf
        IsNaN,
        // isnan                                isnan
        LdExp,
        // ldexp                                ldexp
        Length,
        // length                               length
        Lerp,
        // lerp                                 mix
        LessThan,
        // n/a                                  lessThan
        LessThanEqual,
        // n/a                                  lessThanEqual
        Lit,
        // lit                                  n/a
        Log,
        // log                                  log
        Log10,
        // log10                                n/a
        Log2,
        // log2                                 log2
        MAD,
        // mad                                  fma
        Max,
        // max                                  max
        Min,
        // min                                  min
        ModF,
        // modf                                 modf
        MSAD4,
        // msad4                                n/a
        Mul,
        // mul                                  n/a
        Normalize,
        // normalize                            normalize
        NotEqual,
        // n/a                                  notEqual
        Not,
        // n/a                                  not
        Pow,
        // pow                                  pow
        PrintF,
        // printf                               n/a
        Process2DQuadTessFactorsAvg,
        // Process2DQuadTessFactorsAvg          n/a
        Process2DQuadTessFactorsMax,
        // Process2DQuadTessFactorsMax          n/a
        Process2DQuadTessFactorsMin,
        // Process2DQuadTessFactorsMin          n/a
        ProcessIsolineTessFactors,
        // ProcessIsolineTessFactors            n/a
        ProcessQuadTessFactorsAvg,
        // ProcessQuadTessFactorsAvg            n/a
        ProcessQuadTessFactorsMax,
        // ProcessQuadTessFactorsMax            n/a
        ProcessQuadTessFactorsMin,
        // ProcessQuadTessFactorsMin            n/a
        ProcessTriTessFactorsAvg,
        // ProcessTriTessFactorsAvg             n/a
        ProcessTriTessFactorsMax,
        // ProcessTriTessFactorsMax             n/a
        ProcessTriTessFactorsMin,
        // ProcessTriTessFactorsMin             n/a
        Radians,
        // radians                              radians
        Rcp,
        // rcp                                  n/a
        Reflect,
        // reflect                              reflect
        Refract,
        // refract                              refract
        ReverseBits,
        // reversebits                          n/a
        Round,
        // round                                round
        RSqrt,
        // rsqrt                                inversesqrt
        Saturate,
        // saturate                             n/a
        Sign,
        // sign                                 sign
        Sin,
        // sin                                  sin
        SinCos,
        // sincos                               n/a
        SinH,
        // sinh                                 sinh
        SmoothStep,
        // smoothstep                           smoothstep
        Sqrt,
        // sqrt                                 sqrt
        Step,
        // step                                 step
        Tan,
        // tan                                  tan
        TanH,
        // tanh                                 tanh
        Transpose,
        // transpose                            transpose
        Trunc,
        // trunc                                trunc
 
        // MARK: HLSL 3 texture intrinsics
        Tex1D2,
        Tex1D4,
        Tex1DBias,
        Tex1DGrad,
        Tex1DLod,
        Tex1DProj,
        Tex2D2,
        Tex2D4,
        Tex2DBias,
        Tex2DGrad,
        Tex2DLod,
        Tex2DProj,
        Tex3D2,
        Tex3D4,
        Tex3DBias,
        Tex3DGrad,
        Tex3DLod,
        Tex3DProj,
        TexCube2,
        TexCube4,
        TexCubeBias,
        TexCubeGrad,
        TexCubeLod,
        TexCubeProj,
 
        // MARK: HLSL 4+ class intrinsics
        TextureGetDimensions,
        TextureQueryLod,
        // CalculateLevelOfDetail(SamplerState S, float[1,2,3] Location)
        TextureQueryLodUnclamped,
        // CalculateLevelOfDetailUnclamped(SamplerState S, float[1,2,3] Location)
 
        TextureLoad1,
        // Load(int[1,2,3,4] Location)
        TextureLoad2,
        // Load(int[1,2,3,4] Location, Int32 SampleIndex)
        TextureLoad3,
        // Load(int[1,2,3,4] Location, Int32 SampleIndex, Int32 Offset)
 
        TextureSample2,
        // Sample(SamplerState S, float[1,2,3,4] Location)
        TextureSample3,
        // Sample(SamplerState S, float[1,2,3,4] Location, int[1,2,3] Offset)
        TextureSample4,
        // Sample(SamplerState S, float[1,2,3,4] Location, int[1,2,3] Offset, float Clamp)
        TextureSample5,
        // Sample(SamplerState S, float[1,2,3,4] Location, int[1,2,3] Offset, float Clamp, out uint Status)
        TextureSampleBias3,
        TextureSampleBias4,
        TextureSampleBias5,
        TextureSampleBias6,
        TextureSampleCmp3,
        TextureSampleCmp4,
        TextureSampleCmp5,
        TextureSampleCmp6,
        TextureSampleCmpLevelZero3,
        TextureSampleCmpLevelZero4,
        TextureSampleCmpLevelZero5,
        TextureSampleGrad4,
        TextureSampleGrad5,
        TextureSampleGrad6,
        TextureSampleGrad7,
        TextureSampleLevel3,
        // SampleLevel(SamplerState S, float[1,2,3,4] Location, float LOD)
        TextureSampleLevel4,
        // SampleLevel(SamplerState S, float[1,2,3,4] Location, float LOD, int[1,2,3] Offset)
        TextureSampleLevel5,
        // SampleLevel(SamplerState S, float[1,2,3,4] Location, float LOD, int[1,2,3] Offset, out uint Status)
 
        TextureGather2,
        // Gather(SamplerState S, float[2,3,4] Location)
        TextureGatherRed2,
        // GatherRed(SamplerState S, float[2,3,4] Location)
        TextureGatherGreen2,
        // GatherGreen(SamplerState S, float[2,3,4] Location)
        TextureGatherBlue2,
        // GatherBlue(SamplerState S, float[2,3,4] Location)
        TextureGatherAlpha2,
        // GatherAlpha(SamplerState S, float[2,3,4] Location)
 
        TextureGather3,
        // Gather(SamplerState S, float[2,3] Location, int2 Offset)
        TextureGather4,
        // Gather(SamplerState S, float[2,3] Location, int2 Offset, out uint Status)
        TextureGatherRed3,
        // GatherRed(SamplerState S, float[2,3] Location, int2 Offset)
        TextureGatherRed4,
        // GatherRed(SamplerState S, float[2,3] Location, int2 Offset, out uint Status)
        TextureGatherGreen3,
        // GatherGreen(SamplerState S, float[2,3] Location, int2 Offset)
        TextureGatherGreen4,
        // GatherGreen(SamplerState S, float[2,3] Location, int2 Offset, out uint Status)
        TextureGatherBlue3,
        // GatherBlue(SamplerState S, float[2,3] Location, int2 Offset)
        TextureGatherBlue4,
        // GatherBlue(SamplerState S, float[2,3] Location, int2 Offset, out uint Status)
        TextureGatherAlpha3,
        // GatherAlpha(SamplerState S, float[2,3] Location, int2 Offset)
        TextureGatherAlpha4,
        // GatherAlpha(SamplerState S, float[2,3] Location, int2 Offset, out uint Status)
 
        TextureGatherRed6,
        // GatherRed(SamplerState S, float[2,3] Location, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4)
        TextureGatherRed7,
        // GatherRed(SamplerState S, float[2,3] Location, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4, out uint Status)
        TextureGatherGreen6,
        // GatherGreen(SamplerState S, float[2,3] Location, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4)
        TextureGatherGreen7,
        // GatherGreen(SamplerState S, float[2,3] Location, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4, out uint Status)
        TextureGatherBlue6,
        // GatherBlue(SamplerState S, float[2,3] Location, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4)
        TextureGatherBlue7,
        // GatherBlue(SamplerState S, float[2,3] Location, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4, out uint Status)
        TextureGatherAlpha6,
        // GatherAlpha(SamplerState S, float[2,3] Location, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4)
        TextureGatherAlpha7,
        // GatherAlpha(SamplerState S, float[2,3] Location, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4, out uint Status)
 
        TextureGatherCmp3,
        // GatherCmp(SamplerComparisonState S, float[2,3,4] Location, float CompareValue)
        TextureGatherCmpRed3,
        // GatherCmpRed(SamplerComparisonState S, float[2,3,4] Location, float CompareValue)
        TextureGatherCmpGreen3,
        // GatherCmpGreen(SamplerComparisonState S, float[2,3,4] Location, float CompareValue)
        TextureGatherCmpBlue3,
        // GatherCmpBlue(SamplerComparisonState S, float[2,3,4] Location, float CompareValue)
        TextureGatherCmpAlpha3,
        // GatherCmpAlpha(SamplerComparisonState S, float[2,3,4] Location, float CompareValue)
 
        TextureGatherCmp4,
        // GatherCmp(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset)
        TextureGatherCmp5,
        // GatherCmp(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset, out uint Status)
        TextureGatherCmpRed4,
        // GatherCmpRed(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset)
        TextureGatherCmpRed5,
        // GatherCmpRed(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset, out uint Status)
        TextureGatherCmpGreen4,
        // GatherCmpGreen(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset)
        TextureGatherCmpGreen5,
        // GatherCmpGreen(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset, out uint Status)
        TextureGatherCmpBlue4,
        // GatherCmpBlue(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset)
        TextureGatherCmpBlue5,
        // GatherCmpBlue(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset, out uint Status)
        TextureGatherCmpAlpha4,
        // GatherCmpAlpha(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset)
        TextureGatherCmpAlpha5,
        // GatherCmpAlpha(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset, out uint Status)
 
        TextureGatherCmpRed7,
        // GatherCmpRed(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4)
        TextureGatherCmpRed8,
        // GatherCmpRed(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4, out uint Status)
        TextureGatherCmpGreen7,
        // GatherCmpGreen(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4)
        TextureGatherCmpGreen8,
        // GatherCmpGreen(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4, out uint Status)
        TextureGatherCmpBlue7,
        // GatherCmpBlue(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4)
        TextureGatherCmpBlue8,
        // GatherCmpBlue(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4, out uint Status)
        TextureGatherCmpAlpha7,
        // GatherCmpAlpha(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4)
        TextureGatherCmpAlpha8,
        // GatherCmpAlpha(SamplerComparisonState S, float[2,3] Location, float CompareValue, int2 Offset1, int2 Offset2, int2 Offset3, int2 Offset4, out uint Status)
 
        StreamOutputAppend,
        // Append(StreamDataType)
        StreamOutputRestartStrip,
        // RestartStrip()
 
        // MARK: GLSL only intrinsics
        ImageLoad,
        // imageLoad(gimage Image, T Location)
        ImageStore,
        // imageStore(gimage Image, T Location, G Data)
        ImageAtomicAdd,
        // atomicAdd(inout T Memory, T Data)
        ImageAtomicAnd,
        // atomicAnd(inout T Memory, T Data)
        ImageAtomicOr,
        // atomicOr(inout T Memory, T Data)
        ImageAtomicXor,
        // atomicXor(inout T Memory, T Data)
        ImageAtomicMin,
        // atomicMin(inout T Memory, T Data)
        ImageAtomicMax,
        // atomicMax(inout T Memory, T Data)
        ImageAtomicCompSwap,
        // atomicCompSwap(inout T Memory, T compare, T Data)
        ImageAtomicExchange,
        // atomicExchange(inout T Memory, T Data)
 
        PackHalf2x16,
        // packHalf2x16(vec2 Vec)
    };
 
    // Container structure for all kinds of intrinsic call usages (can be used
    // as Map<Intrinsic, IntrinsicUsage>).
    struct IntrinsicUsage {
        struct ArgumentList {
            Vector<DataType> argTypes;
 
            inline bool operator<(const ArgumentList& rhs) const { return (argTypes < rhs.argTypes); }
        };
 
        // Set of all argument lists that where used for an intrinsic.
        Set<ArgumentList> argLists;
    };
 
    // Returns true if the specified intrinsic is a global intrinsic.
    bool isGlobalIntrinsic(const Intrinsic t);
 
    // Returns true if the specified intrinsic belongs to a texture object.
    bool isTextureIntrinsic(const Intrinsic t);
 
    // Returns true if the specified intrinsic is a texture gather intrinsic.
    bool isTextureGatherIntrisic(const Intrinsic t);
 
    // Returns true if the specified intrinsic is a texture sample intrinsic.
    bool isTextureSampleIntrinsic(const Intrinsic t);
 
    // Returns true if the specified intrinsic is a texture sample or gather intrisic, with a compare operation.
    bool isTextureCompareIntrinsic(const Intrinsic t);
 
    // Returns true if the specified intrinsic is a texture sample compare intrinsic that only samples the first mip level.
    bool isTextureCompareLevelZeroIntrinsic(const Intrinsic t);
 
    // Returns true if the specified intrinsic is a texture load intrisic (e.g. Texture_Load1).
    bool isTextureLoadIntrinsic(const Intrinsic t);
 
    // Returns true if the specified intrinsic belongs to a stream-output object.
    bool isStreamOutputIntrinsic(const Intrinsic t);
 
    // Returns true if the specified intrinsic is an image load/store intrinsic.
    bool isImageIntrinsic(const Intrinsic t);
 
    // Returns true if the specified intrinsic in an interlocked intrinsic (e.g. Intrinsic::InterlockedAdd).
    bool isInterlockedIntristic(const Intrinsic t);
 
    // Returns the respective intrinsic for the specified binary compare operator, or Intrinsic::Undefined if the operator is not a compare operator.
    Intrinsic compareOpToIntrinsic(const BinaryOp op);
 
    Intrinsic interlockedToImageAtomicIntrinsic(const Intrinsic t);
 
    // Returns the number of offset parameters accepted by the specified gather intrinsic.
    Int32 getGatherIntrinsicOffsetParamCount(const Intrinsic t);
 
    // Maps a texture gather intrinsic to a component index (e.g. red -> 0, green -> 1, etc.)
    Int32 getGatherIntrinsicComponentIndex(const Intrinsic t);
 
    // Semantic enumeration (vertex input is omitted).
    enum class Semantic {
        Undefined,
 
        UserDefined,
        // User defined HLSL semantic
 
        // HLSL3     HLSL4+                     GLSL
        // -----------------------------------------------------------------------------------------
        ClipDistance,
        // n/a       SV_ClipDistance            gl_ClipDistance
        CullDistance,
        // n/a       SV_CullDistance            gl_CullDistance (if ARB_cull_distance is present)
        Coverage,
        // n/a       SV_Coverage                gl_SampleMask
        Depth,
        // DEPTH     SV_Depth                   gl_FragDepth
        DepthGreaterEqual,
        // n/a       SV_DepthGreaterEqual       layout(depth_greater) out float gl_FragDepth
        DepthLessEqual,
        // n/a       SV_DepthLessEqual          layout(depth_less) out float gl_FragDepth
        DispatchThreadID,
        // n/a       SV_DispatchThreadID        gl_GlobalInvocationID
        DomainLocation,
        // n/a       SV_DomainLocation          gl_TessCoord
        FragCoord,
        // VPOS      SV_Position                gl_FragCoord
        GroupID,
        // n/a       SV_GroupID                 gl_WorkGroupID
        GroupIndex,
        // n/a       SV_GroupIndex              gl_LocalInvocationIndex
        GroupThreadID,
        // n/a       SV_GroupThreadID           gl_LocalInvocationID
        GSInstanceID,
        // n/a       SV_GSInstanceID            gl_InvocationID
        //HelperInvocation,       // n/a       n/a                        gl_HelperInvocation
        InnerCoverage,
        // n/a       SV_InnerCoverage           gl_SampleMaskIn
        InsideTessFactor,
        // n/a       SV_InsideTessFactor[2]     gl_TessLevelInner[2]
        InstanceID,
        // n/a       SV_InstanceID              gl_InstanceID (OpenGL)/ gl_InstanceIndex (Vulkan)
        IsFrontFace,
        // VFACE     SV_IsFrontFace             gl_FrontFacing
        OutputControlPointID,
        // n/a       SV_OutputControlPointID    gl_InvocationID
        PointSize,
        // PSIZE     n/a                        gl_PointSize
        PrimitiveID,
        // n/a       SV_PrimitiveID             gl_PrimitiveID
        RenderTargetArrayIndex,
        // n/a       SV_RenderTargetArrayIndex  gl_Layer
        SampleIndex,
        // n/a       SV_SampleIndex             gl_SampleID
        StencilRef,
        // n/a       SV_StencilRef              gl_FragStencilRef (if ARB_shader_stencil_export is present)
        Target,
        // COLOR     SV_Target                  gl_FragData
        TessFactor,
        // n/a       SV_TessFactor[4]           gl_TessLevelOuter[4]
        VertexID,
        // n/a       SV_VertexID                gl_VertexID (OpenGL)/ gl_VertexIndex (Vulkan)
        VertexPosition,
        // POSITION  SV_Position                gl_Position
        ViewportArrayIndex,
        // n/a       SV_ViewportArrayIndex      gl_ViewportIndex
        //NumWorkGroups,          // n/a       n/a                        gl_NumWorkGroups
        //WorkGroupSize,          // n/a       n/a                        gl_WorkGroupSize
    };
 
    // Indexed semantic type with 'Semantic' enum, integral index, and implicit conversion from and to 'Semantic' enum.
    class IndexedSemantic {
    private:
        Semantic mSemantic = Semantic::Undefined;
        Int32 mIndex = 0;
        String mUserDefined;
 
    public:
        IndexedSemantic() = default;
        IndexedSemantic(const IndexedSemantic&) = default;
        IndexedSemantic& operator=(const IndexedSemantic&) = default;
 
        IndexedSemantic(Semantic semantic, Int32 index = 0);
        IndexedSemantic(const String& userDefined);
        IndexedSemantic(const IndexedSemantic& rhs, Int32 index);
 
        inline operator Semantic() const { return mSemantic; }
 
        // Compares this semantic with the specified semantic for a strict-weak-order (SWO).
        bool operator<(const IndexedSemantic& rhs) const;
 
        // Returns true if this the semantic is not undefined (Semantic::Undefined).
        [[nodiscard]] bool isValid() const;
 
        // see CeresEngine::ShaderCompiler::IsSystemSemantic
        [[nodiscard]] bool isSystemValue() const;
 
        // see CeresEngine::ShaderCompiler::IsUserSemantic
        [[nodiscard]] bool isUserDefined() const;
 
        [[nodiscard]] String toString() const;
 
        // Resest this semantic to undefined.
        void reset();
 
        // Restes the index of this semantic.
        void resetIndex(int index);
 
        // Converts this system value semantic to a user defined semantic.
        void makeUserDefined(const String& semanticName = "");
 
        // Returns the semantic index.
        [[nodiscard]] inline Int32 getIndex() const { return mIndex; }
    };
 
    // Returns true if the specified semantic is a system value semantic.
    bool isSystemSemantic(const Semantic t);
 
    // Returns true if the specified semantic is a user defined semantic.
    bool isUserSemantic(const Semantic t);
 
    // Returns the specified semantic as string.
    String semanticToString(const Semantic t);
 
    String filterToString(const Reflection::Filter t);
    Reflection::Filter stringToFilter(const String& s);
 
    String texAddressModeToString(const Reflection::TextureAddressMode t);
    Reflection::TextureAddressMode stringToTexAddressMode(const String& s);
 
    String compareFuncToString(const Reflection::ComparisonFunc t);
    Reflection::ComparisonFunc stringToCompareFunc(const String& s);
 
    String resourceTypeToString(const Reflection::ResourceType t);
 
    Reflection::ResourceType uniformBufferTypeToResourceType(const UniformBufferType t);
    Reflection::ResourceType bufferTypeToResourceType(const BufferType t);
    Reflection::ResourceType samplerTypeToResourceType(const SamplerType t);
} // namespace CeresEngine::ShaderCompiler