gluShaderUtil.cpp revision 3c827367444ee418f129b2c238299f49d3264554 
1/*-------------------------------------------------------------------------
2 * drawElements Quality Program OpenGL ES Utilities
3 * ------------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *      http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief Shader utilities.
22 *//*--------------------------------------------------------------------*/
23
24#include "gluShaderUtil.hpp"
25#include "glwEnums.hpp"
26
27namespace glu
28{
29
30// ShadingLanguageVersion
31
32const char* getGLSLVersionName (GLSLVersion version)
33{
34	static const char* s_names[] =
35	{
36		"GLSL ES 1.0",
37		"GLSL ES 3.0",
38		"GLSL ES 3.1",
39		"GLSL 1.3",
40		"GLSL 1.4",
41		"GLSL 1.5",
42		"GLSL 3.3",
43		"GLSL 4.0",
44		"GLSL 4.1",
45		"GLSL 4.2",
46		"GLSL 4.3",
47		"GLSL 4.4",
48	};
49
50	return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_names, version);
51}
52
53const char* getGLSLVersionDeclaration (GLSLVersion version)
54{
55	static const char* s_decl[] =
56	{
57		"#version 100",
58		"#version 300 es",
59		"#version 310 es",
60		"#version 130",
61		"#version 140",
62		"#version 150",
63		"#version 330",
64		"#version 400",
65		"#version 410",
66		"#version 420",
67		"#version 430",
68		"#version 440",
69	};
70
71	return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_decl, version);
72}
73
74bool glslVersionUsesInOutQualifiers (GLSLVersion version)
75{
76	return de::inRange<int>(version, GLSL_VERSION_300_ES, GLSL_VERSION_310_ES) || de::inRange<int>(version, GLSL_VERSION_330, GLSL_VERSION_430);
77}
78
79bool glslVersionIsES (GLSLVersion version)
80{
81	DE_ASSERT(version != GLSL_VERSION_LAST);
82
83	if (version == GLSL_VERSION_100_ES	||
84		version == GLSL_VERSION_300_ES	||
85		version == GLSL_VERSION_310_ES)
86		return true;
87	else
88		return false;
89}
90
91// \todo [2014-10-06 pyry] Export this.
92static ApiType getMinAPIForGLSLVersion (GLSLVersion version)
93{
94	static const ApiType s_minApi[] =
95	{
96		ApiType::es(2,0),
97		ApiType::es(3,0),
98		ApiType::es(3,1),
99		ApiType::core(3,0),
100		ApiType::core(3,1),
101		ApiType::core(3,2),
102		ApiType::core(3,3),
103		ApiType::core(4,0),
104		ApiType::core(4,1),
105		ApiType::core(4,2),
106		ApiType::core(4,3),
107		ApiType::core(4,4),
108	};
109
110	return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_minApi, version);
111}
112
113bool isGLSLVersionSupported (ContextType type, GLSLVersion version)
114{
115	return contextSupports(type, getMinAPIForGLSLVersion(version));
116}
117
118GLSLVersion getContextTypeGLSLVersion (ContextType type)
119{
120	// \note From newer to older
121	for (int version = GLSL_VERSION_LAST-1; version >= 0; version--)
122	{
123		if (isGLSLVersionSupported(type, GLSLVersion(version)))
124			return GLSLVersion(version);
125	}
126
127	DE_ASSERT(false);
128	return GLSL_VERSION_LAST;
129}
130
131// ShaderType
132
133const char* getShaderTypeName (ShaderType shaderType)
134{
135	const char* s_names[] =
136	{
137		"vertex",
138		"fragment",
139		"geometry",
140		"tess_control",
141		"tess_eval",
142		"compute",
143	};
144
145	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == SHADERTYPE_LAST);
146	DE_ASSERT(deInBounds32((int)shaderType, 0, SHADERTYPE_LAST));
147	return s_names[(int)shaderType];
148}
149
150// Precision
151
152const char* getPrecisionName (Precision precision)
153{
154	const char* s_names[] =
155	{
156		"lowp",
157		"mediump",
158		"highp"
159	};
160
161	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == PRECISION_LAST);
162	DE_ASSERT(deInBounds32((int)precision, 0, PRECISION_LAST));
163	return s_names[(int)precision];
164}
165
166// DataType
167
168const char* getDataTypeName (DataType dataType)
169{
170	const char* s_names[] =
171	{
172		"invalid",
173		"float",
174		"vec2",
175		"vec3",
176		"vec4",
177		"mat2",
178		"mat2x3",
179		"mat2x4",
180		"mat3x2",
181		"mat3",
182		"mat3x4",
183		"mat4x2",
184		"mat4x3",
185		"mat4",
186		"int",
187		"ivec2",
188		"ivec3",
189		"ivec4",
190		"uint",
191		"uvec2",
192		"uvec3",
193		"uvec4",
194		"bool",
195		"bvec2",
196		"bvec3",
197		"bvec4",
198		"sampler1D",
199		"sampler2D",
200		"samplerCube",
201		"sampler2DArray",
202		"sampler3D",
203		"samplerCubeArray",
204		"sampler1DShadow",
205		"sampler2DShadow",
206		"samplerCubeShadow",
207		"sampler2DArrayShadow",
208		"samplerCubeArrayShadow",
209		"isampler1D",
210		"isampler2D",
211		"isamplerCube",
212		"isampler2DArray",
213		"isampler3D",
214		"isamplerCubeArray",
215		"usampler1D",
216		"usampler2D",
217		"usamplerCube",
218		"usampler2DArray",
219		"usampler3D",
220		"usamplerCubeArray",
221		"sampler2DMS",
222		"isampler2DMS",
223		"usampler2DMS",
224		"image2D",
225		"imageCube",
226		"image2DArray",
227		"image3D",
228		"imageCubeArray",
229		"iimage2D",
230		"iimageCube",
231		"iimage2DArray",
232		"iimage3D",
233		"iimageCubeArray",
234		"uimage2D",
235		"uimageCube",
236		"uimage2DArray",
237		"uimage3D",
238		"uimageCubeArray",
239		"atomic_uint",
240	};
241
242	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == TYPE_LAST);
243	DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_names)));
244	return s_names[(int)dataType];
245}
246
247int getDataTypeScalarSize (DataType dataType)
248{
249	const int s_sizes[] =
250	{
251		-1,		// invalid
252		1,		// float
253		2,		// vec2
254		3,		// vec3
255		4,		// vec4
256		4,		// mat2
257		6,		// mat2x3
258		8,		// mat2x4
259		6,		// mat3x2
260		9,		// mat3
261		12,		// mat3x4
262		8,		// mat4x2
263		12,		// mat4x3
264		16,		// mat4
265		1,		// int
266		2,		// ivec2
267		3,		// ivec3
268		4,		// ivec4
269		1,		// uint
270		2,		// uvec2
271		3,		// uvec3
272		4,		// uvec4
273		1,		// bool
274		2,		// bvec2
275		3,		// bvec3
276		4,		// bvec4
277		1,		// sampler1D
278		1,		// sampler2D
279		1,		// samplerCube
280		1,		// sampler2DArray
281		1,		// sampler3D
282		1,		// samplerCubeArray
283		1,		// sampler1DShadow
284		1,		// sampler2DShadow
285		1,		// samplerCubeShadow
286		1,		// sampler2DArrayShadow
287		1,		// samplerCubeArrayShadow
288		1,		// isampler1D
289		1,		// isampler2D
290		1,		// isamplerCube
291		1,		// isampler2DArray
292		1,		// isampler3D
293		1,		// isamplerCubeArray
294		1,		// usampler1D
295		1,		// usampler2D
296		1,		// usamplerCube
297		1,		// usampler2DArray
298		1,		// usampler3D
299		1,		// usamplerCubeArray
300		1,		// sampler2DMS
301		1,		// isampler2DMS
302		1,		// usampler2DMS
303		1,		// image2D
304		1,		// imageCube
305		1,		// image2DArray
306		1,		// image3D
307		1,		// imageCubeArray
308		1,		// iimage2D
309		1,		// iimageCube
310		1,		// iimage2DArray
311		1,		// iimage3D
312		1,		// iimageCubeArray
313		1,		// uimage2D
314		1,		// uimageCube
315		1,		// uimage2DArray
316		1,		// uimage3D
317		1,		// uimageCubeArray
318		1,		// atomic_uint
319	};
320
321	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_sizes) == TYPE_LAST);
322	DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_sizes)));
323	return s_sizes[(int)dataType];
324}
325
326DataType getDataTypeScalarType (DataType dataType)
327{
328	const DataType s_scalarTypes[] =
329	{
330		TYPE_INVALID,		// invalid
331		TYPE_FLOAT,			// float
332		TYPE_FLOAT,			// vec2
333		TYPE_FLOAT,			// vec3
334		TYPE_FLOAT,			// vec4
335		TYPE_FLOAT,			// mat2
336		TYPE_FLOAT,			// mat2x3
337		TYPE_FLOAT,			// mat2x4
338		TYPE_FLOAT,			// mat3x2
339		TYPE_FLOAT,			// mat3
340		TYPE_FLOAT,			// mat3x4
341		TYPE_FLOAT,			// mat4x2
342		TYPE_FLOAT,			// mat4x3
343		TYPE_FLOAT,			// mat4
344		TYPE_INT,			// int
345		TYPE_INT,			// ivec2
346		TYPE_INT,			// ivec3
347		TYPE_INT,			// ivec4
348		TYPE_UINT,			// uint
349		TYPE_UINT,			// uvec2
350		TYPE_UINT,			// uvec3
351		TYPE_UINT,			// uvec4
352		TYPE_BOOL,			// bool
353		TYPE_BOOL,			// bvec2
354		TYPE_BOOL,			// bvec3
355		TYPE_BOOL,			// bvec4
356		TYPE_SAMPLER_1D,					// sampler1D
357		TYPE_SAMPLER_2D,					// sampler2D
358		TYPE_SAMPLER_CUBE,					// samplerCube
359		TYPE_SAMPLER_2D_ARRAY,				// sampler2DArray
360		TYPE_SAMPLER_3D,					// sampler3D
361		TYPE_SAMPLER_CUBE_ARRAY,			// samplerCubeArray
362		TYPE_SAMPLER_1D_SHADOW,				// sampler1DShadow
363		TYPE_SAMPLER_2D_SHADOW,				// sampler2DShadow
364		TYPE_SAMPLER_CUBE_SHADOW,			// samplerCubeShadow
365		TYPE_SAMPLER_2D_ARRAY_SHADOW,		// sampler2DArrayShadow
366		TYPE_SAMPLER_CUBE_ARRAY_SHADOW,		// samplerCubeArrayShadow
367		TYPE_INT_SAMPLER_1D,				// isampler1D
368		TYPE_INT_SAMPLER_2D,				// isampler2D
369		TYPE_INT_SAMPLER_CUBE,				// isamplerCube
370		TYPE_INT_SAMPLER_2D_ARRAY,			// isampler2DArray
371		TYPE_INT_SAMPLER_3D,				// isampler3D
372		TYPE_INT_SAMPLER_CUBE_ARRAY,		// isamplerCubeArray
373		TYPE_UINT_SAMPLER_1D,				// usampler1D
374		TYPE_UINT_SAMPLER_2D,				// usampler2D
375		TYPE_UINT_SAMPLER_CUBE,				// usamplerCube
376		TYPE_UINT_SAMPLER_2D_ARRAY,			// usampler2DArray
377		TYPE_UINT_SAMPLER_3D,				// usampler3D
378		TYPE_UINT_SAMPLER_CUBE_ARRAY,		// usamplerCubeArray
379		TYPE_SAMPLER_2D_MULTISAMPLE,		// sampler2DMS
380		TYPE_INT_SAMPLER_2D_MULTISAMPLE,	// isampler2DMS
381		TYPE_UINT_SAMPLER_2D_MULTISAMPLE,	// usampler2DMS
382		TYPE_IMAGE_2D,						// image2D
383		TYPE_IMAGE_CUBE,					// imageCube
384		TYPE_IMAGE_2D_ARRAY,				// image2DArray
385		TYPE_IMAGE_3D,						// image3D
386		TYPE_IMAGE_CUBE_ARRAY,				// imageCubeArray
387		TYPE_INT_IMAGE_2D,					// iimage2D
388		TYPE_INT_IMAGE_CUBE,				// iimageCube
389		TYPE_INT_IMAGE_2D_ARRAY,			// iimage2DArray
390		TYPE_INT_IMAGE_3D,					// iimage3D
391		TYPE_INT_IMAGE_CUBE_ARRAY,			// iimageCubeArray
392		TYPE_UINT_IMAGE_2D,					// uimage2D
393		TYPE_UINT_IMAGE_CUBE,				// uimageCube
394		TYPE_UINT_IMAGE_2D_ARRAY,			// uimage2DArray
395		TYPE_UINT_IMAGE_3D,					// uimage3D
396		TYPE_UINT_IMAGE_CUBE_ARRAY,			// uimageCubeArray
397		TYPE_UINT_ATOMIC_COUNTER,			// atomic_uint
398	};
399
400	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_scalarTypes) == TYPE_LAST);
401	DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_scalarTypes)));
402	return s_scalarTypes[(int)dataType];
403}
404
405DataType getDataTypeFloatScalars (DataType dataType)
406{
407	const DataType s_floatTypes[] =
408	{
409		TYPE_INVALID,		// invalid
410		TYPE_FLOAT,			// float
411		TYPE_FLOAT_VEC2,	// vec2
412		TYPE_FLOAT_VEC3,	// vec3
413		TYPE_FLOAT_VEC4,	// vec4
414		TYPE_FLOAT_MAT2,	// mat2
415		TYPE_FLOAT_MAT2X3,	// mat2x3
416		TYPE_FLOAT_MAT2X4,	// mat2x4
417		TYPE_FLOAT_MAT3X2,	// mat3x2
418		TYPE_FLOAT_MAT3,	// mat3
419		TYPE_FLOAT_MAT3X4,	// mat3x4
420		TYPE_FLOAT_MAT4X2,	// mat4x2
421		TYPE_FLOAT_MAT4X3,	// mat4x3
422		TYPE_FLOAT_MAT4,	// mat4
423		TYPE_FLOAT,			// int
424		TYPE_FLOAT_VEC2,	// ivec2
425		TYPE_FLOAT_VEC3,	// ivec3
426		TYPE_FLOAT_VEC4,	// ivec4
427		TYPE_FLOAT,			// uint
428		TYPE_FLOAT_VEC2,	// uvec2
429		TYPE_FLOAT_VEC3,	// uvec3
430		TYPE_FLOAT_VEC4,	// uvec4
431		TYPE_FLOAT,			// bool
432		TYPE_FLOAT_VEC2,	// bvec2
433		TYPE_FLOAT_VEC3,	// bvec3
434		TYPE_FLOAT_VEC4,	// bvec4
435		TYPE_INVALID,		// sampler1D
436		TYPE_INVALID,		// sampler2D
437		TYPE_INVALID,		// samplerCube
438		TYPE_INVALID,		// sampler2DArray
439		TYPE_INVALID,		// sampler3D
440		TYPE_INVALID,		// samplerCubeArray
441		TYPE_INVALID,		// sampler1DShadow
442		TYPE_INVALID,		// sampler2DShadow
443		TYPE_INVALID,		// samplerCubeShadow
444		TYPE_INVALID,		// sampler2DArrayShadow
445		TYPE_INVALID,		// samplerCubeArrayShadow
446		TYPE_INVALID,		// isampler1D
447		TYPE_INVALID,		// isampler2D
448		TYPE_INVALID,		// isamplerCube
449		TYPE_INVALID,		// isampler2DArray
450		TYPE_INVALID,		// isampler3D
451		TYPE_INVALID,		// isamplerCubeArray
452		TYPE_INVALID,		// usampler1D
453		TYPE_INVALID,		// usampler2D
454		TYPE_INVALID,		// usamplerCube
455		TYPE_INVALID,		// usampler2DArray
456		TYPE_INVALID,		// usampler3D
457		TYPE_INVALID,		// usamplerCubeArray
458		TYPE_INVALID,		// sampler2DMS
459		TYPE_INVALID,		// isampler2DMS
460		TYPE_INVALID,		// usampler2DMS
461		TYPE_INVALID,		// image2D
462		TYPE_INVALID,		// imageCube
463		TYPE_INVALID,		// image2DArray
464		TYPE_INVALID,		// image3D
465		TYPE_INVALID,		// imageCubeArray
466		TYPE_INVALID,		// iimage2D
467		TYPE_INVALID,		// iimageCube
468		TYPE_INVALID,		// iimage2DArray
469		TYPE_INVALID,		// iimage3D
470		TYPE_INVALID,		// iimageCubeArray
471		TYPE_INVALID,		// uimage2D
472		TYPE_INVALID,		// uimageCube
473		TYPE_INVALID,		// uimage2DArray
474		TYPE_INVALID,		// uimage3D
475		TYPE_INVALID,		// uimageCubeArray
476		TYPE_INVALID,		// atomic_uint
477	};
478
479	DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
480	DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
481	return s_floatTypes[(int)dataType];
482}
483
484DataType getDataTypeVector (DataType scalarType, int size)
485{
486	DE_ASSERT(deInRange32(size, 1, 4));
487	switch (scalarType)
488	{
489		case TYPE_FLOAT:
490		case TYPE_INT:
491		case TYPE_UINT:
492		case TYPE_BOOL:
493			return (DataType)((int)scalarType + size - 1);
494		default:
495			return TYPE_INVALID;
496	}
497}
498
499DataType getDataTypeFloatVec (int vecSize)
500{
501	return getDataTypeVector(TYPE_FLOAT, vecSize);
502}
503
504DataType getDataTypeIntVec (int vecSize)
505{
506	return getDataTypeVector(TYPE_INT, vecSize);
507}
508
509DataType getDataTypeUintVec (int vecSize)
510{
511	return getDataTypeVector(TYPE_UINT, vecSize);
512}
513
514DataType getDataTypeBoolVec (int vecSize)
515{
516	return getDataTypeVector(TYPE_BOOL, vecSize);
517}
518
519DataType getDataTypeMatrix (int numCols, int numRows)
520{
521	DE_ASSERT(de::inRange(numCols, 2, 4) && de::inRange(numRows, 2, 4));
522	return (DataType)((int)TYPE_FLOAT_MAT2 + (numCols-2)*3 + (numRows-2));
523}
524
525int getDataTypeMatrixNumRows (DataType dataType)
526{
527	switch (dataType)
528	{
529		case TYPE_FLOAT_MAT2:	return 2;
530		case TYPE_FLOAT_MAT2X3:	return 3;
531		case TYPE_FLOAT_MAT2X4:	return 4;
532		case TYPE_FLOAT_MAT3X2:	return 2;
533		case TYPE_FLOAT_MAT3:	return 3;
534		case TYPE_FLOAT_MAT3X4:	return 4;
535		case TYPE_FLOAT_MAT4X2:	return 2;
536		case TYPE_FLOAT_MAT4X3:	return 3;
537		case TYPE_FLOAT_MAT4:	return 4;
538		default:
539			DE_ASSERT(false);
540			return 0;
541	}
542}
543
544int getDataTypeMatrixNumColumns (DataType dataType)
545{
546	switch (dataType)
547	{
548		case TYPE_FLOAT_MAT2:	return 2;
549		case TYPE_FLOAT_MAT2X3:	return 2;
550		case TYPE_FLOAT_MAT2X4:	return 2;
551		case TYPE_FLOAT_MAT3X2:	return 3;
552		case TYPE_FLOAT_MAT3:	return 3;
553		case TYPE_FLOAT_MAT3X4:	return 3;
554		case TYPE_FLOAT_MAT4X2:	return 4;
555		case TYPE_FLOAT_MAT4X3:	return 4;
556		case TYPE_FLOAT_MAT4:	return 4;
557		default:
558			DE_ASSERT(false);
559			return 0;
560	}
561}
562
563int	getDataTypeNumLocations	(DataType dataType)
564{
565	if (isDataTypeScalarOrVector(dataType))
566		return 1;
567	else if (isDataTypeMatrix(dataType))
568		return getDataTypeMatrixNumColumns(dataType);
569
570	DE_ASSERT(!"Illegal datatype.");
571	return 0;
572}
573
574int	getDataTypeNumComponents (DataType dataType)
575{
576	if (isDataTypeScalarOrVector(dataType))
577		return getDataTypeScalarSize(dataType);
578	else if (isDataTypeMatrix(dataType))
579		return getDataTypeMatrixNumRows(dataType);
580
581	DE_ASSERT(!"Illegal datatype.");
582	return 0;
583}
584
585DataType getDataTypeFromGLType (deUint32 glType)
586{
587	switch (glType)
588	{
589		case GL_FLOAT:									return TYPE_FLOAT;
590		case GL_FLOAT_VEC2:								return TYPE_FLOAT_VEC2;
591		case GL_FLOAT_VEC3:								return TYPE_FLOAT_VEC3;
592		case GL_FLOAT_VEC4:								return TYPE_FLOAT_VEC4;
593
594		case GL_FLOAT_MAT2:								return TYPE_FLOAT_MAT2;
595		case GL_FLOAT_MAT2x3:							return TYPE_FLOAT_MAT2X3;
596		case GL_FLOAT_MAT2x4:							return TYPE_FLOAT_MAT2X4;
597
598		case GL_FLOAT_MAT3x2:							return TYPE_FLOAT_MAT3X2;
599		case GL_FLOAT_MAT3:								return TYPE_FLOAT_MAT3;
600		case GL_FLOAT_MAT3x4:							return TYPE_FLOAT_MAT3X4;
601
602		case GL_FLOAT_MAT4x2:							return TYPE_FLOAT_MAT4X2;
603		case GL_FLOAT_MAT4x3:							return TYPE_FLOAT_MAT4X3;
604		case GL_FLOAT_MAT4:								return TYPE_FLOAT_MAT4;
605
606		case GL_INT:									return TYPE_INT;
607		case GL_INT_VEC2:								return TYPE_INT_VEC2;
608		case GL_INT_VEC3:								return TYPE_INT_VEC3;
609		case GL_INT_VEC4:								return TYPE_INT_VEC4;
610
611		case GL_UNSIGNED_INT:							return TYPE_UINT;
612		case GL_UNSIGNED_INT_VEC2:						return TYPE_UINT_VEC2;
613		case GL_UNSIGNED_INT_VEC3:						return TYPE_UINT_VEC3;
614		case GL_UNSIGNED_INT_VEC4:						return TYPE_UINT_VEC4;
615
616		case GL_BOOL:									return TYPE_BOOL;
617		case GL_BOOL_VEC2:								return TYPE_BOOL_VEC2;
618		case GL_BOOL_VEC3:								return TYPE_BOOL_VEC3;
619		case GL_BOOL_VEC4:								return TYPE_BOOL_VEC4;
620
621		case GL_SAMPLER_1D:								return TYPE_SAMPLER_1D;
622		case GL_SAMPLER_2D:								return TYPE_SAMPLER_2D;
623		case GL_SAMPLER_CUBE:							return TYPE_SAMPLER_CUBE;
624		case GL_SAMPLER_2D_ARRAY:						return TYPE_SAMPLER_2D_ARRAY;
625		case GL_SAMPLER_3D:								return TYPE_SAMPLER_3D;
626		case GL_SAMPLER_CUBE_MAP_ARRAY:					return TYPE_SAMPLER_CUBE_ARRAY;
627
628		case GL_SAMPLER_1D_SHADOW:						return TYPE_SAMPLER_1D_SHADOW;
629		case GL_SAMPLER_2D_SHADOW:						return TYPE_SAMPLER_2D_SHADOW;
630		case GL_SAMPLER_CUBE_SHADOW:					return TYPE_SAMPLER_CUBE_SHADOW;
631		case GL_SAMPLER_2D_ARRAY_SHADOW:				return TYPE_SAMPLER_2D_ARRAY_SHADOW;
632		case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:			return TYPE_SAMPLER_CUBE_ARRAY_SHADOW;
633
634		case GL_INT_SAMPLER_1D:							return TYPE_INT_SAMPLER_1D;
635		case GL_INT_SAMPLER_2D:							return TYPE_INT_SAMPLER_2D;
636		case GL_INT_SAMPLER_CUBE:						return TYPE_INT_SAMPLER_CUBE;
637		case GL_INT_SAMPLER_2D_ARRAY:					return TYPE_INT_SAMPLER_2D_ARRAY;
638		case GL_INT_SAMPLER_3D:							return TYPE_INT_SAMPLER_3D;
639		case GL_INT_SAMPLER_CUBE_MAP_ARRAY:				return TYPE_INT_SAMPLER_CUBE_ARRAY;
640
641		case GL_UNSIGNED_INT_SAMPLER_1D:				return TYPE_UINT_SAMPLER_1D;
642		case GL_UNSIGNED_INT_SAMPLER_2D:				return TYPE_UINT_SAMPLER_2D;
643		case GL_UNSIGNED_INT_SAMPLER_CUBE:				return TYPE_UINT_SAMPLER_CUBE;
644		case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:			return TYPE_UINT_SAMPLER_2D_ARRAY;
645		case GL_UNSIGNED_INT_SAMPLER_3D:				return TYPE_UINT_SAMPLER_3D;
646		case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:	return TYPE_UINT_SAMPLER_CUBE_ARRAY;
647
648		case GL_SAMPLER_2D_MULTISAMPLE:					return TYPE_SAMPLER_2D_MULTISAMPLE;
649		case GL_INT_SAMPLER_2D_MULTISAMPLE:				return TYPE_INT_SAMPLER_2D_MULTISAMPLE;
650		case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:	return TYPE_UINT_SAMPLER_2D_MULTISAMPLE;
651
652		case GL_IMAGE_2D:								return TYPE_IMAGE_2D;
653		case GL_IMAGE_CUBE:								return TYPE_IMAGE_CUBE;
654		case GL_IMAGE_2D_ARRAY:							return TYPE_IMAGE_2D_ARRAY;
655		case GL_IMAGE_3D:								return TYPE_IMAGE_3D;
656		case GL_INT_IMAGE_2D:							return TYPE_INT_IMAGE_2D;
657		case GL_INT_IMAGE_CUBE:							return TYPE_INT_IMAGE_CUBE;
658		case GL_INT_IMAGE_2D_ARRAY:						return TYPE_INT_IMAGE_2D_ARRAY;
659		case GL_INT_IMAGE_3D:							return TYPE_INT_IMAGE_3D;
660		case GL_UNSIGNED_INT_IMAGE_2D:					return TYPE_UINT_IMAGE_2D;
661		case GL_UNSIGNED_INT_IMAGE_CUBE:				return TYPE_UINT_IMAGE_CUBE;
662		case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:			return TYPE_UINT_IMAGE_2D_ARRAY;
663		case GL_UNSIGNED_INT_IMAGE_3D:					return TYPE_UINT_IMAGE_3D;
664
665		case GL_UNSIGNED_INT_ATOMIC_COUNTER:			return TYPE_UINT_ATOMIC_COUNTER;
666
667		default:
668			return TYPE_LAST;
669	}
670}
671
672} // glu
673