#ifndef _GLUSHADERUTIL_HPP
#define _GLUSHADERUTIL_HPP
/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES Utilities
 * ------------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Shader utilities.
 *//*--------------------------------------------------------------------*/

#include "tcuDefs.hpp"
#include "deInt32.h"
#include "gluRenderContext.hpp"
#include "tcuVector.hpp"
#include "tcuVector.hpp"
#include "tcuMatrix.hpp"

namespace glu
{

// ShadingLanguageVersion

enum GLSLVersion
{
    GLSL_VERSION_100_ES = 0, //!< GLSL ES 1.0
    GLSL_VERSION_300_ES,     //!< GLSL ES 3.0
    GLSL_VERSION_310_ES,     //!< GLSL ES 3.1
    GLSL_VERSION_320_ES,     //!< GLSL ES 3.2

    GLSL_VERSION_130, //!< GLSL 1.3
    GLSL_VERSION_140, //!< GLSL 1.4
    GLSL_VERSION_150, //!< GLSL 1.5
    GLSL_VERSION_330, //!< GLSL 3.0
    GLSL_VERSION_400, //!< GLSL 4.0
    GLSL_VERSION_410, //!< GLSL 4.1
    GLSL_VERSION_420, //!< GLSL 4.2
    GLSL_VERSION_430, //!< GLSL 4.3
    GLSL_VERSION_440, //!< GLSL 4.4
    GLSL_VERSION_450, //!< GLSL 4.5
    GLSL_VERSION_460, //!< GLSL 4.6

    GLSL_VERSION_LAST
};

const char *getGLSLVersionName(GLSLVersion version);
const char *getGLSLVersionDeclaration(GLSLVersion version);
bool glslVersionUsesInOutQualifiers(GLSLVersion version);
bool glslVersionIsES(GLSLVersion version);
bool isGLSLVersionSupported(ContextType type, GLSLVersion version);
GLSLVersion getContextTypeGLSLVersion(ContextType type);

// ShaderType

enum ShaderType
{
    SHADERTYPE_VERTEX = 0,
    SHADERTYPE_FRAGMENT,
    SHADERTYPE_GEOMETRY,
    SHADERTYPE_TESSELLATION_CONTROL,
    SHADERTYPE_TESSELLATION_EVALUATION,
    SHADERTYPE_COMPUTE,

    SHADERTYPE_RAYGEN,
    SHADERTYPE_ANY_HIT,
    SHADERTYPE_CLOSEST_HIT,
    SHADERTYPE_MISS,
    SHADERTYPE_INTERSECTION,
    SHADERTYPE_CALLABLE,

    SHADERTYPE_TASK,
    SHADERTYPE_MESH,

    SHADERTYPE_LAST
};

const char *getShaderTypeName(ShaderType shaderType);
std::string getShaderTypePostfix(ShaderType shaderType);

// Precision

enum Precision
{
    PRECISION_LOWP = 0,
    PRECISION_MEDIUMP,
    PRECISION_HIGHP,

    PRECISION_LAST
};

const char *getPrecisionName(Precision precision);
std::string getPrecisionPostfix(Precision precision);

// DataType

enum DataType
{
    TYPE_INVALID = 0,

    TYPE_FLOAT,
    TYPE_FLOAT_VEC2,
    TYPE_FLOAT_VEC3,
    TYPE_FLOAT_VEC4,
    TYPE_FLOAT_MAT2,
    TYPE_FLOAT_MAT2X3,
    TYPE_FLOAT_MAT2X4,
    TYPE_FLOAT_MAT3X2,
    TYPE_FLOAT_MAT3,
    TYPE_FLOAT_MAT3X4,
    TYPE_FLOAT_MAT4X2,
    TYPE_FLOAT_MAT4X3,
    TYPE_FLOAT_MAT4,

    TYPE_DOUBLE,
    TYPE_DOUBLE_VEC2,
    TYPE_DOUBLE_VEC3,
    TYPE_DOUBLE_VEC4,
    TYPE_DOUBLE_MAT2,
    TYPE_DOUBLE_MAT2X3,
    TYPE_DOUBLE_MAT2X4,
    TYPE_DOUBLE_MAT3X2,
    TYPE_DOUBLE_MAT3,
    TYPE_DOUBLE_MAT3X4,
    TYPE_DOUBLE_MAT4X2,
    TYPE_DOUBLE_MAT4X3,
    TYPE_DOUBLE_MAT4,

