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 #include "deArrayUtil.hpp"
27
28 #include <fstream>
29
30 namespace glu
31 {
32
33 // ShadingLanguageVersion
34
getGLSLVersionName(GLSLVersion version)35 const char *getGLSLVersionName(GLSLVersion version)
36 {
37 static const char *s_names[] = {
38 "GLSL ES 1.0", "GLSL ES 3.0", "GLSL ES 3.1", "GLSL ES 3.2", "GLSL 1.3", "GLSL 1.4", "GLSL 1.5", "GLSL 3.3",
39 "GLSL 4.0", "GLSL 4.1", "GLSL 4.2", "GLSL 4.3", "GLSL 4.4", "GLSL 4.5", "GLSL 4.6",
40 };
41
42 return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_names, version);
43 }
44
getGLSLVersionDeclaration(GLSLVersion version)45 const char *getGLSLVersionDeclaration(GLSLVersion version)
46 {
47 static const char *s_decl[] = {
48 "#version 100", "#version 300 es", "#version 310 es", "#version 320 es", "#version 130",
49 "#version 140", "#version 150", "#version 330", "#version 400", "#version 410",
50 "#version 420", "#version 430", "#version 440", "#version 450", "#version 460",
51 };
52
53 return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_decl, version);
54 }
55
glslVersionUsesInOutQualifiers(GLSLVersion version)56 bool glslVersionUsesInOutQualifiers(GLSLVersion version)
57 {
58 return de::inRange<int>(version, GLSL_VERSION_300_ES, GLSL_VERSION_320_ES) ||
59 de::inRange<int>(version, GLSL_VERSION_330, GLSL_VERSION_460);
60 }
61
glslVersionIsES(GLSLVersion version)62 bool glslVersionIsES(GLSLVersion version)
63 {
64 DE_STATIC_ASSERT(GLSL_VERSION_LAST == 15);
65 DE_ASSERT(version != GLSL_VERSION_LAST);
66
67 if (version == GLSL_VERSION_100_ES || version == GLSL_VERSION_300_ES || version == GLSL_VERSION_310_ES ||
68 version == GLSL_VERSION_320_ES)
69 return true;
70 else
71 return false;
72 }
73
74 // \todo [2014-10-06 pyry] Export this.
getMinAPIForGLSLVersion(GLSLVersion version)75 static ApiType getMinAPIForGLSLVersion(GLSLVersion version)
76 {
77 static const ApiType s_minApi[] = {
78 ApiType::es(2, 0), ApiType::es(3, 0), ApiType::es(3, 1), ApiType::es(3, 2), ApiType::core(3, 0),
79 ApiType::core(3, 1), ApiType::core(3, 2), ApiType::core(3, 3), ApiType::core(4, 0), ApiType::core(4, 1),
80 ApiType::core(4, 2), ApiType::core(4, 3), ApiType::core(4, 4), ApiType::core(4, 5), ApiType::core(4, 6),
81 };
82
83 return de::getSizedArrayElement<GLSL_VERSION_LAST>(s_minApi, version);
84 }
85
isGLSLVersionSupported(ContextType type,GLSLVersion version)86 bool isGLSLVersionSupported(ContextType type, GLSLVersion version)
87 {
88 return contextSupports(type, getMinAPIForGLSLVersion(version));
89 }
90
getContextTypeGLSLVersion(ContextType type)91 GLSLVersion getContextTypeGLSLVersion(ContextType type)
92 {
93 // \note From newer to older
94 for (int version = GLSL_VERSION_LAST - 1; version >= 0; version--)
95 {
96 if (isGLSLVersionSupported(type, GLSLVersion(version)))
97 return GLSLVersion(version);
98 }
99
100 DE_ASSERT(false);
101 return GLSL_VERSION_LAST;
102 }
103
104 // ShaderType
105
getShaderTypeName(ShaderType shaderType)106 const char *getShaderTypeName(ShaderType shaderType)
107 {
108 static const char *s_names[] = {
109 "vertex", "fragment", "geometry", "tess_control", "tess_eval", "compute", "ray_gen",
110 "any_hit", "closest_hit", "miss", "intersection", "callable", "task", "mesh",
111 };
112
113 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == SHADERTYPE_LAST);
114 DE_ASSERT(deInBounds32((int)shaderType, 0, SHADERTYPE_LAST));
115 return s_names[(int)shaderType];
116 }
117
getShaderTypePostfix(ShaderType shaderType)118 std::string getShaderTypePostfix(ShaderType shaderType)
119 {
120 return "_" + std::string(getShaderTypeName(shaderType));
121 }
122
123 // Precision
124
getPrecisionName(Precision precision)125 const char *getPrecisionName(Precision precision)
126 {
127 static const char *s_names[] = {"lowp", "mediump", "highp"};
128
129 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == PRECISION_LAST);
130 DE_ASSERT(deInBounds32((int)precision, 0, PRECISION_LAST));
131 return s_names[(int)precision];
132 }
133
getPrecisionPostfix(Precision precision)134 std::string getPrecisionPostfix(Precision precision)
135 {
136 return "_" + std::string(getPrecisionName(precision));
137 }
138
139 // DataType
140
getDataTypeName(DataType dataType)141 const char *getDataTypeName(DataType dataType)
142 {
143 static const char *s_names[] = {
144 "invalid",
145 "float",
146 "vec2",
147 "vec3",
148 "vec4",
149 "mat2",
150 "mat2x3",
151 "mat2x4",
152 "mat3x2",
153 "mat3",
154 "mat3x4",
155 "mat4x2",
156 "mat4x3",
157 "mat4",
158 "double",
159 "dvec2",
160 "dvec3",
161 "dvec4",
162 "dmat2",
163 "dmat2x3",
164 "dmat2x4",
165 "dmat3x2",
166 "dmat3",
167 "dmat3x4",
168 "dmat4x2",
169 "dmat4x3",
170 "dmat4",
171 "int",
172 "ivec2",
173 "ivec3",
174 "ivec4",
175 "uint",
176 "uvec2",
177 "uvec3",
178 "uvec4",
179 "bool",
180 "bvec2",
181 "bvec3",
182 "bvec4",
183 "sampler1D",
184 "sampler2D",
185 "samplerCube",
186 "sampler1DArray",
187 "sampler2DArray",
188 "sampler3D",
189 "samplerCubeArray",
190 "sampler1DShadow",
191 "sampler2DShadow",
192 "samplerCubeShadow",
193 "sampler1DArrayShadow",
194 "sampler2DArrayShadow",
195 "samplerCubeArrayShadow",
196 "isampler1D",
197 "isampler2D",
198 "isamplerCube",
199 "isampler1DArray",
200 "isampler2DArray",
201 "isampler3D",
202 "isamplerCubeArray",
203 "usampler1D",
204 "usampler2D",
205 "usamplerCube",
206 "usampler1DArray",
207 "usampler2DArray",
208 "usampler3D",
209 "usamplerCubeArray",
210 "sampler2DMS",
211 "isampler2DMS",
212 "usampler2DMS",
213 "image2D",
214 "imageCube",
215 "image2DArray",
216 "image3D",
217 "imageCubeArray",
218 "iimage2D",
219 "iimageCube",
220 "iimage2DArray",
221 "iimage3D",
222 "iimageCubeArray",
223 "uimage2D",
224 "uimageCube",
225 "uimage2DArray",
226 "uimage3D",
227 "uimageCubeArray",
228 "atomic_uint",
229 "samplerBuffer",
230 "isamplerBuffer",
231 "usamplerBuffer",
232 "sampler2DMSArray",
233 "isampler2DMSArray",
234 "usampler2DMSArray",
235 "imageBuffer",
236 "iimageBuffer",
237 "uimageBuffer",
238 "uint8_t",
239 "u8vec2",
240 "u8vec3",
241 "u8vec4",
242 "int8_t",
243 "i8vec2",
244 "i8vec3",
245 "i8vec4",
246 "uint16_t",
247 "u16vec2",
248 "u16vec3",
249 "u16vec4",
250 "int16_t",
251 "i16vec2",
252 "i16vec3",
253 "i16vec4",
254 "float16_t",
255 "f16vec2",
256 "f16vec3",
257 "f16vec4",
258 "f16mat2",
259 "f16mat2x3",
260 "f16mat2x4",
261 "f16mat3x2",
262 "f16mat3",
263 "f16mat3x4",
264 "f16mat4x2",
265 "f16mat4x3",
266 "f16mat4",
267 };
268
269 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_names) == TYPE_LAST);
270 DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_names)));
271 return s_names[(int)dataType];
272 }
273
getDataTypeScalarSize(DataType dataType)274 int getDataTypeScalarSize(DataType dataType)
275 {
276 static const int s_sizes[] = {
277 -1, // invalid
278 1, // float
279 2, // vec2
280 3, // vec3
281 4, // vec4
282 4, // mat2
283 6, // mat2x3
284 8, // mat2x4
285 6, // mat3x2
286 9, // mat3
287 12, // mat3x4
288 8, // mat4x2
289 12, // mat4x3
290 16, // mat4
291 1, // double
292 2, // dvec2
293 3, // dvec3
294 4, // dvec4
295 4, // dmat2
296 6, // dmat2x3
297 8, // dmat2x4
298 6, // dmat3x2
299 9, // dmat3
300 12, // dmat3x4
301 8, // dmat4x2
302 12, // dmat4x3
303 16, // dmat4
304 1, // int
305 2, // ivec2
306 3, // ivec3
307 4, // ivec4
308 1, // uint
309 2, // uvec2
310 3, // uvec3
311 4, // uvec4
312 1, // bool
313 2, // bvec2
314 3, // bvec3
315 4, // bvec4
316 1, // sampler1D
317 1, // sampler2D
318 1, // samplerCube
319 1, // sampler1DArray
320 1, // sampler2DArray
321 1, // sampler3D
322 1, // samplerCubeArray
323 1, // sampler1DShadow
324 1, // sampler2DShadow
325 1, // samplerCubeShadow
326 1, // sampler1DArrayShadow
327 1, // sampler2DArrayShadow
328 1, // samplerCubeArrayShadow
329 1, // isampler1D
330 1, // isampler2D
331 1, // isamplerCube
332 1, // isampler1DArray
333 1, // isampler2DArray
334 1, // isampler3D
335 1, // isamplerCubeArray
336 1, // usampler1D
337 1, // usampler2D
338 1, // usamplerCube
339 1, // usampler1DArray
340 1, // usampler2DArray
341 1, // usampler3D
342 1, // usamplerCubeArray
343 1, // sampler2DMS
344 1, // isampler2DMS
345 1, // usampler2DMS
346 1, // image2D
347 1, // imageCube
348 1, // image2DArray
349 1, // image3D
350 1, // imageCubeArray
351 1, // iimage2D
352 1, // iimageCube
353 1, // iimage2DArray
354 1, // iimage3D
355 1, // iimageCubeArray
356 1, // uimage2D
357 1, // uimageCube
358 1, // uimage2DArray
359 1, // uimage3D
360 1, // uimageCubeArray
361 1, // atomic_uint
362 1, // samplerBuffer
363 1, // isamplerBuffer
364 1, // usamplerBuffer
365 1, // sampler2DMSArray
366 1, // isampler2DMSArray
367 1, // usampler2DMSArray
368 1, // imageBuffer
369 1, // iimageBuffer
370 1, // uimageBuffer
371 1, // uint8_t
372 2, // u8vec2
373 3, // u8vec3
374 4, // u8vec4
375 1, // int8_t
376 2, // i8vec2
377 3, // i8vec3
378 4, // i8vec4
379 1, // uint16_t
380 2, // u16vec2
381 3, // u16vec3
382 4, // u16vec4
383 1, // int16_t
384 2, // i16vec2
385 3, // i16vec3
386 4, // i16vec4
387 1, // float16_t
388 2, // f16vec2
389 3, // f16vec3
390 4, // f16vec4
391 4, // f16mat2
392 6, // f16mat2x3
393 8, // f16mat2x4
394 6, // f16mat3x2
395 9, // f16mat3
396 12, // f16mat3x4
397 8, // f16mat4x2
398 12, // f16mat4x3
399 16, // f16mat4
400 };
401
402 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_sizes) == TYPE_LAST);
403 DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_sizes)));
404 return s_sizes[(int)dataType];
405 }
406
getDataTypeScalarType(DataType dataType)407 DataType getDataTypeScalarType(DataType dataType)
408 {
409 static const DataType s_scalarTypes[] = {
410 TYPE_INVALID, // invalid
411 TYPE_FLOAT, // float
412 TYPE_FLOAT, // vec2
413 TYPE_FLOAT, // vec3
414 TYPE_FLOAT, // vec4
415 TYPE_FLOAT, // mat2
416 TYPE_FLOAT, // mat2x3
417 TYPE_FLOAT, // mat2x4
418 TYPE_FLOAT, // mat3x2
419 TYPE_FLOAT, // mat3
420 TYPE_FLOAT, // mat3x4
421 TYPE_FLOAT, // mat4x2
422 TYPE_FLOAT, // mat4x3
423 TYPE_FLOAT, // mat4
424 TYPE_DOUBLE, // double
425 TYPE_DOUBLE, // dvec2
426 TYPE_DOUBLE, // dvec3
427 TYPE_DOUBLE, // dvec4
428 TYPE_DOUBLE, // dmat2
429 TYPE_DOUBLE, // dmat2x3
430 TYPE_DOUBLE, // dmat2x4
431 TYPE_DOUBLE, // dmat3x2
432 TYPE_DOUBLE, // dmat3
433 TYPE_DOUBLE, // dmat3x4
434 TYPE_DOUBLE, // dmat4x2
435 TYPE_DOUBLE, // dmat4x3
436 TYPE_DOUBLE, // dmat4
437 TYPE_INT, // int
438 TYPE_INT, // ivec2
439 TYPE_INT, // ivec3
440 TYPE_INT, // ivec4
441 TYPE_UINT, // uint
442 TYPE_UINT, // uvec2
443 TYPE_UINT, // uvec3
444 TYPE_UINT, // uvec4
445 TYPE_BOOL, // bool
446 TYPE_BOOL, // bvec2
447 TYPE_BOOL, // bvec3
448 TYPE_BOOL, // bvec4
449 TYPE_SAMPLER_1D, // sampler1D
450 TYPE_SAMPLER_2D, // sampler2D
451 TYPE_SAMPLER_CUBE, // samplerCube
452 TYPE_SAMPLER_1D_ARRAY, // sampler1DArray
453 TYPE_SAMPLER_2D_ARRAY, // sampler2DArray
454 TYPE_SAMPLER_3D, // sampler3D
455 TYPE_SAMPLER_CUBE_ARRAY, // samplerCubeArray
456 TYPE_SAMPLER_1D_SHADOW, // sampler1DShadow
457 TYPE_SAMPLER_2D_SHADOW, // sampler2DShadow
458 TYPE_SAMPLER_CUBE_SHADOW, // samplerCubeShadow
459 TYPE_SAMPLER_1D_ARRAY_SHADOW, // sampler1DArrayShadow
460 TYPE_SAMPLER_2D_ARRAY_SHADOW, // sampler2DArrayShadow
461 TYPE_SAMPLER_CUBE_ARRAY_SHADOW, // samplerCubeArrayShadow
462 TYPE_INT_SAMPLER_1D, // isampler1D
463 TYPE_INT_SAMPLER_2D, // isampler2D
464 TYPE_INT_SAMPLER_CUBE, // isamplerCube
465 TYPE_INT_SAMPLER_1D_ARRAY, // isampler1DArray
466 TYPE_INT_SAMPLER_2D_ARRAY, // isampler2DArray
467 TYPE_INT_SAMPLER_3D, // isampler3D
468 TYPE_INT_SAMPLER_CUBE_ARRAY, // isamplerCubeArray
469 TYPE_UINT_SAMPLER_1D, // usampler1D
470 TYPE_UINT_SAMPLER_2D, // usampler2D
471 TYPE_UINT_SAMPLER_CUBE, // usamplerCube
472 TYPE_UINT_SAMPLER_1D_ARRAY, // usampler1DArray
473 TYPE_UINT_SAMPLER_2D_ARRAY, // usampler2DArray
474 TYPE_UINT_SAMPLER_3D, // usampler3D
475 TYPE_UINT_SAMPLER_CUBE_ARRAY, // usamplerCubeArray
476 TYPE_SAMPLER_2D_MULTISAMPLE, // sampler2DMS
477 TYPE_INT_SAMPLER_2D_MULTISAMPLE, // isampler2DMS
478 TYPE_UINT_SAMPLER_2D_MULTISAMPLE, // usampler2DMS
479 TYPE_IMAGE_2D, // image2D
480 TYPE_IMAGE_CUBE, // imageCube
481 TYPE_IMAGE_2D_ARRAY, // image2DArray
482 TYPE_IMAGE_3D, // image3D
483 TYPE_IMAGE_CUBE_ARRAY, // imageCubeArray
484 TYPE_INT_IMAGE_2D, // iimage2D
485 TYPE_INT_IMAGE_CUBE, // iimageCube
486 TYPE_INT_IMAGE_2D_ARRAY, // iimage2DArray
487 TYPE_INT_IMAGE_3D, // iimage3D
488 TYPE_INT_IMAGE_CUBE_ARRAY, // iimageCubeArray
489 TYPE_UINT_IMAGE_2D, // uimage2D
490 TYPE_UINT_IMAGE_CUBE, // uimageCube
491 TYPE_UINT_IMAGE_2D_ARRAY, // uimage2DArray
492 TYPE_UINT_IMAGE_3D, // uimage3D
493 TYPE_UINT_IMAGE_CUBE_ARRAY, // uimageCubeArray
494 TYPE_UINT_ATOMIC_COUNTER, // atomic_uint
495 TYPE_SAMPLER_BUFFER, // samplerBuffer
496 TYPE_INT_SAMPLER_BUFFER, // isamplerBuffer
497 TYPE_UINT_SAMPLER_BUFFER, // usamplerBuffer
498 TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY, // sampler2DMSArray
499 TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, // isampler2DMSArray
500 TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY, // usampler2DMSArray
501 TYPE_IMAGE_BUFFER, // imageBuffer
502 TYPE_INT_IMAGE_BUFFER, // iimageBuffer
503 TYPE_UINT_IMAGE_BUFFER, // uimageBuffer
504 TYPE_UINT8, // uint8_t
505 TYPE_UINT8, // u8vec2
506 TYPE_UINT8, // u8vec3
507 TYPE_UINT8, // u8vec4
508 TYPE_INT8, // int8_t
509 TYPE_INT8, // i8vec2
510 TYPE_INT8, // i8vec3
511 TYPE_INT8, // i8vec4
512 TYPE_UINT16, // uint16_t
513 TYPE_UINT16, // u16vec2
514 TYPE_UINT16, // u16vec3
515 TYPE_UINT16, // u16vec4
516 TYPE_INT16, // int16_t
517 TYPE_INT16, // i16vec2
518 TYPE_INT16, // i16vec3
519 TYPE_INT16, // i16vec4
520 TYPE_FLOAT16, // float16_t
521 TYPE_FLOAT16, // f16vec2
522 TYPE_FLOAT16, // f16vec3
523 TYPE_FLOAT16, // f16vec4
524 TYPE_FLOAT16, // f16mat2
525 TYPE_FLOAT16, // f16mat2x3
526 TYPE_FLOAT16, // f16mat2x4
527 TYPE_FLOAT16, // f16mat3x2
528 TYPE_FLOAT16, // f16mat3
529 TYPE_FLOAT16, // f16mat3x4
530 TYPE_FLOAT16, // f16mat4x2
531 TYPE_FLOAT16, // f16mat4x3
532 TYPE_FLOAT16, // f16mat4
533 };
534
535 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_scalarTypes) == TYPE_LAST);
536 DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_scalarTypes)));
537 return s_scalarTypes[(int)dataType];
538 }
539
getDataTypeFloat16Scalars(DataType dataType)540 DataType getDataTypeFloat16Scalars(DataType dataType)
541 {
542 static const DataType s_floatTypes[] = {
543 TYPE_INVALID, // invalid
544 TYPE_FLOAT16, // float
545 TYPE_FLOAT16_VEC2, // vec2
546 TYPE_FLOAT16_VEC3, // vec3
547 TYPE_FLOAT16_VEC4, // vec4
548 TYPE_FLOAT16_MAT2, // mat2
549 TYPE_FLOAT16_MAT2X3, // mat2x3
550 TYPE_FLOAT16_MAT2X4, // mat2x4
551 TYPE_FLOAT16_MAT3X2, // mat3x2
552 TYPE_FLOAT16_MAT3, // mat3
553 TYPE_FLOAT16_MAT3X4, // mat3x4
554 TYPE_FLOAT16_MAT4X2, // mat4x2
555 TYPE_FLOAT16_MAT4X3, // mat4x3
556 TYPE_FLOAT16_MAT4, // mat4
557 TYPE_FLOAT16, // double
558 TYPE_FLOAT16_VEC2, // dvec2
559 TYPE_FLOAT16_VEC3, // dvec3
560 TYPE_FLOAT16_VEC4, // dvec4
561 TYPE_FLOAT16_MAT2, // dmat2
562 TYPE_FLOAT16_MAT2X3, // dmat2x3
563 TYPE_FLOAT16_MAT2X4, // dmat2x4
564 TYPE_FLOAT16_MAT3X2, // dmat3x2
565 TYPE_FLOAT16_MAT3, // dmat3
566 TYPE_FLOAT16_MAT3X4, // dmat3x4
567 TYPE_FLOAT16_MAT4X2, // dmat4x2
568 TYPE_FLOAT16_MAT4X3, // dmat4x3
569 TYPE_FLOAT16_MAT4, // dmat4
570 TYPE_FLOAT16, // int
571 TYPE_FLOAT16_VEC2, // ivec2
572 TYPE_FLOAT16_VEC3, // ivec3
573 TYPE_FLOAT16_VEC4, // ivec4
574 TYPE_FLOAT16, // uint
575 TYPE_FLOAT16_VEC2, // uvec2
576 TYPE_FLOAT16_VEC3, // uvec3
577 TYPE_FLOAT16_VEC4, // uvec4
578 TYPE_FLOAT16, // bool
579 TYPE_FLOAT16_VEC2, // bvec2
580 TYPE_FLOAT16_VEC3, // bvec3
581 TYPE_FLOAT16_VEC4, // bvec4
582 TYPE_INVALID, // sampler1D
583 TYPE_INVALID, // sampler2D
584 TYPE_INVALID, // samplerCube
585 TYPE_INVALID, // sampler1DArray
586 TYPE_INVALID, // sampler2DArray
587 TYPE_INVALID, // sampler3D
588 TYPE_INVALID, // samplerCubeArray
589 TYPE_INVALID, // sampler1DShadow
590 TYPE_INVALID, // sampler2DShadow
591 TYPE_INVALID, // samplerCubeShadow
592 TYPE_INVALID, // sampler1DArrayShadow
593 TYPE_INVALID, // sampler2DArrayShadow
594 TYPE_INVALID, // samplerCubeArrayShadow
595 TYPE_INVALID, // isampler1D
596 TYPE_INVALID, // isampler2D
597 TYPE_INVALID, // isamplerCube
598 TYPE_INVALID, // isampler1DArray
599 TYPE_INVALID, // isampler2DArray
600 TYPE_INVALID, // isampler3D
601 TYPE_INVALID, // isamplerCubeArray
602 TYPE_INVALID, // usampler1D
603 TYPE_INVALID, // usampler2D
604 TYPE_INVALID, // usamplerCube
605 TYPE_INVALID, // usampler1DArray
606 TYPE_INVALID, // usampler2DArray
607 TYPE_INVALID, // usampler3D
608 TYPE_INVALID, // usamplerCubeArray
609 TYPE_INVALID, // sampler2DMS
610 TYPE_INVALID, // isampler2DMS
611 TYPE_INVALID, // usampler2DMS
612 TYPE_INVALID, // image2D
613 TYPE_INVALID, // imageCube
614 TYPE_INVALID, // image2DArray
615 TYPE_INVALID, // image3D
616 TYPE_INVALID, // imageCubeArray
617 TYPE_INVALID, // iimage2D
618 TYPE_INVALID, // iimageCube
619 TYPE_INVALID, // iimage2DArray
620 TYPE_INVALID, // iimage3D
621 TYPE_INVALID, // iimageCubeArray
622 TYPE_INVALID, // uimage2D
623 TYPE_INVALID, // uimageCube
624 TYPE_INVALID, // uimage2DArray
625 TYPE_INVALID, // uimage3D
626 TYPE_INVALID, // uimageCubeArray
627 TYPE_INVALID, // atomic_uint
628 TYPE_INVALID, // samplerBuffer
629 TYPE_INVALID, // isamplerBuffer
630 TYPE_INVALID, // usamplerBuffer
631 TYPE_INVALID, // sampler2DMSArray
632 TYPE_INVALID, // isampler2DMSArray
633 TYPE_INVALID, // usampler2DMSArray
634 TYPE_INVALID, // imageBuffer
635 TYPE_INVALID, // iimageBuffer
636 TYPE_INVALID, // uimageBuffer
637 TYPE_FLOAT16, // uint8_t
638 TYPE_FLOAT16_VEC2, // u8vec2
639 TYPE_FLOAT16_VEC3, // u8vec3
640 TYPE_FLOAT16_VEC4, // u8vec4
641 TYPE_FLOAT16, // int8_t
642 TYPE_FLOAT16_VEC2, // i8vec2
643 TYPE_FLOAT16_VEC3, // i8vec3
644 TYPE_FLOAT16_VEC4, // i8vec4
645 TYPE_FLOAT16, // uint16_t
646 TYPE_FLOAT16_VEC2, // u16vec2
647 TYPE_FLOAT16_VEC3, // u16vec3
648 TYPE_FLOAT16_VEC4, // u16vec4
649 TYPE_FLOAT16, // int16_t
650 TYPE_FLOAT16_VEC2, // i16vec2
651 TYPE_FLOAT16_VEC3, // i16vec3
652 TYPE_FLOAT16_VEC4, // i16vec4
653 TYPE_FLOAT16, // float16_t
654 TYPE_FLOAT16_VEC2, // f16vec2
655 TYPE_FLOAT16_VEC3, // f16vec3
656 TYPE_FLOAT16_VEC4, // f16vec4
657 TYPE_FLOAT16_MAT2, // f16mat2
658 TYPE_FLOAT16_MAT2X3, // f16mat2x3
659 TYPE_FLOAT16_MAT2X4, // f16mat2x4
660 TYPE_FLOAT16_MAT3X2, // f16mat3x2
661 TYPE_FLOAT16_MAT3, // f16mat3
662 TYPE_FLOAT16_MAT3X4, // f16mat3x4
663 TYPE_FLOAT16_MAT4X2, // f16mat4x2
664 TYPE_FLOAT16_MAT4X3, // f16mat4x3
665 TYPE_FLOAT16_MAT4, // f16mat4
666 };
667
668 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
669 DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
670 return s_floatTypes[(int)dataType];
671 }
672
getDataTypeFloatScalars(DataType dataType)673 DataType getDataTypeFloatScalars(DataType dataType)
674 {
675 static const DataType s_floatTypes[] = {
676 TYPE_INVALID, // invalid
677 TYPE_FLOAT, // float
678 TYPE_FLOAT_VEC2, // vec2
679 TYPE_FLOAT_VEC3, // vec3
680 TYPE_FLOAT_VEC4, // vec4
681 TYPE_FLOAT_MAT2, // mat2
682 TYPE_FLOAT_MAT2X3, // mat2x3
683 TYPE_FLOAT_MAT2X4, // mat2x4
684 TYPE_FLOAT_MAT3X2, // mat3x2
685 TYPE_FLOAT_MAT3, // mat3
686 TYPE_FLOAT_MAT3X4, // mat3x4
687 TYPE_FLOAT_MAT4X2, // mat4x2
688 TYPE_FLOAT_MAT4X3, // mat4x3
689 TYPE_FLOAT_MAT4, // mat4
690 TYPE_FLOAT, // double
691 TYPE_FLOAT_VEC2, // dvec2
692 TYPE_FLOAT_VEC3, // dvec3
693 TYPE_FLOAT_VEC4, // dvec4
694 TYPE_FLOAT_MAT2, // dmat2
695 TYPE_FLOAT_MAT2X3, // dmat2x3
696 TYPE_FLOAT_MAT2X4, // dmat2x4
697 TYPE_FLOAT_MAT3X2, // dmat3x2
698 TYPE_FLOAT_MAT3, // dmat3
699 TYPE_FLOAT_MAT3X4, // dmat3x4
700 TYPE_FLOAT_MAT4X2, // dmat4x2
701 TYPE_FLOAT_MAT4X3, // dmat4x3
702 TYPE_FLOAT_MAT4, // dmat4
703 TYPE_FLOAT, // int
704 TYPE_FLOAT_VEC2, // ivec2
705 TYPE_FLOAT_VEC3, // ivec3
706 TYPE_FLOAT_VEC4, // ivec4
707 TYPE_FLOAT, // uint
708 TYPE_FLOAT_VEC2, // uvec2
709 TYPE_FLOAT_VEC3, // uvec3
710 TYPE_FLOAT_VEC4, // uvec4
711 TYPE_FLOAT, // bool
712 TYPE_FLOAT_VEC2, // bvec2
713 TYPE_FLOAT_VEC3, // bvec3
714 TYPE_FLOAT_VEC4, // bvec4
715 TYPE_INVALID, // sampler1D
716 TYPE_INVALID, // sampler2D
717 TYPE_INVALID, // samplerCube
718 TYPE_INVALID, // sampler1DArray
719 TYPE_INVALID, // sampler2DArray
720 TYPE_INVALID, // sampler3D
721 TYPE_INVALID, // samplerCubeArray
722 TYPE_INVALID, // sampler1DShadow
723 TYPE_INVALID, // sampler2DShadow
724 TYPE_INVALID, // samplerCubeShadow
725 TYPE_INVALID, // sampler1DArrayShadow
726 TYPE_INVALID, // sampler2DArrayShadow
727 TYPE_INVALID, // samplerCubeArrayShadow
728 TYPE_INVALID, // isampler1D
729 TYPE_INVALID, // isampler2D
730 TYPE_INVALID, // isamplerCube
731 TYPE_INVALID, // isampler1DArray
732 TYPE_INVALID, // isampler2DArray
733 TYPE_INVALID, // isampler3D
734 TYPE_INVALID, // isamplerCubeArray
735 TYPE_INVALID, // usampler1D
736 TYPE_INVALID, // usampler2D
737 TYPE_INVALID, // usamplerCube
738 TYPE_INVALID, // usampler1DArray
739 TYPE_INVALID, // usampler2DArray
740 TYPE_INVALID, // usampler3D
741 TYPE_INVALID, // usamplerCubeArray
742 TYPE_INVALID, // sampler2DMS
743 TYPE_INVALID, // isampler2DMS
744 TYPE_INVALID, // usampler2DMS
745 TYPE_INVALID, // image2D
746 TYPE_INVALID, // imageCube
747 TYPE_INVALID, // image2DArray
748 TYPE_INVALID, // image3D
749 TYPE_INVALID, // imageCubeArray
750 TYPE_INVALID, // iimage2D
751 TYPE_INVALID, // iimageCube
752 TYPE_INVALID, // iimage2DArray
753 TYPE_INVALID, // iimage3D
754 TYPE_INVALID, // iimageCubeArray
755 TYPE_INVALID, // uimage2D
756 TYPE_INVALID, // uimageCube
757 TYPE_INVALID, // uimage2DArray
758 TYPE_INVALID, // uimage3D
759 TYPE_INVALID, // uimageCubeArray
760 TYPE_INVALID, // atomic_uint
761 TYPE_INVALID, // samplerBuffer
762 TYPE_INVALID, // isamplerBuffer
763 TYPE_INVALID, // usamplerBuffer
764 TYPE_INVALID, // sampler2DMSArray
765 TYPE_INVALID, // isampler2DMSArray
766 TYPE_INVALID, // usampler2DMSArray
767 TYPE_INVALID, // imageBuffer
768 TYPE_INVALID, // iimageBuffer
769 TYPE_INVALID, // uimageBuffer
770 TYPE_FLOAT, // uint8_t
771 TYPE_FLOAT_VEC2, // u8vec2
772 TYPE_FLOAT_VEC3, // u8vec3
773 TYPE_FLOAT_VEC4, // u8vec4
774 TYPE_FLOAT, // int8_t
775 TYPE_FLOAT_VEC2, // i8vec2
776 TYPE_FLOAT_VEC3, // i8vec3
777 TYPE_FLOAT_VEC4, // i8vec4
778 TYPE_FLOAT, // uint16_t
779 TYPE_FLOAT_VEC2, // u16vec2
780 TYPE_FLOAT_VEC3, // u16vec3
781 TYPE_FLOAT_VEC4, // u16vec4
782 TYPE_FLOAT, // int16_t
783 TYPE_FLOAT_VEC2, // i16vec2
784 TYPE_FLOAT_VEC3, // i16vec3
785 TYPE_FLOAT_VEC4, // i16vec4
786 TYPE_FLOAT, // float16_t
787 TYPE_FLOAT_VEC2, // f16vec2
788 TYPE_FLOAT_VEC3, // f16vec3
789 TYPE_FLOAT_VEC4, // f16vec4
790 TYPE_FLOAT_MAT2, // f16mat2
791 TYPE_FLOAT_MAT2X3, // f16mat2x3
792 TYPE_FLOAT_MAT2X4, // f16mat2x4
793 TYPE_FLOAT_MAT3X2, // f16mat3x2
794 TYPE_FLOAT_MAT3, // f16mat3
795 TYPE_FLOAT_MAT3X4, // f16mat3x4
796 TYPE_FLOAT_MAT4X2, // f16mat4x2
797 TYPE_FLOAT_MAT4X3, // f16mat4x3
798 TYPE_FLOAT_MAT4, // f16mat4
799 };
800
801 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_floatTypes) == TYPE_LAST);
802 DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_floatTypes)));
803 return s_floatTypes[(int)dataType];
804 }
805
getDataTypeDoubleScalars(DataType dataType)806 DataType getDataTypeDoubleScalars(DataType dataType)
807 {
808 static const DataType s_doubleTypes[] = {
809 TYPE_INVALID, // invalid
810 TYPE_DOUBLE, // float
811 TYPE_DOUBLE_VEC2, // vec2
812 TYPE_DOUBLE_VEC3, // vec3
813 TYPE_DOUBLE_VEC4, // vec4
814 TYPE_DOUBLE_MAT2, // mat2
815 TYPE_DOUBLE_MAT2X3, // mat2x3
816 TYPE_DOUBLE_MAT2X4, // mat2x4
817 TYPE_DOUBLE_MAT3X2, // mat3x2
818 TYPE_DOUBLE_MAT3, // mat3
819 TYPE_DOUBLE_MAT3X4, // mat3x4
820 TYPE_DOUBLE_MAT4X2, // mat4x2
821 TYPE_DOUBLE_MAT4X3, // mat4x3
822 TYPE_DOUBLE_MAT4, // mat4
823 TYPE_DOUBLE, // double
824 TYPE_DOUBLE_VEC2, // dvec2
825 TYPE_DOUBLE_VEC3, // dvec3
826 TYPE_DOUBLE_VEC4, // dvec4
827 TYPE_DOUBLE_MAT2, // dmat2
828 TYPE_DOUBLE_MAT2X3, // dmat2x3
829 TYPE_DOUBLE_MAT2X4, // dmat2x4
830 TYPE_DOUBLE_MAT3X2, // dmat3x2
831 TYPE_DOUBLE_MAT3, // dmat3
832 TYPE_DOUBLE_MAT3X4, // dmat3x4
833 TYPE_DOUBLE_MAT4X2, // dmat4x2
834 TYPE_DOUBLE_MAT4X3, // dmat4x3
835 TYPE_DOUBLE_MAT4, // dmat4
836 TYPE_DOUBLE, // int
837 TYPE_DOUBLE_VEC2, // ivec2
838 TYPE_DOUBLE_VEC3, // ivec3
839 TYPE_DOUBLE_VEC4, // ivec4
840 TYPE_DOUBLE, // uint
841 TYPE_DOUBLE_VEC2, // uvec2
842 TYPE_DOUBLE_VEC3, // uvec3
843 TYPE_DOUBLE_VEC4, // uvec4
844 TYPE_DOUBLE, // bool
845 TYPE_DOUBLE_VEC2, // bvec2
846 TYPE_DOUBLE_VEC3, // bvec3
847 TYPE_DOUBLE_VEC4, // bvec4
848 TYPE_INVALID, // sampler1D
849 TYPE_INVALID, // sampler2D
850 TYPE_INVALID, // samplerCube
851 TYPE_INVALID, // sampler1DArray
852 TYPE_INVALID, // sampler2DArray
853 TYPE_INVALID, // sampler3D
854 TYPE_INVALID, // samplerCubeArray
855 TYPE_INVALID, // sampler1DShadow
856 TYPE_INVALID, // sampler2DShadow
857 TYPE_INVALID, // samplerCubeShadow
858 TYPE_INVALID, // sampler1DArrayShadow
859 TYPE_INVALID, // sampler2DArrayShadow
860 TYPE_INVALID, // samplerCubeArrayShadow
861 TYPE_INVALID, // isampler1D
862 TYPE_INVALID, // isampler2D
863 TYPE_INVALID, // isamplerCube
864 TYPE_INVALID, // isampler1DArray
865 TYPE_INVALID, // isampler2DArray
866 TYPE_INVALID, // isampler3D
867 TYPE_INVALID, // isamplerCubeArray
868 TYPE_INVALID, // usampler1D
869 TYPE_INVALID, // usampler2D
870 TYPE_INVALID, // usamplerCube
871 TYPE_INVALID, // usampler1DArray
872 TYPE_INVALID, // usampler2DArray
873 TYPE_INVALID, // usampler3D
874 TYPE_INVALID, // usamplerCubeArray
875 TYPE_INVALID, // sampler2DMS
876 TYPE_INVALID, // isampler2DMS
877 TYPE_INVALID, // usampler2DMS
878 TYPE_INVALID, // image2D
879 TYPE_INVALID, // imageCube
880 TYPE_INVALID, // image2DArray
881 TYPE_INVALID, // image3D
882 TYPE_INVALID, // imageCubeArray
883 TYPE_INVALID, // iimage2D
884 TYPE_INVALID, // iimageCube
885 TYPE_INVALID, // iimage2DArray
886 TYPE_INVALID, // iimage3D
887 TYPE_INVALID, // iimageCubeArray
888 TYPE_INVALID, // uimage2D
889 TYPE_INVALID, // uimageCube
890 TYPE_INVALID, // uimage2DArray
891 TYPE_INVALID, // uimage3D
892 TYPE_INVALID, // uimageCubeArray
893 TYPE_INVALID, // atomic_uint
894 TYPE_INVALID, // samplerBuffer
895 TYPE_INVALID, // isamplerBuffer
896 TYPE_INVALID, // usamplerBuffer
897 TYPE_INVALID, // sampler2DMSArray
898 TYPE_INVALID, // isampler2DMSArray
899 TYPE_INVALID, // usampler2DMSArray
900 TYPE_INVALID, // imageBuffer
901 TYPE_INVALID, // iimageBuffer
902 TYPE_INVALID, // uimageBuffer
903 TYPE_DOUBLE, // uint18_t
904 TYPE_DOUBLE_VEC2, // u8vec2
905 TYPE_DOUBLE_VEC3, // u8vec3
906 TYPE_DOUBLE_VEC4, // u8vec4
907 TYPE_DOUBLE, // int8_t
908 TYPE_DOUBLE_VEC2, // i8vec2
909 TYPE_DOUBLE_VEC3, // i8vec3
910 TYPE_DOUBLE_VEC4, // i8vec4
911 TYPE_DOUBLE, // uint16_t
912 TYPE_DOUBLE_VEC2, // u16vec2
913 TYPE_DOUBLE_VEC3, // u16vec3
914 TYPE_DOUBLE_VEC4, // u16vec4
915 TYPE_DOUBLE, // int16_t
916 TYPE_DOUBLE_VEC2, // i16vec2
917 TYPE_DOUBLE_VEC3, // i16vec3
918 TYPE_DOUBLE_VEC4, // i16vec4
919 TYPE_DOUBLE, // float16_t
920 TYPE_DOUBLE_VEC2, // f16vec2
921 TYPE_DOUBLE_VEC3, // f16vec3
922 TYPE_DOUBLE_VEC4, // f16vec4
923 TYPE_DOUBLE_MAT2, // f16mat2
924 TYPE_DOUBLE_MAT2X3, // f16mat2x3
925 TYPE_DOUBLE_MAT2X4, // f16mat2x4
926 TYPE_DOUBLE_MAT3X2, // f16mat3x2
927 TYPE_DOUBLE_MAT3, // f16mat3
928 TYPE_DOUBLE_MAT3X4, // f16mat3x4
929 TYPE_DOUBLE_MAT4X2, // f16mat4x2
930 TYPE_DOUBLE_MAT4X3, // f16mat4x3
931 TYPE_DOUBLE_MAT4, // f16mat4
932 };
933
934 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(s_doubleTypes) == TYPE_LAST);
935 DE_ASSERT(deInBounds32((int)dataType, 0, DE_LENGTH_OF_ARRAY(s_doubleTypes)));
936 return s_doubleTypes[(int)dataType];
937 }
938
getDataTypeVector(DataType scalarType,int size)939 DataType getDataTypeVector(DataType scalarType, int size)
940 {
941 DE_ASSERT(deInRange32(size, 1, 4));
942 switch (scalarType)
943 {
944 case TYPE_FLOAT:
945 case TYPE_DOUBLE:
946 case TYPE_INT:
947 case TYPE_UINT:
948 case TYPE_BOOL:
949 case TYPE_UINT8:
950 case TYPE_INT8:
951 case TYPE_UINT16:
952 case TYPE_INT16:
953 case TYPE_FLOAT16:
954 return (DataType)((int)scalarType + size - 1);
955 default:
956 return TYPE_INVALID;
957 }
958 }
959
getDataTypeFloatVec(int vecSize)960 DataType getDataTypeFloatVec(int vecSize)
961 {
962 return getDataTypeVector(TYPE_FLOAT, vecSize);
963 }
964
getDataTypeIntVec(int vecSize)965 DataType getDataTypeIntVec(int vecSize)
966 {
967 return getDataTypeVector(TYPE_INT, vecSize);
968 }
969
getDataTypeUintVec(int vecSize)970 DataType getDataTypeUintVec(int vecSize)
971 {
972 return getDataTypeVector(TYPE_UINT, vecSize);
973 }
974
getDataTypeBoolVec(int vecSize)975 DataType getDataTypeBoolVec(int vecSize)
976 {
977 return getDataTypeVector(TYPE_BOOL, vecSize);
978 }
979
getDataTypeMatrix(int numCols,int numRows)980 DataType getDataTypeMatrix(int numCols, int numRows)
981 {
982 DE_ASSERT(de::inRange(numCols, 2, 4) && de::inRange(numRows, 2, 4));
983 return (DataType)((int)TYPE_FLOAT_MAT2 + (numCols - 2) * 3 + (numRows - 2));
984 }
985
getDataTypeMatrixNumRows(DataType dataType)986 int getDataTypeMatrixNumRows(DataType dataType)
987 {
988 switch (dataType)
989 {
990 case TYPE_FLOAT_MAT2:
991 return 2;
992 case TYPE_FLOAT_MAT2X3:
993 return 3;
994 case TYPE_FLOAT_MAT2X4:
995 return 4;
996 case TYPE_FLOAT_MAT3X2:
997 return 2;
998 case TYPE_FLOAT_MAT3:
999 return 3;
1000 case TYPE_FLOAT_MAT3X4:
1001 return 4;
1002 case TYPE_FLOAT_MAT4X2:
1003 return 2;
1004 case TYPE_FLOAT_MAT4X3:
1005 return 3;
1006 case TYPE_FLOAT_MAT4:
1007 return 4;
1008 case TYPE_DOUBLE_MAT2:
1009 return 2;
1010 case TYPE_DOUBLE_MAT2X3:
1011 return 3;
1012 case TYPE_DOUBLE_MAT2X4:
1013 return 4;
1014 case TYPE_DOUBLE_MAT3X2:
1015 return 2;
1016 case TYPE_DOUBLE_MAT3:
1017 return 3;
1018 case TYPE_DOUBLE_MAT3X4:
1019 return 4;
1020 case TYPE_DOUBLE_MAT4X2:
1021 return 2;
1022 case TYPE_DOUBLE_MAT4X3:
1023 return 3;
1024 case TYPE_DOUBLE_MAT4:
1025 return 4;
1026 case TYPE_FLOAT16_MAT2:
1027 return 2;
1028 case TYPE_FLOAT16_MAT2X3:
1029 return 3;
1030 case TYPE_FLOAT16_MAT2X4:
1031 return 4;
1032 case TYPE_FLOAT16_MAT3X2:
1033 return 2;
1034 case TYPE_FLOAT16_MAT3:
1035 return 3;
1036 case TYPE_FLOAT16_MAT3X4:
1037 return 4;
1038 case TYPE_FLOAT16_MAT4X2:
1039 return 2;
1040 case TYPE_FLOAT16_MAT4X3:
1041 return 3;
1042 case TYPE_FLOAT16_MAT4:
1043 return 4;
1044 default:
1045 DE_ASSERT(false);
1046 return 0;
1047 }
1048 }
1049
getDataTypeMatrixNumColumns(DataType dataType)1050 int getDataTypeMatrixNumColumns(DataType dataType)
1051 {
1052 switch (dataType)
1053 {
1054 case TYPE_FLOAT_MAT2:
1055 return 2;
1056 case TYPE_FLOAT_MAT2X3:
1057 return 2;
1058 case TYPE_FLOAT_MAT2X4:
1059 return 2;
1060 case TYPE_FLOAT_MAT3X2:
1061 return 3;
1062 case TYPE_FLOAT_MAT3:
1063 return 3;
1064 case TYPE_FLOAT_MAT3X4:
1065 return 3;
1066 case TYPE_FLOAT_MAT4X2:
1067 return 4;
1068 case TYPE_FLOAT_MAT4X3:
1069 return 4;
1070 case TYPE_FLOAT_MAT4:
1071 return 4;
1072 case TYPE_DOUBLE_MAT2:
1073 return 2;
1074 case TYPE_DOUBLE_MAT2X3:
1075 return 2;
1076 case TYPE_DOUBLE_MAT2X4:
1077 return 2;
1078 case TYPE_DOUBLE_MAT3X2:
1079 return 3;
1080 case TYPE_DOUBLE_MAT3:
1081 return 3;
1082 case TYPE_DOUBLE_MAT3X4:
1083 return 3;
1084 case TYPE_DOUBLE_MAT4X2:
1085 return 4;
1086 case TYPE_DOUBLE_MAT4X3:
1087 return 4;
1088 case TYPE_DOUBLE_MAT4:
1089 return 4;
1090 case TYPE_FLOAT16_MAT2:
1091 return 2;
1092 case TYPE_FLOAT16_MAT2X3:
1093 return 2;
1094 case TYPE_FLOAT16_MAT2X4:
1095 return 2;
1096 case TYPE_FLOAT16_MAT3X2:
1097 return 3;
1098 case TYPE_FLOAT16_MAT3:
1099 return 3;
1100 case TYPE_FLOAT16_MAT3X4:
1101 return 3;
1102 case TYPE_FLOAT16_MAT4X2:
1103 return 4;
1104 case TYPE_FLOAT16_MAT4X3:
1105 return 4;
1106 case TYPE_FLOAT16_MAT4:
1107 return 4;
1108 default:
1109 DE_ASSERT(false);
1110 return 0;
1111 }
1112 }
1113
getDataTypeMatrixColumnType(DataType dataType)1114 DataType getDataTypeMatrixColumnType(DataType dataType)
1115 {
1116 switch (dataType)
1117 {
1118 case TYPE_FLOAT_MAT2:
1119 return TYPE_FLOAT_VEC2;
1120 case TYPE_FLOAT_MAT2X3:
1121 return TYPE_FLOAT_VEC3;
1122 case TYPE_FLOAT_MAT2X4:
1123 return TYPE_FLOAT_VEC4;
1124 case TYPE_FLOAT_MAT3X2:
1125 return TYPE_FLOAT_VEC2;
1126 case TYPE_FLOAT_MAT3:
1127 return TYPE_FLOAT_VEC3;
1128 case TYPE_FLOAT_MAT3X4:
1129 return TYPE_FLOAT_VEC4;
1130 case TYPE_FLOAT_MAT4X2:
1131 return TYPE_FLOAT_VEC2;
1132 case TYPE_FLOAT_MAT4X3:
1133 return TYPE_FLOAT_VEC3;
1134 case TYPE_FLOAT_MAT4:
1135 return TYPE_FLOAT_VEC4;
1136 case TYPE_DOUBLE_MAT2:
1137 return TYPE_DOUBLE_VEC2;
1138 case TYPE_DOUBLE_MAT2X3:
1139 return TYPE_DOUBLE_VEC3;
1140 case TYPE_DOUBLE_MAT2X4:
1141 return TYPE_DOUBLE_VEC4;
1142 case TYPE_DOUBLE_MAT3X2:
1143 return TYPE_DOUBLE_VEC2;
1144 case TYPE_DOUBLE_MAT3:
1145 return TYPE_DOUBLE_VEC3;
1146 case TYPE_DOUBLE_MAT3X4:
1147 return TYPE_DOUBLE_VEC4;
1148 case TYPE_DOUBLE_MAT4X2:
1149 return TYPE_DOUBLE_VEC2;
1150 case TYPE_DOUBLE_MAT4X3:
1151 return TYPE_DOUBLE_VEC3;
1152 case TYPE_DOUBLE_MAT4:
1153 return TYPE_DOUBLE_VEC4;
1154 case TYPE_FLOAT16_MAT2:
1155 return TYPE_FLOAT16_VEC2;
1156 case TYPE_FLOAT16_MAT2X3:
1157 return TYPE_FLOAT16_VEC3;
1158 case TYPE_FLOAT16_MAT2X4:
1159 return TYPE_FLOAT16_VEC4;
1160 case TYPE_FLOAT16_MAT3X2:
1161 return TYPE_FLOAT16_VEC2;
1162 case TYPE_FLOAT16_MAT3:
1163 return TYPE_FLOAT16_VEC3;
1164 case TYPE_FLOAT16_MAT3X4:
1165 return TYPE_FLOAT16_VEC4;
1166 case TYPE_FLOAT16_MAT4X2:
1167 return TYPE_FLOAT16_VEC2;
1168 case TYPE_FLOAT16_MAT4X3:
1169 return TYPE_FLOAT16_VEC3;
1170 case TYPE_FLOAT16_MAT4:
1171 return TYPE_FLOAT16_VEC4;
1172 default:
1173 DE_ASSERT(false);
1174 return TYPE_INVALID;
1175 }
1176 }
1177
getDataTypeNumLocations(DataType dataType)1178 int getDataTypeNumLocations(DataType dataType)
1179 {
1180 if (isDataTypeScalarOrVector(dataType))
1181 return 1;
1182 else if (isDataTypeMatrix(dataType))
1183 return getDataTypeMatrixNumColumns(dataType);
1184
1185 DE_FATAL("Illegal datatype.");
1186 return 0;
1187 }
1188
getDataTypeNumComponents(DataType dataType)1189 int getDataTypeNumComponents(DataType dataType)
1190 {
1191 if (isDataTypeScalarOrVector(dataType))
1192 return getDataTypeScalarSize(dataType);
1193 else if (isDataTypeMatrix(dataType))
1194 return getDataTypeMatrixNumRows(dataType);
1195
1196 DE_FATAL("Illegal datatype.");
1197 return 0;
1198 }
1199
getDataTypeFromGLType(uint32_t glType)1200 DataType getDataTypeFromGLType(uint32_t glType)
1201 {
1202 switch (glType)
1203 {
1204 case GL_FLOAT:
1205 return TYPE_FLOAT;
1206 case GL_FLOAT_VEC2:
1207 return TYPE_FLOAT_VEC2;
1208 case GL_FLOAT_VEC3:
1209 return TYPE_FLOAT_VEC3;
1210 case GL_FLOAT_VEC4:
1211 return TYPE_FLOAT_VEC4;
1212
1213 case GL_FLOAT_MAT2:
1214 return TYPE_FLOAT_MAT2;
1215 case GL_FLOAT_MAT2x3:
1216 return TYPE_FLOAT_MAT2X3;
1217 case GL_FLOAT_MAT2x4:
1218 return TYPE_FLOAT_MAT2X4;
1219
1220 case GL_FLOAT_MAT3x2:
1221 return TYPE_FLOAT_MAT3X2;
1222 case GL_FLOAT_MAT3:
1223 return TYPE_FLOAT_MAT3;
1224 case GL_FLOAT_MAT3x4:
1225 return TYPE_FLOAT_MAT3X4;
1226
1227 case GL_FLOAT_MAT4x2:
1228 return TYPE_FLOAT_MAT4X2;
1229 case GL_FLOAT_MAT4x3:
1230 return TYPE_FLOAT_MAT4X3;
1231 case GL_FLOAT_MAT4:
1232 return TYPE_FLOAT_MAT4;
1233
1234 case GL_DOUBLE:
1235 return TYPE_DOUBLE;
1236 case GL_DOUBLE_VEC2:
1237 return TYPE_DOUBLE_VEC2;
1238 case GL_DOUBLE_VEC3:
1239 return TYPE_DOUBLE_VEC3;
1240 case GL_DOUBLE_VEC4:
1241 return TYPE_DOUBLE_VEC4;
1242
1243 case GL_DOUBLE_MAT2:
1244 return TYPE_DOUBLE_MAT2;
1245 case GL_DOUBLE_MAT2x3:
1246 return TYPE_DOUBLE_MAT2X3;
1247 case GL_DOUBLE_MAT2x4:
1248 return TYPE_DOUBLE_MAT2X4;
1249
1250 case GL_DOUBLE_MAT3x2:
1251 return TYPE_DOUBLE_MAT3X2;
1252 case GL_DOUBLE_MAT3:
1253 return TYPE_DOUBLE_MAT3;
1254 case GL_DOUBLE_MAT3x4:
1255 return TYPE_DOUBLE_MAT3X4;
1256
1257 case GL_DOUBLE_MAT4x2:
1258 return TYPE_DOUBLE_MAT4X2;
1259 case GL_DOUBLE_MAT4x3:
1260 return TYPE_DOUBLE_MAT4X3;
1261 case GL_DOUBLE_MAT4:
1262 return TYPE_DOUBLE_MAT4;
1263
1264 case GL_INT:
1265 return TYPE_INT;
1266 case GL_INT_VEC2:
1267 return TYPE_INT_VEC2;
1268 case GL_INT_VEC3:
1269 return TYPE_INT_VEC3;
1270 case GL_INT_VEC4:
1271 return TYPE_INT_VEC4;
1272
1273 case GL_UNSIGNED_INT:
1274 return TYPE_UINT;
1275 case GL_UNSIGNED_INT_VEC2:
1276 return TYPE_UINT_VEC2;
1277 case GL_UNSIGNED_INT_VEC3:
1278 return TYPE_UINT_VEC3;
1279 case GL_UNSIGNED_INT_VEC4:
1280 return TYPE_UINT_VEC4;
1281
1282 case GL_BOOL:
1283 return TYPE_BOOL;
1284 case GL_BOOL_VEC2:
1285 return TYPE_BOOL_VEC2;
1286 case GL_BOOL_VEC3:
1287 return TYPE_BOOL_VEC3;
1288 case GL_BOOL_VEC4:
1289 return TYPE_BOOL_VEC4;
1290
1291 case GL_SAMPLER_1D:
1292 return TYPE_SAMPLER_1D;
1293 case GL_SAMPLER_2D:
1294 return TYPE_SAMPLER_2D;
1295 case GL_SAMPLER_CUBE:
1296 return TYPE_SAMPLER_CUBE;
1297 case GL_SAMPLER_1D_ARRAY:
1298 return TYPE_SAMPLER_1D_ARRAY;
1299 case GL_SAMPLER_2D_ARRAY:
1300 return TYPE_SAMPLER_2D_ARRAY;
1301 case GL_SAMPLER_3D:
1302 return TYPE_SAMPLER_3D;
1303 case GL_SAMPLER_CUBE_MAP_ARRAY:
1304 return TYPE_SAMPLER_CUBE_ARRAY;
1305
1306 case GL_SAMPLER_1D_SHADOW:
1307 return TYPE_SAMPLER_1D_SHADOW;
1308 case GL_SAMPLER_2D_SHADOW:
1309 return TYPE_SAMPLER_2D_SHADOW;
1310 case GL_SAMPLER_CUBE_SHADOW:
1311 return TYPE_SAMPLER_CUBE_SHADOW;
1312 case GL_SAMPLER_1D_ARRAY_SHADOW:
1313 return TYPE_SAMPLER_1D_ARRAY_SHADOW;
1314 case GL_SAMPLER_2D_ARRAY_SHADOW:
1315 return TYPE_SAMPLER_2D_ARRAY_SHADOW;
1316 case GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW:
1317 return TYPE_SAMPLER_CUBE_ARRAY_SHADOW;
1318
1319 case GL_INT_SAMPLER_1D:
1320 return TYPE_INT_SAMPLER_1D;
1321 case GL_INT_SAMPLER_2D:
1322 return TYPE_INT_SAMPLER_2D;
1323 case GL_INT_SAMPLER_CUBE:
1324 return TYPE_INT_SAMPLER_CUBE;
1325 case GL_INT_SAMPLER_1D_ARRAY:
1326 return TYPE_INT_SAMPLER_1D_ARRAY;
1327 case GL_INT_SAMPLER_2D_ARRAY:
1328 return TYPE_INT_SAMPLER_2D_ARRAY;
1329 case GL_INT_SAMPLER_3D:
1330 return TYPE_INT_SAMPLER_3D;
1331 case GL_INT_SAMPLER_CUBE_MAP_ARRAY:
1332 return TYPE_INT_SAMPLER_CUBE_ARRAY;
1333
1334 case GL_UNSIGNED_INT_SAMPLER_1D:
1335 return TYPE_UINT_SAMPLER_1D;
1336 case GL_UNSIGNED_INT_SAMPLER_2D:
1337 return TYPE_UINT_SAMPLER_2D;
1338 case GL_UNSIGNED_INT_SAMPLER_CUBE:
1339 return TYPE_UINT_SAMPLER_CUBE;
1340 case GL_UNSIGNED_INT_SAMPLER_1D_ARRAY:
1341 return TYPE_UINT_SAMPLER_1D_ARRAY;
1342 case GL_UNSIGNED_INT_SAMPLER_2D_ARRAY:
1343 return TYPE_UINT_SAMPLER_2D_ARRAY;
1344 case GL_UNSIGNED_INT_SAMPLER_3D:
1345 return TYPE_UINT_SAMPLER_3D;
1346 case GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY:
1347 return TYPE_UINT_SAMPLER_CUBE_ARRAY;
1348
1349 case GL_SAMPLER_2D_MULTISAMPLE:
1350 return TYPE_SAMPLER_2D_MULTISAMPLE;
1351 case GL_INT_SAMPLER_2D_MULTISAMPLE:
1352 return TYPE_INT_SAMPLER_2D_MULTISAMPLE;
1353 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE:
1354 return TYPE_UINT_SAMPLER_2D_MULTISAMPLE;
1355
1356 case GL_IMAGE_2D:
1357 return TYPE_IMAGE_2D;
1358 case GL_IMAGE_CUBE:
1359 return TYPE_IMAGE_CUBE;
1360 case GL_IMAGE_2D_ARRAY:
1361 return TYPE_IMAGE_2D_ARRAY;
1362 case GL_IMAGE_3D:
1363 return TYPE_IMAGE_3D;
1364 case GL_INT_IMAGE_2D:
1365 return TYPE_INT_IMAGE_2D;
1366 case GL_INT_IMAGE_CUBE:
1367 return TYPE_INT_IMAGE_CUBE;
1368 case GL_INT_IMAGE_2D_ARRAY:
1369 return TYPE_INT_IMAGE_2D_ARRAY;
1370 case GL_INT_IMAGE_3D:
1371 return TYPE_INT_IMAGE_3D;
1372 case GL_UNSIGNED_INT_IMAGE_2D:
1373 return TYPE_UINT_IMAGE_2D;
1374 case GL_UNSIGNED_INT_IMAGE_CUBE:
1375 return TYPE_UINT_IMAGE_CUBE;
1376 case GL_UNSIGNED_INT_IMAGE_2D_ARRAY:
1377 return TYPE_UINT_IMAGE_2D_ARRAY;
1378 case GL_UNSIGNED_INT_IMAGE_3D:
1379 return TYPE_UINT_IMAGE_3D;
1380
1381 case GL_UNSIGNED_INT_ATOMIC_COUNTER:
1382 return TYPE_UINT_ATOMIC_COUNTER;
1383
1384 case GL_SAMPLER_BUFFER:
1385 return TYPE_SAMPLER_BUFFER;
1386 case GL_INT_SAMPLER_BUFFER:
1387 return TYPE_INT_SAMPLER_BUFFER;
1388 case GL_UNSIGNED_INT_SAMPLER_BUFFER:
1389 return TYPE_UINT_SAMPLER_BUFFER;
1390
1391 case GL_SAMPLER_2D_MULTISAMPLE_ARRAY:
1392 return TYPE_SAMPLER_2D_MULTISAMPLE_ARRAY;
1393 case GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
1394 return TYPE_INT_SAMPLER_2D_MULTISAMPLE_ARRAY;
1395 case GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY:
1396 return TYPE_UINT_SAMPLER_2D_MULTISAMPLE_ARRAY;
1397
1398 case GL_IMAGE_BUFFER:
1399 return TYPE_IMAGE_BUFFER;
1400 case GL_INT_IMAGE_BUFFER:
1401 return TYPE_INT_IMAGE_BUFFER;
1402 case GL_UNSIGNED_INT_IMAGE_BUFFER:
1403 return TYPE_UINT_IMAGE_BUFFER;
1404
1405 default:
1406 return TYPE_LAST;
1407 }
1408 }
1409
1410 // Miscellaneous
saveShader(const std::string & name,const std::string & code)1411 bool saveShader(const std::string &name, const std::string &code)
1412 {
1413 bool equals = false;
1414 std::ifstream existingShaderFile(name + ".glsl");
1415 if (existingShaderFile.is_open())
1416 {
1417 std::string existingCode;
1418 existingShaderFile >> existingCode;
1419 equals = code == existingCode;
1420 existingShaderFile.close();
1421 }
1422 if (false == equals)
1423 {
1424 std::ofstream newShaderFile(name + ".x");
1425 if (newShaderFile.is_open())
1426 {
1427 newShaderFile << code;
1428 newShaderFile.close();
1429 equals = true;
1430 }
1431 }
1432 return equals;
1433 }
1434
1435 } // namespace glu
1436