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