    TYPE_INT,
    TYPE_INT_VEC2,
    TYPE_INT_VEC3,
    TYPE_INT_VEC4,

    TYPE_UINT,
    TYPE_UINT_VEC2,
    TYPE_UINT_VEC3,
    TYPE_UINT_VEC4,

    TYPE_BOOL,
    TYPE_BOOL_VEC2,
    TYPE_BOOL_VEC3,
    TYPE_BOOL_VEC4,

    TYPE_SAMPLER_1D,
    TYPE_SAMPLER_2D,
    TYPE_SAMPLER_CUBE,
    TYPE_SAMPLER_1D_ARRAY,
    TYPE_SAMPLER_2D_ARRAY,
    TYPE_SAMPLER_3D,
    TYPE_SAMPLER_CUBE_ARRAY,

    TYPE_SAMPLER_1D_SHADOW,
    TYPE_SAMPLER_2D_SHADOW,
    TYPE_SAMPLER_CUBE_SHADOW,
    TYPE_SAMPLER_1D_ARRAY_SHADOW,
    TYPE_SAMPLER_2D_ARRAY_SHADOW,
    TYPE_SAMPLER_CUBE_ARRAY_SHADOW,

    TYPE_INT_SAMPLER_1D,
    TYPE_INT_SAMPLER_2D,
    TYPE_INT_SAMPLER_CUBE,
    TYPE_INT_SAMPLER_1D_ARRAY,
    TYPE_INT_SAMPLER_2D_ARRAY,
    TYPE_INT_SAMPLER_3D,
    TYPE_INT_SAMPLER_CUBE_ARRAY,

    TYPE_UINT_SAMPLER_1D,
    TYPE_UINT_SAMPLER_2D,
    TYPE_UINT_SAMPLER_CUBE,
    TYPE_UINT_SAMPLER_1D_ARRAY,
    TYPE_UINT_SAMPLER_2D_ARRAY,
    TYPE_UINT_SAMPLER_3D,
    TYPE_UINT_SAMPLER_CUBE_ARRAY,

    TYPE_SAMPLER_2D_MULTISAMPLE,
    TYPE_INT_SAMPLER_2D_MULTISAMPLE,
    TYPE_UINT_SAMPLER_2D_MULTISAMPLE,

    TYPE_IMAGE_2D,
    TYPE_IMAGE_CUBE,
    TYPE_IMAGE_2D_ARRAY,
    TYPE_IMAGE_3D,
    TYPE_IMAGE_CUBE_ARRAY,

    TYPE_INT_IMAGE_2D,
    TYPE_INT_IMAGE_CUBE,
    TYPE_INT_IMAGE_2D_ARRAY,
    TYPE_INT_IMAGE_3D,
    TYPE_INT_IMAGE_CUBE_ARRAY,

    TYPE_UINT_IMAGE_2D,
    TYPE_UINT_IMAGE_CUBE,
    TYPE_UINT_IMAGE_2D_ARRAY,
    TYPE_UINT_IMAGE_3D,
    TYPE_UINT_IMAGE_CUBE_ARRAY,

    TYPE_UINT_ATOMIC_COUNTER,

    TYPE_SAMPLER_BUFFER,
    TYPE_INT_SAMPLER_BUFFER,
    TYPE_UINT_SAMPLER_BUFFER,

    TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
    TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
    TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,

    TYPE_IMAGE_BUFFER,
    TYPE_INT_IMAGE_BUFFER,
    TYPE_UINT_IMAGE_BUFFER,

    TYPE_UINT8,
    TYPE_UINT8_VEC2,
    TYPE_UINT8_VEC3,
    TYPE_UINT8_VEC4,

    TYPE_INT8,
    TYPE_INT8_VEC2,
    TYPE_INT8_VEC3,
    TYPE_INT8_VEC4,

    TYPE_UINT16,
    TYPE_UINT16_VEC2,
    TYPE_UINT16_VEC3,
    TYPE_UINT16_VEC4,

    TYPE_INT16,
    TYPE_INT16_VEC2,
    TYPE_INT16_VEC3,
    TYPE_INT16_VEC4,

