#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_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		(deUint32 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		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<deUint16>			{ 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<deUint32>			{ 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); }

} // glu

#endif // _GLUSHADERUTIL_HPP