1 #ifndef _GLUSHADERUTIL_HPP
2 #define _GLUSHADERUTIL_HPP
3 /*-------------------------------------------------------------------------
4 * drawElements Quality Program OpenGL ES Utilities
5 * ------------------------------------------------
6 *
7 * Copyright 2014 The Android Open Source Project
8 *
9 * Licensed under the Apache License, Version 2.0 (the "License");
10 * you may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * http://www.apache.org/licenses/LICENSE-2.0
14 *
15 * Unless required by applicable law or agreed to in writing, software
16 * distributed under the License is distributed on an "AS IS" BASIS,
17 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
18 * See the License for the specific language governing permissions and
19 * limitations under the License.
20 *
21 *//*!
22 * \file
23 * \brief Shader utilities.
24 *//*--------------------------------------------------------------------*/
25
26 #include "tcuDefs.hpp"
27 #include "deInt32.h"
28 #include "gluRenderContext.hpp"
29 #include "tcuVector.hpp"
30 #include "tcuVector.hpp"
31 #include "tcuMatrix.hpp"
32
33 namespace glu
34 {
35
36 // ShadingLanguageVersion
37
38 enum GLSLVersion
39 {
40 GLSL_VERSION_100_ES = 0, //!< GLSL ES 1.0
41 GLSL_VERSION_300_ES, //!< GLSL ES 3.0
42 GLSL_VERSION_310_ES, //!< GLSL ES 3.1
43 GLSL_VERSION_320_ES, //!< GLSL ES 3.2
44
45 GLSL_VERSION_130, //!< GLSL 1.3
46 GLSL_VERSION_140, //!< GLSL 1.4
47 GLSL_VERSION_150, //!< GLSL 1.5
48 GLSL_VERSION_330, //!< GLSL 3.0
49 GLSL_VERSION_400, //!< GLSL 4.0
50 GLSL_VERSION_410, //!< GLSL 4.1
51 GLSL_VERSION_420, //!< GLSL 4.2
52 GLSL_VERSION_430, //!< GLSL 4.3
53 GLSL_VERSION_440, //!< GLSL 4.4
54 GLSL_VERSION_450, //!< GLSL 4.5
55 GLSL_VERSION_460, //!< GLSL 4.6
56
57 GLSL_VERSION_LAST
58 };
59
60 const char *getGLSLVersionName(GLSLVersion version);
61 const char *getGLSLVersionDeclaration(GLSLVersion version);
62 bool glslVersionUsesInOutQualifiers(GLSLVersion version);
63 bool glslVersionIsES(GLSLVersion version);
64 bool isGLSLVersionSupported(ContextType type, GLSLVersion version);
65 GLSLVersion getContextTypeGLSLVersion(ContextType type);
66
67 // ShaderType
68
69 enum ShaderType
70 {
71 SHADERTYPE_VERTEX = 0,
72 SHADERTYPE_FRAGMENT,
73 SHADERTYPE_GEOMETRY,
74 SHADERTYPE_TESSELLATION_CONTROL,
75 SHADERTYPE_TESSELLATION_EVALUATION,
76 SHADERTYPE_COMPUTE,
77
78 SHADERTYPE_RAYGEN,
79 SHADERTYPE_ANY_HIT,
80 SHADERTYPE_CLOSEST_HIT,
81 SHADERTYPE_MISS,
82 SHADERTYPE_INTERSECTION,
83 SHADERTYPE_CALLABLE,
84
85 SHADERTYPE_TASK,
86 SHADERTYPE_MESH,
87
88 SHADERTYPE_LAST
89 };
90
91 const char *getShaderTypeName(ShaderType shaderType);
92 std::string getShaderTypePostfix(ShaderType shaderType);
93
94 // Precision
95
96 enum Precision
97 {
98 PRECISION_LOWP = 0,
99 PRECISION_MEDIUMP,
100 PRECISION_HIGHP,
101
102 PRECISION_LAST
103 };
104
105 const char *getPrecisionName(Precision precision);
106 std::string getPrecisionPostfix(Precision precision);
107
108 // DataType
109
110 enum DataType
111 {
112 TYPE_INVALID = 0,
113
114 TYPE_FLOAT,
115 TYPE_FLOAT_VEC2,
116 TYPE_FLOAT_VEC3,
117 TYPE_FLOAT_VEC4,
118 TYPE_FLOAT_MAT2,
119 TYPE_FLOAT_MAT2X3,
120 TYPE_FLOAT_MAT2X4,
121 TYPE_FLOAT_MAT3X2,
122 TYPE_FLOAT_MAT3,
123 TYPE_FLOAT_MAT3X4,
124 TYPE_FLOAT_MAT4X2,
125 TYPE_FLOAT_MAT4X3,
126 TYPE_FLOAT_MAT4,
127
128 TYPE_DOUBLE,
129 TYPE_DOUBLE_VEC2,
130 TYPE_DOUBLE_VEC3,
131 TYPE_DOUBLE_VEC4,
132 TYPE_DOUBLE_MAT2,
133 TYPE_DOUBLE_MAT2X3,
134 TYPE_DOUBLE_MAT2X4,
135 TYPE_DOUBLE_MAT3X2,
136 TYPE_DOUBLE_MAT3,
137 TYPE_DOUBLE_MAT3X4,
138 TYPE_DOUBLE_MAT4X2,
139 TYPE_DOUBLE_MAT4X3,
140 TYPE_DOUBLE_MAT4,
141
142 TYPE_INT,
143 TYPE_INT_VEC2,
144 TYPE_INT_VEC3,
145 TYPE_INT_VEC4,
146
147 TYPE_UINT,
148 TYPE_UINT_VEC2,
149 TYPE_UINT_VEC3,
150 TYPE_UINT_VEC4,
151
152 TYPE_BOOL,
153 TYPE_BOOL_VEC2,
154 TYPE_BOOL_VEC3,
155 TYPE_BOOL_VEC4,
156
157 TYPE_SAMPLER_1D,
158 TYPE_SAMPLER_2D,
159 TYPE_SAMPLER_CUBE,
160 TYPE_SAMPLER_1D_ARRAY,
161 TYPE_SAMPLER_2D_ARRAY,
162 TYPE_SAMPLER_3D,
163 TYPE_SAMPLER_CUBE_ARRAY,
164
165 TYPE_SAMPLER_1D_SHADOW,
166 TYPE_SAMPLER_2D_SHADOW,
167 TYPE_SAMPLER_CUBE_SHADOW,
168 TYPE_SAMPLER_1D_ARRAY_SHADOW,
169 TYPE_SAMPLER_2D_ARRAY_SHADOW,
170 TYPE_SAMPLER_CUBE_ARRAY_SHADOW,
171
172 TYPE_INT_SAMPLER_1D,
173 TYPE_INT_SAMPLER_2D,
174 TYPE_INT_SAMPLER_CUBE,
175 TYPE_INT_SAMPLER_1D_ARRAY,
176 TYPE_INT_SAMPLER_2D_ARRAY,
177 TYPE_INT_SAMPLER_3D,
178 TYPE_INT_SAMPLER_CUBE_ARRAY,
179
180 TYPE_UINT_SAMPLER_1D,
181 TYPE_UINT_SAMPLER_2D,
182 TYPE_UINT_SAMPLER_CUBE,
183 TYPE_UINT_SAMPLER_1D_ARRAY,
184 TYPE_UINT_SAMPLER_2D_ARRAY,
185 TYPE_UINT_SAMPLER_3D,
186 TYPE_UINT_SAMPLER_CUBE_ARRAY,
187
188 TYPE_SAMPLER_2D_MULTISAMPLE,
189 TYPE_INT_SAMPLER_2D_MULTISAMPLE,
190 TYPE_UINT_SAMPLER_2D_MULTISAMPLE,
191
192 TYPE_IMAGE_2D,
193 TYPE_IMAGE_CUBE,
194 TYPE_IMAGE_2D_ARRAY,
195 TYPE_IMAGE_3D,
196 TYPE_IMAGE_CUBE_ARRAY,
197
198 TYPE_INT_IMAGE_2D,
199 TYPE_INT_IMAGE_CUBE,
200 TYPE_INT_IMAGE_2D_ARRAY,
201 TYPE_INT_IMAGE_3D,
202 TYPE_INT_IMAGE_CUBE_ARRAY,
203
204 TYPE_UINT_IMAGE_2D,
205 TYPE_UINT_IMAGE_CUBE,
206 TYPE_UINT_IMAGE_2D_ARRAY,
207 TYPE_UINT_IMAGE_3D,
208 TYPE_UINT_IMAGE_CUBE_ARRAY,
209
210 TYPE_UINT_ATOMIC_COUNTER,
211
212 TYPE_SAMPLER_BUFFER,
213 TYPE_INT_SAMPLER_BUFFER,
214 TYPE_UINT_SAMPLER_BUFFER,
215
216 TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY,
217 TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY,
218 TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY,
219
220 TYPE_IMAGE_BUFFER,
221 TYPE_INT_IMAGE_BUFFER,
222 TYPE_UINT_IMAGE_BUFFER,
223
224 TYPE_UINT8,
225 TYPE_UINT8_VEC2,
226 TYPE_UINT8_VEC3,
227 TYPE_UINT8_VEC4,
228
229 TYPE_INT8,
230 TYPE_INT8_VEC2,
231 TYPE_INT8_VEC3,
232 TYPE_INT8_VEC4,
233
234 TYPE_UINT16,
235 TYPE_UINT16_VEC2,
236 TYPE_UINT16_VEC3,
237 TYPE_UINT16_VEC4,
238
239 TYPE_INT16,
240 TYPE_INT16_VEC2,
241 TYPE_INT16_VEC3,
242 TYPE_INT16_VEC4,
243
244 TYPE_FLOAT16,
245 TYPE_FLOAT16_VEC2,
246 TYPE_FLOAT16_VEC3,
247 TYPE_FLOAT16_VEC4,
248 TYPE_FLOAT16_MAT2,
249 TYPE_FLOAT16_MAT2X3,
250 TYPE_FLOAT16_MAT2X4,
251 TYPE_FLOAT16_MAT3X2,
252 TYPE_FLOAT16_MAT3,
253 TYPE_FLOAT16_MAT3X4,
254 TYPE_FLOAT16_MAT4X2,
255 TYPE_FLOAT16_MAT4X3,
256 TYPE_FLOAT16_MAT4,
257
258 TYPE_LAST
259 };
260
261 const char *getDataTypeName(DataType dataType);
262 int getDataTypeScalarSize(DataType dataType);
263 DataType getDataTypeScalarType(DataType dataType);
264 DataType getDataTypeFloat16Scalars(DataType dataType);
265 DataType getDataTypeFloatScalars(DataType dataType);
266 DataType getDataTypeDoubleScalars(DataType dataType);
267 DataType getDataTypeVector(DataType scalarType, int size);
268 DataType getDataTypeFloatVec(int vecSize);
269 DataType getDataTypeIntVec(int vecSize);
270 DataType getDataTypeUintVec(int vecSize);
271 DataType getDataTypeBoolVec(int vecSize);
272 DataType getDataTypeMatrix(int numCols, int numRows);
273 DataType getDataTypeFromGLType(uint32_t glType);
274
isDataTypeFloat16OrVec(DataType dataType)275 inline bool isDataTypeFloat16OrVec(DataType dataType)
276 {
277 return (dataType >= TYPE_FLOAT16) && (dataType <= TYPE_FLOAT16_MAT4);
278 }
isDataTypeFloatOrVec(DataType dataType)279 inline bool isDataTypeFloatOrVec(DataType dataType)
280 {
281 return (dataType >= TYPE_FLOAT) && (dataType <= TYPE_FLOAT_VEC4);
282 }
isDataTypeFloatType(DataType dataType)283 inline bool isDataTypeFloatType(DataType dataType)
284 {
285 return (dataType >= TYPE_FLOAT) && (dataType <= TYPE_FLOAT_MAT4);
286 }
isDataTypeDoubleType(DataType dataType)287 inline bool isDataTypeDoubleType(DataType dataType)
288 {
289 return (dataType >= TYPE_DOUBLE) && (dataType <= TYPE_DOUBLE_MAT4);
290 }
isDataTypeDoubleOrDVec(DataType dataType)291 inline bool isDataTypeDoubleOrDVec(DataType dataType)
292 {
293 return (dataType >= TYPE_DOUBLE) && (dataType <= TYPE_DOUBLE_VEC4);
294 }
isDataTypeMatrix(DataType dataType)295 inline bool isDataTypeMatrix(DataType dataType)
296 {
297 return ((dataType >= TYPE_FLOAT_MAT2) && (dataType <= TYPE_FLOAT_MAT4)) ||
298 ((dataType >= TYPE_DOUBLE_MAT2) && (dataType <= TYPE_DOUBLE_MAT4)) ||
299 ((dataType >= TYPE_FLOAT16_MAT2) && (dataType <= TYPE_FLOAT16_MAT4));
300 }
isDataTypeIntOrIVec(DataType dataType)301 inline bool isDataTypeIntOrIVec(DataType dataType)
302 {
303 return (dataType >= TYPE_INT) && (dataType <= TYPE_INT_VEC4);
304 }
isDataTypeUintOrUVec(DataType dataType)305 inline bool isDataTypeUintOrUVec(DataType dataType)
306 {
307 return (dataType >= TYPE_UINT) && (dataType <= TYPE_UINT_VEC4);
308 }
isDataTypeIntOrIVec8Bit(DataType dataType)309 inline bool isDataTypeIntOrIVec8Bit(DataType dataType)
310 {
311 return (dataType >= TYPE_INT8) && (dataType <= TYPE_INT8_VEC4);
312 }
isDataTypeUintOrUVec8Bit(DataType dataType)313 inline bool isDataTypeUintOrUVec8Bit(DataType dataType)
314 {
315 return (dataType >= TYPE_UINT8) && (dataType <= TYPE_UINT8_VEC4);
316 }
isDataTypeIntOrIVec16Bit(DataType dataType)317 inline bool isDataTypeIntOrIVec16Bit(DataType dataType)
318 {
319 return (dataType >= TYPE_INT16) && (dataType <= TYPE_INT16_VEC4);
320 }
isDataTypeUintOrUVec16Bit(DataType dataType)321 inline bool isDataTypeUintOrUVec16Bit(DataType dataType)
322 {
323 return (dataType >= TYPE_UINT16) && (dataType <= TYPE_UINT16_VEC4);
324 }
isDataTypeBoolOrBVec(DataType dataType)325 inline bool isDataTypeBoolOrBVec(DataType dataType)
326 {
327 return (dataType >= TYPE_BOOL) && (dataType <= TYPE_BOOL_VEC4);
328 }
isDataTypeScalar(DataType dataType)329 inline bool isDataTypeScalar(DataType dataType)
330 {
331 return (dataType == TYPE_FLOAT) || (dataType == TYPE_DOUBLE) || (dataType == TYPE_INT) || (dataType == TYPE_UINT) ||
332 (dataType == TYPE_BOOL) || (dataType == TYPE_UINT8) || (dataType == TYPE_INT8) ||
333 (dataType == TYPE_UINT16) || (dataType == TYPE_INT16) || (dataType == TYPE_FLOAT16);
334 }
isDataTypeVector(DataType dataType)335 inline bool isDataTypeVector(DataType dataType)
336 {
337 return deInRange32(dataType, TYPE_FLOAT_VEC2, TYPE_FLOAT_VEC4) ||
338 deInRange32(dataType, TYPE_DOUBLE_VEC2, TYPE_DOUBLE_VEC4) ||
339 deInRange32(dataType, TYPE_INT_VEC2, TYPE_INT_VEC4) ||
340 deInRange32(dataType, TYPE_UINT_VEC2, TYPE_UINT_VEC4) ||
341 deInRange32(dataType, TYPE_BOOL_VEC2, TYPE_BOOL_VEC4) ||
342 deInRange32(dataType, TYPE_UINT8_VEC2, TYPE_UINT8_VEC4) ||
343 deInRange32(dataType, TYPE_INT8_VEC2, TYPE_INT8_VEC4) ||
344 deInRange32(dataType, TYPE_UINT16_VEC2, TYPE_UINT16_VEC4) ||
345 deInRange32(dataType, TYPE_INT16_VEC2, TYPE_INT16_VEC4) ||
346 deInRange32(dataType, TYPE_FLOAT16_VEC2, TYPE_FLOAT16_VEC4);
347 }
isDataTypeScalarOrVector(DataType dataType)348 inline bool isDataTypeScalarOrVector(DataType dataType)
349 {
350 return deInRange32(dataType, TYPE_FLOAT, TYPE_FLOAT_VEC4) || deInRange32(dataType, TYPE_DOUBLE, TYPE_DOUBLE_VEC4) ||
351 deInRange32(dataType, TYPE_INT, TYPE_INT_VEC4) || deInRange32(dataType, TYPE_UINT, TYPE_UINT_VEC4) ||
352 deInRange32(dataType, TYPE_BOOL, TYPE_BOOL_VEC4) || deInRange32(dataType, TYPE_UINT8, TYPE_UINT8_VEC4) ||
353 deInRange32(dataType, TYPE_INT8, TYPE_INT8_VEC4) || deInRange32(dataType, TYPE_UINT16, TYPE_UINT16_VEC4) ||
354 deInRange32(dataType, TYPE_INT16, TYPE_INT16_VEC4) || deInRange32(dataType, TYPE_FLOAT16, TYPE_FLOAT16_VEC4);
355 }
isDataTypeSampler(DataType dataType)356 inline bool isDataTypeSampler(DataType dataType)
357 {
358 return (dataType >= TYPE_SAMPLER_1D) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE);
359 }
isDataTypeImage(DataType dataType)360 inline bool isDataTypeImage(DataType dataType)
361 {
362 return (dataType >= TYPE_IMAGE_2D) && (dataType <= TYPE_UINT_IMAGE_3D);
363 }
isDataTypeSamplerMultisample(DataType dataType)364 inline bool isDataTypeSamplerMultisample(DataType dataType)
365 {
366 return (dataType >= TYPE_SAMPLER_2D_MULTISAMPLE) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE);
367 }
isDataTypeAtomicCounter(DataType dataType)368 inline bool isDataTypeAtomicCounter(DataType dataType)
369 {
370 return dataType == TYPE_UINT_ATOMIC_COUNTER;
371 }
isDataTypeSamplerBuffer(DataType dataType)372 inline bool isDataTypeSamplerBuffer(DataType dataType)
373 {
374 return (dataType >= TYPE_SAMPLER_BUFFER) && (dataType <= TYPE_UINT_SAMPLER_BUFFER);
375 }
isDataTypeSamplerMSArray(DataType dataType)376 inline bool isDataTypeSamplerMSArray(DataType dataType)
377 {
378 return (dataType >= TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY) && (dataType <= TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY);
379 }
isDataTypeImageBuffer(DataType dataType)380 inline bool isDataTypeImageBuffer(DataType dataType)
381 {
382 return (dataType >= TYPE_IMAGE_BUFFER) && (dataType <= TYPE_UINT_IMAGE_BUFFER);
383 }
isDataTypeExplicitPrecision(DataType dataType)384 inline bool isDataTypeExplicitPrecision(DataType dataType)
385 {
386 return deInRange32(dataType, TYPE_UINT8, TYPE_UINT8_VEC4) || deInRange32(dataType, TYPE_INT8, TYPE_INT8_VEC4) ||
387 deInRange32(dataType, TYPE_UINT16, TYPE_UINT16_VEC4) || deInRange32(dataType, TYPE_INT16, TYPE_INT16_VEC4) ||
388 deInRange32(dataType, TYPE_FLOAT16, TYPE_FLOAT16_MAT4) ||
389 deInRange32(dataType, TYPE_DOUBLE, TYPE_DOUBLE_MAT4);
390 }
dataTypeSupportsPrecisionModifier(DataType dataType)391 inline bool dataTypeSupportsPrecisionModifier(DataType dataType)
392 {
393 return !isDataTypeBoolOrBVec(dataType) && !isDataTypeExplicitPrecision(dataType);
394 }
395
396 int getDataTypeMatrixNumRows(DataType dataType);
397 int getDataTypeMatrixNumColumns(DataType dataType);
398 DataType getDataTypeMatrixColumnType(DataType dataType);
399
400 int getDataTypeNumLocations(DataType dataType);
401 int getDataTypeNumComponents(DataType dataType);
402
403 template <typename T>
404 struct DataTypeTraits;
405
406 template <>
407 struct DataTypeTraits<uint16_t>
408 {
409 enum
410 {
411 DATATYPE = TYPE_FLOAT16
412 };
413 };
414 template <>
415 struct DataTypeTraits<float>
416 {
417 enum
418 {
419 DATATYPE = TYPE_FLOAT
420 };
421 };
422 template <>
423 struct DataTypeTraits<double>
424 {
425 enum
426 {
427 DATATYPE = TYPE_DOUBLE
428 };
429 };
430 template <>
431 struct DataTypeTraits<bool>
432 {
433 enum
434 {
435 DATATYPE = TYPE_BOOL
436 };
437 };
438 template <>
439 struct DataTypeTraits<int>
440 {
441 enum
442 {
443 DATATYPE = TYPE_INT
444 };
445 };
446 template <>
447 struct DataTypeTraits<uint32_t>
448 {
449 enum
450 {
451 DATATYPE = TYPE_UINT
452 };
453 };
454 template <>
455 struct DataTypeTraits<tcu::Mat2>
456 {
457 enum
458 {
459 DATATYPE = TYPE_FLOAT_MAT2
460 };
461 };
462 template <>
463 struct DataTypeTraits<tcu::Mat2x3>
464 {
465 enum
466 {
467 DATATYPE = TYPE_FLOAT_MAT2X3
468 };
469 };
470 template <>
471 struct DataTypeTraits<tcu::Mat2x4>
472 {
473 enum
474 {
475 DATATYPE = TYPE_FLOAT_MAT2X4
476 };
477 };
478 template <>
479 struct DataTypeTraits<tcu::Mat3x2>
480 {
481 enum
482 {
483 DATATYPE = TYPE_FLOAT_MAT3X2
484 };
485 };
486 template <>
487 struct DataTypeTraits<tcu::Mat3>
488 {
489 enum
490 {
491 DATATYPE = TYPE_FLOAT_MAT3
492 };
493 };
494 template <>
495 struct DataTypeTraits<tcu::Mat3x4>
496 {
497 enum
498 {
499 DATATYPE = TYPE_FLOAT_MAT3X4
500 };
501 };
502 template <>
503 struct DataTypeTraits<tcu::Mat4x2>
504 {
505 enum
506 {
507 DATATYPE = TYPE_FLOAT_MAT4X2
508 };
509 };
510 template <>
511 struct DataTypeTraits<tcu::Mat4x3>
512 {
513 enum
514 {
515 DATATYPE = TYPE_FLOAT_MAT4X3
516 };
517 };
518 template <>
519 struct DataTypeTraits<tcu::Mat4>
520 {
521 enum
522 {
523 DATATYPE = TYPE_FLOAT_MAT4
524 };
525 };
526 template <>
527 struct DataTypeTraits<tcu::Mat2_16b>
528 {
529 enum
530 {
531 DATATYPE = TYPE_FLOAT16_MAT2
532 };
533 };
534 template <>
535 struct DataTypeTraits<tcu::Mat2x3_16b>
536 {
537 enum
538 {
539 DATATYPE = TYPE_FLOAT16_MAT2X3
540 };
541 };
542 template <>
543 struct DataTypeTraits<tcu::Mat2x4_16b>
544 {
545 enum
546 {
547 DATATYPE = TYPE_FLOAT16_MAT2X4
548 };
549 };
550 template <>
551 struct DataTypeTraits<tcu::Mat3x2_16b>
552 {
553 enum
554 {
555 DATATYPE = TYPE_FLOAT16_MAT3X2
556 };
557 };
558 template <>
559 struct DataTypeTraits<tcu::Mat3_16b>
560 {
561 enum
562 {
563 DATATYPE = TYPE_FLOAT16_MAT3
564 };
565 };
566 template <>
567 struct DataTypeTraits<tcu::Mat3x4_16b>
568 {
569 enum
570 {
571 DATATYPE = TYPE_FLOAT16_MAT3X4
572 };
573 };
574 template <>
575 struct DataTypeTraits<tcu::Mat4x2_16b>
576 {
577 enum
578 {
579 DATATYPE = TYPE_FLOAT16_MAT4X2
580 };
581 };
582 template <>
583 struct DataTypeTraits<tcu::Mat4x3_16b>
584 {
585 enum
586 {
587 DATATYPE = TYPE_FLOAT16_MAT4X3
588 };
589 };
590 template <>
591 struct DataTypeTraits<tcu::Mat4_16b>
592 {
593 enum
594 {
595 DATATYPE = TYPE_FLOAT16_MAT4
596 };
597 };
598 template <>
599 struct DataTypeTraits<tcu::Matrix2d>
600 {
601 enum
602 {
603 DATATYPE = TYPE_DOUBLE_MAT2
604 };
605 };
606 template <>
607 struct DataTypeTraits<tcu::Matrix3d>
608 {
609 enum
610 {
611 DATATYPE = TYPE_DOUBLE_MAT3
612 };
613 };
614 template <>
615 struct DataTypeTraits<tcu::Matrix4d>
616 {
617 enum
618 {
619 DATATYPE = TYPE_DOUBLE_MAT4
620 };
621 };
622 template <>
623 struct DataTypeTraits<tcu::Mat2x3d>
624 {
625 enum
626 {
627 DATATYPE = TYPE_DOUBLE_MAT2X3
628 };
629 };
630 template <>
631 struct DataTypeTraits<tcu::Mat2x4d>
632 {
633 enum
634 {
635 DATATYPE = TYPE_DOUBLE_MAT2X4
636 };
637 };
638 template <>
639 struct DataTypeTraits<tcu::Mat3x2d>
640 {
641 enum
642 {
643 DATATYPE = TYPE_DOUBLE_MAT3X2
644 };
645 };
646 template <>
647 struct DataTypeTraits<tcu::Mat3x4d>
648 {
649 enum
650 {
651 DATATYPE = TYPE_DOUBLE_MAT3X4
652 };
653 };
654 template <>
655 struct DataTypeTraits<tcu::Mat4x2d>
656 {
657 enum
658 {
659 DATATYPE = TYPE_DOUBLE_MAT4X2
660 };
661 };
662 template <>
663 struct DataTypeTraits<tcu::Mat4x3d>
664 {
665 enum
666 {
667 DATATYPE = TYPE_DOUBLE_MAT4X3
668 };
669 };
670
671 template <typename T, int Size>
672 struct DataTypeTraits<tcu::Vector<T, Size>>
673 {
674 DE_STATIC_ASSERT(TYPE_FLOAT_VEC4 == TYPE_FLOAT + 3);
675 DE_STATIC_ASSERT(TYPE_INT_VEC4 == TYPE_INT + 3);
676 DE_STATIC_ASSERT(TYPE_UINT_VEC4 == TYPE_UINT + 3);
677 DE_STATIC_ASSERT(TYPE_BOOL_VEC4 == TYPE_BOOL + 3);
678 DE_STATIC_ASSERT(TYPE_DOUBLE_VEC4 == TYPE_DOUBLE + 3);
679 enum
680 {
681 DATATYPE = DataTypeTraits<T>::DATATYPE + Size - 1
682 };
683 };
684
685 template <typename T>
dataTypeOf(void)686 inline DataType dataTypeOf(void)
687 {
688 return DataType(DataTypeTraits<T>::DATATYPE);
689 }
690
691 } // namespace glu
692
693 #endif // _GLUSHADERUTIL_HPP
694