    TYPE_FLOAT16,
    TYPE_FLOAT16_VEC2,
    TYPE_FLOAT16_VEC3,
    TYPE_FLOAT16_VEC4,
    TYPE_FLOAT16_MAT2,
    TYPE_FLOAT16_MAT2X3,
    TYPE_FLOAT16_MAT2X4,
    TYPE_FLOAT16_MAT3X2,
    TYPE_FLOAT16_MAT3,
    TYPE_FLOAT16_MAT3X4,
    TYPE_FLOAT16_MAT4X2,
    TYPE_FLOAT16_MAT4X3,
    TYPE_FLOAT16_MAT4,

    TYPE_LAST
};

const char *getDataTypeName(DataType dataType);
int getDataTypeScalarSize(DataType dataType);
DataType getDataTypeScalarType(DataType dataType);
DataType getDataTypeFloat16Scalars(DataType dataType);
DataType getDataTypeFloatScalars(DataType dataType);
DataType getDataTypeDoubleScalars(DataType dataType);
DataType getDataTypeVector(DataType scalarType, int size);
DataType getDataTypeFloatVec(int vecSize);
DataType getDataTypeIntVec(int vecSize);
DataType getDataTypeUintVec(int vecSize);
DataType getDataTypeBoolVec(int vecSize);
DataType getDataTypeMatrix(int numCols, int numRows);
DataType getDataTypeFromGLType(uint32_t glType);

inline bool isDataTypeFloat16OrVec(DataType dataType)
{
    return (dataType >= TYPE_FLOAT16) && (dataType <= TYPE_FLOAT16_MAT4);
}
inline bool isDataTypeFloatOrVec(DataType dataType)
{
    return (dataType >= TYPE_FLOAT) && (dataType <= TYPE_FLOAT_VEC4);
}
inline bool isDataTypeFloatType(DataType dataType)
{
    return (dataType >= TYPE_FLOAT) && (dataType <= TYPE_FLOAT_MAT4);
}
inline bool isDataTypeDoubleType(DataType dataType)
{
    return (dataType >= TYPE_DOUBLE) && (dataType <= TYPE_DOUBLE_MAT4);
}
inline bool isDataTypeDoubleOrDVec(DataType dataType)
{
    return (dataType >= TYPE_DOUBLE) && (dataType <= TYPE_DOUBLE_VEC4);
}
inline bool isDataTypeMatrix(DataType dataType)
{
    return ((dataType >= TYPE_FLOAT_MAT2) && (dataType <= TYPE_FLOAT_MAT4)) ||
           ((dataType >= TYPE_DOUBLE_MAT2) && (dataType <= TYPE_DOUBLE_MAT4)) ||
           ((dataType >= TYPE_FLOAT16_MAT2) && (dataType <= TYPE_FLOAT16_MAT4));
}
inline bool isDataTypeIntOrIVec(DataType dataType)
{
    return (dataType >= TYPE_INT) && (dataType <= TYPE_INT_VEC4);
}
inline bool isDataTypeUintOrUVec(DataType dataType)
{
    return (dataType >= TYPE_UINT) && (dataType <= TYPE_UINT_VEC4);
}
inline bool isDataTypeIntOrIVec8Bit(DataType dataType)
{
    return (dataType >= TYPE_INT8) && (dataType <= TYPE_INT8_VEC4);
}
inline bool isDataTypeUintOrUVec8Bit(DataType dataType)
{
    return (dataType >= TYPE_UINT8) && (dataType <= TYPE_UINT8_VEC4);
}
inline bool isDataTypeIntOrIVec16Bit(DataType dataType)
{
    return (dataType >= TYPE_INT16) && (dataType <= TYPE_INT16_VEC4);
}
inline bool isDataTypeUintOrUVec16Bit(DataType dataType)
{
    return (dataType >= TYPE_UINT16) && (dataType <= TYPE_UINT16_VEC4);
}
inline bool isDataTypeBoolOrBVec(DataType dataType)
{
    return (dataType >= TYPE_BOOL) && (dataType <= TYPE_BOOL_VEC4);
}
inline bool isDataTypeScalar(DataType dataType)
{
    return (dataType == TYPE_FLOAT) || (dataType == TYPE_DOUBLE) || (dataType == TYPE_INT) || (dataType == TYPE_UINT) ||
           (dataType == TYPE_BOOL) || (dataType == TYPE_UINT8) || (dataType == TYPE_INT8) ||
           (dataType == TYPE_UINT16) || (dataType == TYPE_INT16) || (dataType == TYPE_FLOAT16);
}
inline bool isDataTypeVector(DataType dataType)
{
    return deInRange32(dataType, TYPE_FLOAT_VEC2, TYPE_FLOAT_VEC4) ||
           deInRange32(dataType, TYPE_DOUBLE_VEC2, TYPE_DOUBLE_VEC4) ||
           deInRange32(dataType, TYPE_INT_VEC2, TYPE_INT_VEC4) ||
           deInRange32(dataType, TYPE_UINT_VEC2, TYPE_UINT_VEC4) ||
           deInRange32(dataType, TYPE_BOOL_VEC2, TYPE_BOOL_VEC4) ||
           deInRange32(dataType, TYPE_UINT8_VEC2, TYPE_UINT8_VEC4) ||
           deInRange32(dataType, TYPE_INT8_VEC2, TYPE_INT8_VEC4) ||
           deInRange32(dataType, TYPE_UINT16_VEC2, TYPE_UINT16_VEC4) ||
           deInRange32(dataType, TYPE_INT16_VEC2, TYPE_INT16_VEC4) ||
           deInRange32(dataType, TYPE_FLOAT16_VEC2, TYPE_FLOAT16_VEC4);
}
inline bool isDataTypeScalarOrVector(DataType dataType)
{
    return deInRange32(dataType, TYPE_FLOAT, TYPE_FLOAT_VEC4) || deInRange32(dataType, TYPE_DOUBLE, TYPE_DOUBLE_VEC4) ||
           deInRange32(dataType, TYPE_INT, TYPE_INT_VEC4) || deInRange32(dataType, TYPE_UINT, TYPE_UINT_VEC4) ||
           deInRange32(dataType, TYPE_BOOL, TYPE_BOOL_VEC4) || deInRange32(dataType, TYPE_UINT8, TYPE_UINT8_VEC4) ||
           deInRange32(dataType, TYPE_INT8, TYPE_INT8_VEC4) || deInRange32(dataType, TYPE_UINT16, TYPE_UINT16_VEC4) ||
           deInRange32(dataType, TYPE_INT16, TYPE_INT16_VEC4) || deInRange32(dataType, TYPE_FLOAT16, TYPE_FLOAT16_VEC4);
}
inline bool isDataTypeSampler(DataType dataType)
{
    return (dataType >= TYPE_SAMPLER_1D) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE);
}
inline bool isDataTypeImage(DataType dataType)
{
    return (dataType >= TYPE_IMAGE_2D) && (dataType <= TYPE_UINT_IMAGE_3D);
}
inline bool isDataTypeSamplerMultisample(DataType dataType)
{
    return (dataType >= TYPE_SAMPLER_2D_MULTISAMPLE) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE);
}
inline bool isDataTypeAtomicCounter(DataType dataType)
{
    return dataType == TYPE_UINT_ATOMIC_COUNTER;
}
inline bool isDataTypeSamplerBuffer(DataType dataType)
{
    return (dataType >= TYPE_SAMPLER_BUFFER) && (dataType <= TYPE_UINT_SAMPLER_BUFFER);
}
inline bool isDataTypeSamplerMSArray(DataType dataType)
{
    return (dataType >= TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY);
}
inline bool isDataTypeImageBuffer(DataType dataType)
{
    return (dataType >= TYPE_IMAGE_BUFFER) && (dataType <= TYPE_UINT_IMAGE_BUFFER);
}
inline bool isDataTypeExplicitPrecision(DataType dataType)
{
    return deInRange32(dataType, TYPE_UINT8, TYPE_UINT8_VEC4) || deInRange32(dataType, TYPE_INT8, TYPE_INT8_VEC4) ||
           deInRange32(dataType, TYPE_UINT16, TYPE_UINT16_VEC4) || deInRange32(dataType, TYPE_INT16, TYPE_INT16_VEC4) ||
           deInRange32(dataType, TYPE_FLOAT16, TYPE_FLOAT16_MAT4) ||
           deInRange32(dataType, TYPE_DOUBLE, TYPE_DOUBLE_MAT4);
}
inline bool dataTypeSupportsPrecisionModifier(DataType dataType)
{
    return !isDataTypeBoolOrBVec(dataType) && !isDataTypeExplicitPrecision(dataType);
}

