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