int getDataTypeMatrixNumRows(DataType dataType);
int getDataTypeMatrixNumColumns(DataType dataType);
DataType getDataTypeMatrixColumnType(DataType dataType);

int getDataTypeNumLocations(DataType dataType);
int getDataTypeNumComponents(DataType dataType);

template <typename T>
struct DataTypeTraits;

template <>
struct DataTypeTraits<uint16_t>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16
    };
};
template <>
struct DataTypeTraits<float>
{
    enum
    {
        DATATYPE = TYPE_FLOAT
    };
};
template <>
struct DataTypeTraits<double>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE
    };
};
template <>
struct DataTypeTraits<bool>
{
    enum
    {
        DATATYPE = TYPE_BOOL
    };
};
template <>
struct DataTypeTraits<int>
{
    enum
    {
        DATATYPE = TYPE_INT
    };
};
template <>
struct DataTypeTraits<uint32_t>
{
    enum
    {
        DATATYPE = TYPE_UINT
    };
};
template <>
struct DataTypeTraits<tcu::Mat2>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT2
    };
};
template <>
struct DataTypeTraits<tcu::Mat2x3>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT2X3
    };
};
template <>
struct DataTypeTraits<tcu::Mat2x4>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT2X4
    };
};
template <>
struct DataTypeTraits<tcu::Mat3x2>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT3X2
    };
};
template <>
struct DataTypeTraits<tcu::Mat3>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT3
    };
};
template <>
struct DataTypeTraits<tcu::Mat3x4>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT3X4
    };
};
template <>
struct DataTypeTraits<tcu::Mat4x2>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT4X2
    };
};
template <>
struct DataTypeTraits<tcu::Mat4x3>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT4X3
    };
};
template <>
struct DataTypeTraits<tcu::Mat4>
{
    enum
    {
        DATATYPE = TYPE_FLOAT_MAT4
    };
};
template <>
struct DataTypeTraits<tcu::Mat2_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT2
    };
};
template <>
struct DataTypeTraits<tcu::Mat2x3_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT2X3
    };
};
template <>
struct DataTypeTraits<tcu::Mat2x4_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT2X4
    };
};
template <>
struct DataTypeTraits<tcu::Mat3x2_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT3X2
    };
};
template <>
struct DataTypeTraits<tcu::Mat3_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT3
    };
};
template <>
struct DataTypeTraits<tcu::Mat3x4_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT3X4
    };
};
template <>
struct DataTypeTraits<tcu::Mat4x2_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT4X2
    };
};
template <>
struct DataTypeTraits<tcu::Mat4x3_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT4X3
    };
};
template <>
struct DataTypeTraits<tcu::Mat4_16b>
{
    enum
    {
        DATATYPE = TYPE_FLOAT16_MAT4
    };
};
template <>
struct DataTypeTraits<tcu::Matrix2d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT2
    };
};
template <>
struct DataTypeTraits<tcu::Matrix3d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT3
    };
};
template <>
struct DataTypeTraits<tcu::Matrix4d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT4
    };
};
template <>
struct DataTypeTraits<tcu::Mat2x3d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT2X3
    };
};
template <>
struct DataTypeTraits<tcu::Mat2x4d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT2X4
    };
};
template <>
struct DataTypeTraits<tcu::Mat3x2d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT3X2
    };
};
template <>
struct DataTypeTraits<tcu::Mat3x4d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT3X4
    };
};
template <>
struct DataTypeTraits<tcu::Mat4x2d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT4X2
    };
};
template <>
struct DataTypeTraits<tcu::Mat4x3d>
{
    enum
    {
        DATATYPE = TYPE_DOUBLE_MAT4X3
    };
};

template <typename T, int Size>
struct DataTypeTraits<tcu::Vector<T, Size>>
{
    DE_STATIC_ASSERT(TYPE_FLOAT_VEC4 == TYPE_FLOAT + 3);
    DE_STATIC_ASSERT(TYPE_INT_VEC4 == TYPE_INT + 3);
    DE_STATIC_ASSERT(TYPE_UINT_VEC4 == TYPE_UINT + 3);
    DE_STATIC_ASSERT(TYPE_BOOL_VEC4 == TYPE_BOOL + 3);
    DE_STATIC_ASSERT(TYPE_DOUBLE_VEC4 == TYPE_DOUBLE + 3);
    enum
    {
        DATATYPE = DataTypeTraits<T>::DATATYPE + Size - 1
    };
};

template <typename T>
inline DataType dataTypeOf(void)
{
    return DataType(DataTypeTraits<T>::DATATYPE);
}

} // namespace glu

#endif // _GLUSHADERUTIL_HPP