1 //
2 // Copyright 2002 The ANGLE Project Authors. All rights reserved.
3 // Use of this source code is governed by a BSD-style license that can be
4 // found in the LICENSE file.
5 //
6
7 #ifndef COMPILER_TRANSLATOR_BASETYPES_H_
8 #define COMPILER_TRANSLATOR_BASETYPES_H_
9
10 #include <algorithm>
11 #include <array>
12
13 #include "GLSLANG/ShaderLang.h"
14 #include "common/debug.h"
15 #include "compiler/translator/ImmutableString.h"
16
17 namespace sh
18 {
19
20 //
21 // Precision qualifiers
22 //
23 enum TPrecision
24 {
25 // These need to be kept sorted
26 EbpUndefined,
27 EbpLow,
28 EbpMedium,
29 EbpHigh,
30
31 // end of list
32 EbpLast
33 };
34
getPrecisionString(TPrecision p)35 inline const char *getPrecisionString(TPrecision p)
36 {
37 switch (p)
38 {
39 case EbpHigh:
40 return "highp";
41 case EbpMedium:
42 return "mediump";
43 case EbpLow:
44 return "lowp";
45 default:
46 return "mediump"; // Safest fallback
47 }
48 }
49
50 //
51 // Basic type. Arrays, vectors, etc., are orthogonal to this.
52 //
53 enum TBasicType
54 {
55 EbtVoid,
56 EbtFloat,
57 EbtDouble,
58 EbtInt,
59 EbtUInt,
60 EbtBool,
61
62 EbtAtomicCounter,
63 EbtYuvCscStandardEXT, // Only valid if EXT_YUV_target exists.
64
65 EbtGuardSamplerBegin, // non type: see implementation of IsSampler()
66 EbtSampler2D = EbtGuardSamplerBegin,
67 EbtSampler3D,
68 EbtSamplerCube,
69 EbtSampler2DArray,
70 EbtSamplerExternalOES, // Only valid if OES_EGL_image_external exists.
71 EbtSamplerExternal2DY2YEXT, // Only valid if GL_EXT_YUV_target exists.
72 EbtSampler2DRect, // Only valid if GL_ARB_texture_rectangle exists.
73 EbtSampler2DMS,
74 EbtSampler2DMSArray,
75 EbtISampler2D,
76 EbtISampler3D,
77 EbtISamplerCube,
78 EbtISampler2DArray,
79 EbtISampler2DMS,
80 EbtISampler2DMSArray,
81 EbtUSampler2D,
82 EbtUSampler3D,
83 EbtUSamplerCube,
84 EbtUSampler2DArray,
85 EbtUSampler2DMS,
86 EbtUSampler2DMSArray,
87 EbtSampler2DShadow,
88 EbtSamplerCubeShadow,
89 EbtSampler2DArrayShadow,
90 EbtSampler1D, // Desktop GLSL sampler types
91 EbtSampler1DArray,
92 EbtSampler1DArrayShadow,
93 EbtSamplerBuffer,
94 EbtSamplerCubeArray,
95 EbtSamplerCubeArrayShadow,
96 EbtSampler1DShadow,
97 EbtSampler2DRectShadow,
98 EbtISampler1D,
99 EbtISampler1DArray,
100 EbtISampler2DRect,
101 EbtISamplerBuffer,
102 EbtISamplerCubeArray,
103 EbtUSampler1D,
104 EbtUSampler1DArray,
105 EbtUSampler2DRect,
106 EbtUSamplerBuffer,
107 EbtUSamplerCubeArray,
108 EbtSamplerVideoWEBGL,
109 EbtGuardSamplerEnd = EbtSamplerVideoWEBGL, // non type: see implementation of IsSampler()
110
111 // images
112 EbtGuardImageBegin,
113 EbtImage2D = EbtGuardImageBegin,
114 EbtIImage2D,
115 EbtUImage2D,
116 EbtImage3D,
117 EbtIImage3D,
118 EbtUImage3D,
119 EbtImage2DArray,
120 EbtIImage2DArray,
121 EbtUImage2DArray,
122 EbtImageCube,
123 EbtIImageCube,
124 EbtUImageCube,
125 EbtImage1D, // Desktop GLSL image types
126 EbtIImage1D,
127 EbtUImage1D,
128 EbtImage1DArray,
129 EbtIImage1DArray,
130 EbtUImage1DArray,
131 EbtImage2DMS,
132 EbtIImage2DMS,
133 EbtUImage2DMS,
134 EbtImage2DMSArray,
135 EbtIImage2DMSArray,
136 EbtUImage2DMSArray,
137 EbtImageCubeArray,
138 EbtIImageCubeArray,
139 EbtUImageCubeArray,
140 EbtImageRect,
141 EbtIImageRect,
142 EbtUImageRect,
143 EbtImageBuffer,
144 EbtIImageBuffer,
145 EbtUImageBuffer,
146 EbtGuardImageEnd = EbtUImageBuffer,
147
148 // Subpass Input
149 EbtGuardSubpassInputBegin,
150 EbtSubpassInput = EbtGuardSubpassInputBegin,
151 EbtISubpassInput,
152 EbtUSubpassInput,
153 EbtSubpassInputMS,
154 EbtISubpassInputMS,
155 EbtUSubpassInputMS,
156 EbtGuardSubpassInputEnd = EbtUSubpassInputMS,
157
158 EbtLastSimpleType = EbtGuardSubpassInputEnd,
159
160 EbtStruct,
161 EbtInterfaceBlock,
162
163 // end of list
164 EbtLast = EbtInterfaceBlock
165 };
166
167 class TBasicMangledName
168 {
169 public:
TBasicMangledName(TBasicType t)170 constexpr TBasicMangledName(TBasicType t) : mName{'\0', '\0'}
171 {
172 if (t > EbtLastSimpleType)
173 {
174 mName[0] = '{';
175 mName[1] = '\0';
176 }
177 else if (t < 26)
178 {
179 mName[0] = '0';
180 mName[1] = static_cast<char>('A' + t);
181 }
182 else if (t < 52)
183 {
184 mName[0] = '0';
185 mName[1] = static_cast<char>('a' - 26 + t);
186 }
187 else if (t < 78)
188 {
189 mName[0] = '1';
190 mName[1] = static_cast<char>('A' - 52 + t);
191 }
192 else if (t < 104)
193 {
194 mName[0] = '1';
195 mName[1] = static_cast<char>('a' - 78 + t);
196 }
197 }
198
getName()199 constexpr char *getName() { return mName; }
200
201 static constexpr int mangledNameSize = 2;
202
203 private:
204 char mName[mangledNameSize];
205 };
206
207 const char *getBasicString(TBasicType t);
208
IsSampler(TBasicType type)209 inline bool IsSampler(TBasicType type)
210 {
211 return type >= EbtGuardSamplerBegin && type <= EbtGuardSamplerEnd;
212 }
213
IsImage(TBasicType type)214 inline bool IsImage(TBasicType type)
215 {
216 return type >= EbtGuardImageBegin && type <= EbtGuardImageEnd;
217 }
218
IsAtomicCounter(TBasicType type)219 inline bool IsAtomicCounter(TBasicType type)
220 {
221 return type == EbtAtomicCounter;
222 }
223
IsSubpassInputType(TBasicType type)224 inline bool IsSubpassInputType(TBasicType type)
225 {
226 return type >= EbtGuardSubpassInputBegin && type <= EbtGuardSubpassInputEnd;
227 }
228
IsOpaqueType(TBasicType type)229 inline bool IsOpaqueType(TBasicType type)
230 {
231 return IsSampler(type) || IsImage(type) || IsAtomicCounter(type) || IsSubpassInputType(type);
232 }
233
IsIntegerSampler(TBasicType type)234 inline bool IsIntegerSampler(TBasicType type)
235 {
236 switch (type)
237 {
238 case EbtISampler2D:
239 case EbtISampler3D:
240 case EbtISamplerCube:
241 case EbtISampler2DArray:
242 case EbtISampler2DMS:
243 case EbtISampler2DMSArray:
244 case EbtUSampler2D:
245 case EbtUSampler3D:
246 case EbtUSamplerCube:
247 case EbtUSampler2DArray:
248 case EbtUSampler2DMS:
249 case EbtUSampler2DMSArray:
250 case EbtISampler1D:
251 case EbtISampler1DArray:
252 case EbtISampler2DRect:
253 case EbtISamplerBuffer:
254 case EbtISamplerCubeArray:
255 case EbtUSampler1D:
256 case EbtUSampler1DArray:
257 case EbtUSampler2DRect:
258 case EbtUSamplerBuffer:
259 case EbtUSamplerCubeArray:
260 return true;
261 case EbtSampler2D:
262 case EbtSampler3D:
263 case EbtSamplerCube:
264 case EbtSamplerExternalOES:
265 case EbtSamplerExternal2DY2YEXT:
266 case EbtSampler2DRect:
267 case EbtSampler2DArray:
268 case EbtSampler2DShadow:
269 case EbtSamplerCubeShadow:
270 case EbtSampler2DArrayShadow:
271 case EbtSampler2DMS:
272 case EbtSampler2DMSArray:
273 case EbtSampler1D:
274 case EbtSampler1DArray:
275 case EbtSampler1DArrayShadow:
276 case EbtSamplerBuffer:
277 case EbtSamplerCubeArray:
278 case EbtSamplerCubeArrayShadow:
279 case EbtSampler1DShadow:
280 case EbtSampler2DRectShadow:
281 case EbtSamplerVideoWEBGL:
282 return false;
283 default:
284 ASSERT(!IsSampler(type));
285 }
286
287 return false;
288 }
289
IsIntegerSamplerUnsigned(TBasicType type)290 inline bool IsIntegerSamplerUnsigned(TBasicType type)
291 {
292 switch (type)
293 {
294 case EbtISampler2D:
295 case EbtISampler3D:
296 case EbtISamplerCube:
297 case EbtISampler2DArray:
298 case EbtISampler2DMS:
299 case EbtISampler2DMSArray:
300 case EbtISampler1D:
301 case EbtISampler1DArray:
302 case EbtISampler2DRect:
303 case EbtISamplerBuffer:
304 case EbtISamplerCubeArray:
305 return false;
306 case EbtUSampler2D:
307 case EbtUSampler3D:
308 case EbtUSamplerCube:
309 case EbtUSampler2DArray:
310 case EbtUSampler2DMS:
311 case EbtUSampler2DMSArray:
312 case EbtUSampler1D:
313 case EbtUSampler1DArray:
314 case EbtUSampler2DRect:
315 case EbtUSamplerBuffer:
316 case EbtUSamplerCubeArray:
317 return true;
318 default:
319 ASSERT(!IsIntegerSampler(type));
320 }
321
322 return false;
323 }
324
IsSampler2DMS(TBasicType type)325 inline bool IsSampler2DMS(TBasicType type)
326 {
327 switch (type)
328 {
329 case EbtSampler2DMS:
330 case EbtISampler2DMS:
331 case EbtUSampler2DMS:
332 return true;
333 default:
334 return false;
335 }
336 }
337
IsSampler2DMSArray(TBasicType type)338 inline bool IsSampler2DMSArray(TBasicType type)
339 {
340 switch (type)
341 {
342 case EbtSampler2DMSArray:
343 case EbtISampler2DMSArray:
344 case EbtUSampler2DMSArray:
345 return true;
346 default:
347 return false;
348 }
349 }
350
IsFloatImage(TBasicType type)351 inline bool IsFloatImage(TBasicType type)
352 {
353 switch (type)
354 {
355 case EbtImage1D:
356 case EbtImage2D:
357 case EbtImage3D:
358 case EbtImage1DArray:
359 case EbtImage2DArray:
360 case EbtImageCube:
361 case EbtImage2DMS:
362 case EbtImage2DMSArray:
363 case EbtImageCubeArray:
364 case EbtImageRect:
365 case EbtImageBuffer:
366 return true;
367 default:
368 break;
369 }
370
371 return false;
372 }
373
IsIntegerImage(TBasicType type)374 inline bool IsIntegerImage(TBasicType type)
375 {
376
377 switch (type)
378 {
379 case EbtIImage1D:
380 case EbtIImage2D:
381 case EbtIImage3D:
382 case EbtIImage1DArray:
383 case EbtIImage2DArray:
384 case EbtIImageCube:
385 case EbtIImage2DMS:
386 case EbtIImage2DMSArray:
387 case EbtIImageCubeArray:
388 case EbtIImageRect:
389 case EbtIImageBuffer:
390 return true;
391 default:
392 break;
393 }
394
395 return false;
396 }
397
IsUnsignedImage(TBasicType type)398 inline bool IsUnsignedImage(TBasicType type)
399 {
400
401 switch (type)
402 {
403 case EbtUImage1D:
404 case EbtUImage2D:
405 case EbtUImage3D:
406 case EbtUImage1DArray:
407 case EbtUImage2DArray:
408 case EbtUImageCube:
409 case EbtUImage2DMS:
410 case EbtUImage2DMSArray:
411 case EbtUImageCubeArray:
412 case EbtUImageRect:
413 case EbtUImageBuffer:
414 return true;
415 default:
416 break;
417 }
418
419 return false;
420 }
421
422 // Samplers are divided into 4 disjoint categories: 2D, cube, 3D, and array.
423 // Array samplers are not 2D samplers.
IsSampler2D(TBasicType type)424 inline bool IsSampler2D(TBasicType type)
425 {
426 switch (type)
427 {
428 case EbtSampler2D:
429 case EbtISampler2D:
430 case EbtUSampler2D:
431 case EbtSampler2DRect:
432 case EbtISampler2DRect:
433 case EbtUSampler2DRect:
434 case EbtSampler2DRectShadow:
435 case EbtSamplerExternalOES:
436 case EbtSamplerExternal2DY2YEXT:
437 case EbtSampler2DShadow:
438 case EbtSampler2DMS:
439 case EbtISampler2DMS:
440 case EbtUSampler2DMS:
441 case EbtSamplerVideoWEBGL:
442 return true;
443 case EbtSampler2DArray:
444 case EbtISampler2DArray:
445 case EbtUSampler2DArray:
446 case EbtSampler2DMSArray:
447 case EbtISampler2DMSArray:
448 case EbtUSampler2DMSArray:
449 case EbtSampler2DArrayShadow:
450 case EbtSampler3D:
451 case EbtISampler3D:
452 case EbtUSampler3D:
453 case EbtISamplerCube:
454 case EbtUSamplerCube:
455 case EbtSamplerCube:
456 case EbtSamplerCubeShadow:
457 case EbtSampler1D:
458 case EbtSampler1DArray:
459 case EbtSampler1DArrayShadow:
460 case EbtSamplerBuffer:
461 case EbtSamplerCubeArray:
462 case EbtSamplerCubeArrayShadow:
463 case EbtSampler1DShadow:
464 case EbtISampler1D:
465 case EbtISampler1DArray:
466 case EbtISamplerBuffer:
467 case EbtISamplerCubeArray:
468 case EbtUSampler1D:
469 case EbtUSampler1DArray:
470 case EbtUSamplerBuffer:
471 case EbtUSamplerCubeArray:
472 return false;
473 default:
474 ASSERT(!IsSampler(type));
475 }
476
477 return false;
478 }
479
IsSamplerCube(TBasicType type)480 inline bool IsSamplerCube(TBasicType type)
481 {
482 switch (type)
483 {
484 case EbtSamplerCube:
485 case EbtISamplerCube:
486 case EbtUSamplerCube:
487 case EbtSamplerCubeShadow:
488 return true;
489 case EbtSampler2D:
490 case EbtSampler3D:
491 case EbtSamplerExternalOES:
492 case EbtSamplerExternal2DY2YEXT:
493 case EbtSampler2DRect:
494 case EbtSampler2DArray:
495 case EbtSampler2DMS:
496 case EbtSampler2DMSArray:
497 case EbtISampler2D:
498 case EbtISampler3D:
499 case EbtISampler2DArray:
500 case EbtISampler2DMS:
501 case EbtISampler2DMSArray:
502 case EbtUSampler2D:
503 case EbtUSampler3D:
504 case EbtUSampler2DArray:
505 case EbtUSampler2DMS:
506 case EbtUSampler2DMSArray:
507 case EbtSampler2DShadow:
508 case EbtSampler2DArrayShadow:
509 case EbtSampler1D:
510 case EbtSampler1DArray:
511 case EbtSampler1DArrayShadow:
512 case EbtSamplerBuffer:
513 case EbtSamplerCubeArray:
514 case EbtSamplerCubeArrayShadow:
515 case EbtSampler1DShadow:
516 case EbtSampler2DRectShadow:
517 case EbtISampler1D:
518 case EbtISampler1DArray:
519 case EbtISampler2DRect:
520 case EbtISamplerBuffer:
521 case EbtISamplerCubeArray:
522 case EbtUSampler1D:
523 case EbtUSampler1DArray:
524 case EbtUSampler2DRect:
525 case EbtUSamplerBuffer:
526 case EbtUSamplerCubeArray:
527 case EbtSamplerVideoWEBGL:
528 return false;
529 default:
530 ASSERT(!IsSampler(type));
531 }
532
533 return false;
534 }
535
IsSampler3D(TBasicType type)536 inline bool IsSampler3D(TBasicType type)
537 {
538 switch (type)
539 {
540 case EbtSampler3D:
541 case EbtISampler3D:
542 case EbtUSampler3D:
543 return true;
544 case EbtSampler2D:
545 case EbtSamplerCube:
546 case EbtSamplerExternalOES:
547 case EbtSamplerExternal2DY2YEXT:
548 case EbtSampler2DRect:
549 case EbtSampler2DArray:
550 case EbtSampler2DMS:
551 case EbtSampler2DMSArray:
552 case EbtISampler2D:
553 case EbtISamplerCube:
554 case EbtISampler2DArray:
555 case EbtISampler2DMS:
556 case EbtISampler2DMSArray:
557 case EbtUSampler2D:
558 case EbtUSamplerCube:
559 case EbtUSampler2DArray:
560 case EbtUSampler2DMS:
561 case EbtUSampler2DMSArray:
562 case EbtSampler2DShadow:
563 case EbtSamplerCubeShadow:
564 case EbtSampler2DArrayShadow:
565 case EbtSampler1D:
566 case EbtSampler1DArray:
567 case EbtSampler1DArrayShadow:
568 case EbtSamplerBuffer:
569 case EbtSamplerCubeArray:
570 case EbtSamplerCubeArrayShadow:
571 case EbtSampler1DShadow:
572 case EbtSampler2DRectShadow:
573 case EbtISampler1D:
574 case EbtISampler1DArray:
575 case EbtISampler2DRect:
576 case EbtISamplerBuffer:
577 case EbtISamplerCubeArray:
578 case EbtUSampler1D:
579 case EbtUSampler1DArray:
580 case EbtUSampler2DRect:
581 case EbtUSamplerBuffer:
582 case EbtUSamplerCubeArray:
583 case EbtSamplerVideoWEBGL:
584 return false;
585 default:
586 ASSERT(!IsSampler(type));
587 }
588
589 return false;
590 }
591
IsSamplerArray(TBasicType type)592 inline bool IsSamplerArray(TBasicType type)
593 {
594 switch (type)
595 {
596 case EbtSampler1DArray:
597 case EbtISampler1DArray:
598 case EbtUSampler1DArray:
599 case EbtSampler1DArrayShadow:
600 case EbtSampler2DArray:
601 case EbtISampler2DArray:
602 case EbtUSampler2DArray:
603 case EbtSampler2DMSArray:
604 case EbtISampler2DMSArray:
605 case EbtUSampler2DMSArray:
606 case EbtSampler2DArrayShadow:
607 case EbtSamplerCubeArray:
608 case EbtISamplerCubeArray:
609 case EbtUSamplerCubeArray:
610 case EbtSamplerCubeArrayShadow:
611 return true;
612 case EbtSampler2D:
613 case EbtISampler2D:
614 case EbtUSampler2D:
615 case EbtSampler2DRect:
616 case EbtSamplerExternalOES:
617 case EbtSamplerExternal2DY2YEXT:
618 case EbtSampler3D:
619 case EbtISampler3D:
620 case EbtUSampler3D:
621 case EbtISamplerCube:
622 case EbtUSamplerCube:
623 case EbtSamplerCube:
624 case EbtSampler2DShadow:
625 case EbtSamplerCubeShadow:
626 case EbtSampler2DMS:
627 case EbtISampler2DMS:
628 case EbtUSampler2DMS:
629 case EbtSampler1D:
630 case EbtSamplerBuffer:
631 case EbtSampler1DShadow:
632 case EbtSampler2DRectShadow:
633 case EbtISampler1D:
634 case EbtISampler2DRect:
635 case EbtISamplerBuffer:
636 case EbtUSampler1D:
637 case EbtUSampler2DRect:
638 case EbtUSamplerBuffer:
639 case EbtSamplerVideoWEBGL:
640 return false;
641 default:
642 ASSERT(!IsSampler(type));
643 }
644
645 return false;
646 }
647
IsShadowSampler(TBasicType type)648 inline bool IsShadowSampler(TBasicType type)
649 {
650 switch (type)
651 {
652 case EbtSampler1DShadow:
653 case EbtSampler2DShadow:
654 case EbtSamplerCubeShadow:
655 case EbtSampler1DArrayShadow:
656 case EbtSampler2DArrayShadow:
657 case EbtSamplerCubeArrayShadow:
658 case EbtSampler2DRectShadow:
659 return true;
660 case EbtISampler2D:
661 case EbtISampler3D:
662 case EbtISamplerCube:
663 case EbtISampler2DArray:
664 case EbtISampler2DMS:
665 case EbtISampler2DMSArray:
666 case EbtUSampler2D:
667 case EbtUSampler3D:
668 case EbtUSamplerCube:
669 case EbtUSampler2DArray:
670 case EbtUSampler2DMS:
671 case EbtUSampler2DMSArray:
672 case EbtSampler2D:
673 case EbtSampler3D:
674 case EbtSamplerCube:
675 case EbtSamplerExternalOES:
676 case EbtSamplerExternal2DY2YEXT:
677 case EbtSampler2DRect:
678 case EbtSampler2DArray:
679 case EbtSampler2DMS:
680 case EbtSampler2DMSArray:
681 case EbtSampler1D:
682 case EbtSampler1DArray:
683 case EbtSamplerBuffer:
684 case EbtSamplerCubeArray:
685 case EbtISampler1D:
686 case EbtISampler1DArray:
687 case EbtISampler2DRect:
688 case EbtISamplerBuffer:
689 case EbtISamplerCubeArray:
690 case EbtUSampler1D:
691 case EbtUSampler1DArray:
692 case EbtUSampler2DRect:
693 case EbtUSamplerBuffer:
694 case EbtUSamplerCubeArray:
695 case EbtSamplerVideoWEBGL:
696 return false;
697 default:
698 ASSERT(!IsSampler(type));
699 }
700
701 return false;
702 }
703
IsImage2D(TBasicType type)704 inline bool IsImage2D(TBasicType type)
705 {
706 switch (type)
707 {
708 case EbtImage2D:
709 case EbtIImage2D:
710 case EbtUImage2D:
711 case EbtImage2DMS:
712 case EbtIImage2DMS:
713 case EbtUImage2DMS:
714 return true;
715 case EbtImage3D:
716 case EbtIImage3D:
717 case EbtUImage3D:
718 case EbtImage2DArray:
719 case EbtIImage2DArray:
720 case EbtUImage2DArray:
721 case EbtImageCube:
722 case EbtIImageCube:
723 case EbtUImageCube:
724 case EbtImage1D:
725 case EbtIImage1D:
726 case EbtUImage1D:
727 case EbtImage1DArray:
728 case EbtIImage1DArray:
729 case EbtUImage1DArray:
730 case EbtImage2DMSArray:
731 case EbtIImage2DMSArray:
732 case EbtUImage2DMSArray:
733 case EbtImageCubeArray:
734 case EbtIImageCubeArray:
735 case EbtUImageCubeArray:
736 case EbtImageRect:
737 case EbtIImageRect:
738 case EbtUImageRect:
739 case EbtImageBuffer:
740 case EbtIImageBuffer:
741 case EbtUImageBuffer:
742 return false;
743 default:
744 ASSERT(!IsImage(type));
745 }
746
747 return false;
748 }
749
IsImage3D(TBasicType type)750 inline bool IsImage3D(TBasicType type)
751 {
752 switch (type)
753 {
754 case EbtImage3D:
755 case EbtIImage3D:
756 case EbtUImage3D:
757 return true;
758 case EbtImage2D:
759 case EbtIImage2D:
760 case EbtUImage2D:
761 case EbtImage2DArray:
762 case EbtIImage2DArray:
763 case EbtUImage2DArray:
764 case EbtImageCube:
765 case EbtIImageCube:
766 case EbtUImageCube:
767 case EbtImage1D:
768 case EbtIImage1D:
769 case EbtUImage1D:
770 case EbtImage1DArray:
771 case EbtIImage1DArray:
772 case EbtUImage1DArray:
773 case EbtImage2DMS:
774 case EbtIImage2DMS:
775 case EbtUImage2DMS:
776 case EbtImage2DMSArray:
777 case EbtIImage2DMSArray:
778 case EbtUImage2DMSArray:
779 case EbtImageCubeArray:
780 case EbtIImageCubeArray:
781 case EbtUImageCubeArray:
782 case EbtImageRect:
783 case EbtIImageRect:
784 case EbtUImageRect:
785 case EbtImageBuffer:
786 case EbtIImageBuffer:
787 case EbtUImageBuffer:
788 return false;
789 default:
790 ASSERT(!IsImage(type));
791 }
792
793 return false;
794 }
795
IsImage2DArray(TBasicType type)796 inline bool IsImage2DArray(TBasicType type)
797 {
798 switch (type)
799 {
800 case EbtImage2DArray:
801 case EbtIImage2DArray:
802 case EbtUImage2DArray:
803 case EbtImage2DMSArray:
804 case EbtIImage2DMSArray:
805 case EbtUImage2DMSArray:
806 return true;
807 case EbtImage2D:
808 case EbtIImage2D:
809 case EbtUImage2D:
810 case EbtImage3D:
811 case EbtIImage3D:
812 case EbtUImage3D:
813 case EbtImageCube:
814 case EbtIImageCube:
815 case EbtUImageCube:
816 case EbtImage1D:
817 case EbtIImage1D:
818 case EbtUImage1D:
819 case EbtImage1DArray:
820 case EbtIImage1DArray:
821 case EbtUImage1DArray:
822 case EbtImage2DMS:
823 case EbtIImage2DMS:
824 case EbtUImage2DMS:
825 case EbtImageCubeArray:
826 case EbtIImageCubeArray:
827 case EbtUImageCubeArray:
828 case EbtImageRect:
829 case EbtIImageRect:
830 case EbtUImageRect:
831 case EbtImageBuffer:
832 case EbtIImageBuffer:
833 case EbtUImageBuffer:
834 return false;
835 default:
836 ASSERT(!IsImage(type));
837 }
838
839 return false;
840 }
841
IsImageCube(TBasicType type)842 inline bool IsImageCube(TBasicType type)
843 {
844 switch (type)
845 {
846 case EbtImageCube:
847 case EbtIImageCube:
848 case EbtUImageCube:
849 return true;
850 case EbtImage2D:
851 case EbtIImage2D:
852 case EbtUImage2D:
853 case EbtImage3D:
854 case EbtIImage3D:
855 case EbtUImage3D:
856 case EbtImage2DArray:
857 case EbtIImage2DArray:
858 case EbtUImage2DArray:
859 case EbtImage1D:
860 case EbtIImage1D:
861 case EbtUImage1D:
862 case EbtImage1DArray:
863 case EbtIImage1DArray:
864 case EbtUImage1DArray:
865 case EbtImage2DMS:
866 case EbtIImage2DMS:
867 case EbtUImage2DMS:
868 case EbtImage2DMSArray:
869 case EbtIImage2DMSArray:
870 case EbtUImage2DMSArray:
871 case EbtImageCubeArray:
872 case EbtIImageCubeArray:
873 case EbtUImageCubeArray:
874 case EbtImageRect:
875 case EbtIImageRect:
876 case EbtUImageRect:
877 case EbtImageBuffer:
878 case EbtIImageBuffer:
879 case EbtUImageBuffer:
880 return false;
881 default:
882 ASSERT(!IsImage(type));
883 }
884
885 return false;
886 }
887
IsInteger(TBasicType type)888 inline bool IsInteger(TBasicType type)
889 {
890 return type == EbtInt || type == EbtUInt;
891 }
892
SupportsPrecision(TBasicType type)893 inline bool SupportsPrecision(TBasicType type)
894 {
895 return type == EbtFloat || type == EbtInt || type == EbtUInt || IsOpaqueType(type);
896 }
897
898 //
899 // Qualifiers and built-ins. These are mainly used to see what can be read
900 // or written, and by the machine dependent translator to know which registers
901 // to allocate variables in. Since built-ins tend to go to different registers
902 // than varying or uniform, it makes sense they are peers, not sub-classes.
903 //
904 enum TQualifier
905 {
906 EvqTemporary, // For temporaries (within a function), read/write
907 EvqGlobal, // For globals read/write
908 EvqConst, // User defined constants and non-output parameters in functions
909 EvqAttribute, // Readonly
910 EvqVaryingIn, // readonly, fragment shaders only
911 EvqVaryingOut, // vertex shaders only read/write
912 EvqUniform, // Readonly, vertex and fragment
913 EvqBuffer, // read/write, vertex, fragment and compute shader
914 EvqPatch, // EXT_tessellation_shader storage qualifier
915
916 EvqVertexIn, // Vertex shader input
917 EvqFragmentOut, // Fragment shader output
918 EvqVertexOut, // Vertex shader output
919 EvqFragmentIn, // Fragment shader input
920
921 EvqFragmentInOut, // EXT_shader_framebuffer_fetch qualifier
922
923 // parameters
924 EvqIn,
925 EvqOut,
926 EvqInOut,
927 EvqConstReadOnly,
928
929 // built-ins read by vertex shader
930 EvqInstanceID,
931 EvqVertexID,
932
933 // built-ins written by vertex shader
934 EvqPosition,
935 EvqPointSize,
936
937 EvqDrawID, // ANGLE_multi_draw
938
939 // built-ins read by fragment shader
940 EvqFragCoord,
941 EvqFrontFacing,
942 EvqPointCoord,
943 EvqHelperInvocation,
944
945 // built-ins written by fragment shader
946 EvqFragColor,
947 EvqFragData,
948
949 EvqFragDepth, // gl_FragDepth for ESSL300.
950 EvqFragDepthEXT, // gl_FragDepthEXT for ESSL100, EXT_frag_depth.
951
952 EvqSecondaryFragColorEXT, // EXT_blend_func_extended
953 EvqSecondaryFragDataEXT, // EXT_blend_func_extended
954
955 EvqViewIDOVR, // OVR_multiview
956 EvqViewportIndex, // gl_ViewportIndex
957
958 EvqClipDistance, // APPLE_clip_distance/EXT_clip_cull_distance
959 EvqCullDistance, // EXT_clip_cull_distance
960
961 // built-ins written by the shader_framebuffer_fetch extension(s)
962 EvqLastFragColor,
963 EvqLastFragData,
964
965 // GLSL ES 3.0 vertex output and fragment input
966 EvqSmooth, // Incomplete qualifier, smooth is the default
967 EvqFlat, // Incomplete qualifier
968 EvqNoPerspective, // Incomplete qualifier
969 EvqCentroid, // Incomplete qualifier
970 EvqSample,
971 EvqSmoothOut,
972 EvqFlatOut,
973 EvqNoPerspectiveOut,
974 EvqCentroidOut, // Implies smooth
975 EvqSampleOut,
976 EvqSmoothIn,
977 EvqFlatIn,
978 EvqNoPerspectiveIn,
979 EvqCentroidIn, // Implies smooth
980 EvqSampleIn,
981
982 // GLSL ES 3.0 extension OES_sample_variables
983 EvqSampleID,
984 EvqSamplePosition,
985 EvqSampleMaskIn,
986 EvqSampleMask,
987 EvqNumSamples,
988
989 // GLSL ES 3.1 compute shader special variables
990 EvqShared,
991 EvqComputeIn,
992 EvqNumWorkGroups,
993 EvqWorkGroupSize,
994 EvqWorkGroupID,
995 EvqLocalInvocationID,
996 EvqGlobalInvocationID,
997 EvqLocalInvocationIndex,
998
999 // GLSL ES 3.1 memory qualifiers
1000 EvqReadOnly,
1001 EvqWriteOnly,
1002 EvqCoherent,
1003 EvqRestrict,
1004 EvqVolatile,
1005
1006 // GLSL ES 3.1 extension EXT_geometry_shader qualifiers
1007 EvqGeometryIn,
1008 EvqGeometryOut,
1009 EvqPerVertexIn, // gl_in
1010 EvqPrimitiveIDIn, // gl_PrimitiveIDIn
1011 EvqInvocationID, // gl_InvocationID
1012 EvqPrimitiveID, // gl_PrimitiveID
1013 EvqLayer, // gl_Layer
1014
1015 // GLSL ES 3.1 extension EXT_gpu_shader5 qualifiers
1016 EvqPrecise,
1017
1018 // GLES ES 3.1 extension EXT_tessellation_shader qualifiers
1019 EvqPatchIn,
1020 EvqPatchOut,
1021
1022 EvqTessControlIn,
1023 EvqTessControlOut,
1024 EvqPerVertexOut,
1025 EvqPatchVerticesIn,
1026 EvqTessLevelOuter,
1027 EvqTessLevelInner,
1028
1029 EvqTessEvaluationIn,
1030 EvqTessEvaluationOut,
1031 EvqTessCoord,
1032
1033 // end of list
1034 EvqLast
1035 };
1036
IsQualifierUnspecified(TQualifier qualifier)1037 inline bool IsQualifierUnspecified(TQualifier qualifier)
1038 {
1039 return (qualifier == EvqTemporary || qualifier == EvqGlobal);
1040 }
1041
IsStorageBuffer(TQualifier qualifier)1042 inline bool IsStorageBuffer(TQualifier qualifier)
1043 {
1044 return qualifier == EvqBuffer;
1045 }
1046
IsShaderIn(TQualifier qualifier)1047 inline bool IsShaderIn(TQualifier qualifier)
1048 {
1049 switch (qualifier)
1050 {
1051 case EvqVertexIn:
1052 case EvqTessControlIn:
1053 case EvqTessEvaluationIn:
1054 case EvqGeometryIn:
1055 case EvqFragmentIn:
1056 case EvqAttribute:
1057 case EvqVaryingIn:
1058 case EvqSmoothIn:
1059 case EvqFlatIn:
1060 case EvqNoPerspectiveIn:
1061 case EvqCentroidIn:
1062 case EvqSampleIn:
1063 case EvqPatchIn:
1064 return true;
1065 default:
1066 return false;
1067 }
1068 }
1069
IsShaderOut(TQualifier qualifier)1070 inline bool IsShaderOut(TQualifier qualifier)
1071 {
1072 switch (qualifier)
1073 {
1074 case EvqVertexOut:
1075 case EvqTessControlOut:
1076 case EvqTessEvaluationOut:
1077 case EvqGeometryOut:
1078 case EvqFragmentOut:
1079 case EvqVaryingOut:
1080 case EvqSmoothOut:
1081 case EvqFlatOut:
1082 case EvqNoPerspectiveOut:
1083 case EvqCentroidOut:
1084 case EvqSampleOut:
1085 case EvqPatchOut:
1086 case EvqFragmentInOut:
1087 return true;
1088 default:
1089 return false;
1090 }
1091 }
1092
IsShaderIoBlock(TQualifier qualifier)1093 inline bool IsShaderIoBlock(TQualifier qualifier)
1094 {
1095 switch (qualifier)
1096 {
1097 case EvqPerVertexIn:
1098 case EvqPerVertexOut:
1099 case EvqVertexOut:
1100 case EvqTessControlIn:
1101 case EvqTessControlOut:
1102 case EvqTessEvaluationIn:
1103 case EvqTessEvaluationOut:
1104 case EvqGeometryIn:
1105 case EvqGeometryOut:
1106 case EvqFragmentIn:
1107 return true;
1108 default:
1109 return false;
1110 }
1111 }
1112
1113 enum TLayoutImageInternalFormat
1114 {
1115 EiifUnspecified,
1116 EiifRGBA32F,
1117 EiifRGBA16F,
1118 EiifR32F,
1119 EiifRGBA32UI,
1120 EiifRGBA16UI,
1121 EiifRGBA8UI,
1122 EiifR32UI,
1123 EiifRGBA32I,
1124 EiifRGBA16I,
1125 EiifRGBA8I,
1126 EiifR32I,
1127 EiifRGBA8,
1128 EiifRGBA8_SNORM
1129 };
1130
1131 enum TLayoutMatrixPacking
1132 {
1133 EmpUnspecified,
1134 EmpRowMajor,
1135 EmpColumnMajor
1136 };
1137
1138 enum TLayoutBlockStorage
1139 {
1140 EbsUnspecified,
1141 EbsShared,
1142 EbsPacked,
1143 EbsStd140,
1144 EbsStd430
1145 };
1146
1147 enum TYuvCscStandardEXT
1148 {
1149 EycsUndefined,
1150 EycsItu601,
1151 EycsItu601FullRange,
1152 EycsItu709
1153 };
1154
1155 enum TLayoutPrimitiveType
1156 {
1157 EptUndefined,
1158 EptPoints,
1159 EptLines,
1160 EptLinesAdjacency,
1161 EptTriangles,
1162 EptTrianglesAdjacency,
1163 EptLineStrip,
1164 EptTriangleStrip
1165 };
1166
1167 enum TLayoutTessEvaluationType
1168 {
1169 EtetUndefined,
1170 EtetTriangles,
1171 EtetQuads,
1172 EtetIsolines,
1173 EtetEqualSpacing,
1174 EtetFractionalEvenSpacing,
1175 EtetFractionalOddSpacing,
1176 EtetCw,
1177 EtetCcw,
1178 EtetPointMode
1179 };
1180
1181 struct TLayoutQualifier
1182 {
1183 // Must have a trivial default constructor since it is used in YYSTYPE.
1184 TLayoutQualifier() = default;
1185
CreateTLayoutQualifier1186 constexpr static TLayoutQualifier Create() { return TLayoutQualifier(0); }
1187
isEmptyTLayoutQualifier1188 bool isEmpty() const
1189 {
1190 return location == -1 && binding == -1 && offset == -1 && numViews == -1 && yuv == false &&
1191 earlyFragmentTests == false && matrixPacking == EmpUnspecified &&
1192 blockStorage == EbsUnspecified && !localSize.isAnyValueSet() &&
1193 imageInternalFormat == EiifUnspecified && primitiveType == EptUndefined &&
1194 invocations == 0 && maxVertices == -1 && vertices == 0 &&
1195 tesPrimitiveType == EtetUndefined && tesVertexSpacingType == EtetUndefined &&
1196 tesOrderingType == EtetUndefined && tesPointType == EtetUndefined && index == -1 &&
1197 inputAttachmentIndex == -1 && noncoherent == false;
1198 }
1199
isCombinationValidTLayoutQualifier1200 bool isCombinationValid() const
1201 {
1202 bool workGroupSizeSpecified = localSize.isAnyValueSet();
1203 bool numViewsSet = (numViews != -1);
1204 bool geometryShaderSpecified =
1205 (primitiveType != EptUndefined) || (invocations != 0) || (maxVertices != -1);
1206 bool subpassInputSpecified = (inputAttachmentIndex != -1);
1207 bool otherLayoutQualifiersSpecified =
1208 (location != -1 || binding != -1 || index != -1 || matrixPacking != EmpUnspecified ||
1209 blockStorage != EbsUnspecified || imageInternalFormat != EiifUnspecified);
1210
1211 // we can have either the work group size specified, or number of views,
1212 // or yuv layout qualifier, or early_fragment_tests layout qualifier, or the other layout
1213 // qualifiers.
1214 return (workGroupSizeSpecified ? 1 : 0) + (numViewsSet ? 1 : 0) + (yuv ? 1 : 0) +
1215 (earlyFragmentTests ? 1 : 0) + (otherLayoutQualifiersSpecified ? 1 : 0) +
1216 (geometryShaderSpecified ? 1 : 0) + (subpassInputSpecified ? 1 : 0) +
1217 (noncoherent ? 1 : 0) <=
1218 1;
1219 }
1220
isLocalSizeEqualTLayoutQualifier1221 bool isLocalSizeEqual(const WorkGroupSize &localSizeIn) const
1222 {
1223 return localSize.isWorkGroupSizeMatching(localSizeIn);
1224 }
1225
1226 int location;
1227 unsigned int locationsSpecified;
1228 TLayoutMatrixPacking matrixPacking;
1229 TLayoutBlockStorage blockStorage;
1230
1231 // Compute shader layout qualifiers.
1232 WorkGroupSize localSize;
1233
1234 int binding;
1235 int offset;
1236
1237 // Image format layout qualifier
1238 TLayoutImageInternalFormat imageInternalFormat;
1239
1240 // OVR_multiview num_views.
1241 int numViews;
1242
1243 // EXT_YUV_target yuv layout qualifier.
1244 bool yuv;
1245
1246 // early_fragment_tests qualifier.
1247 bool earlyFragmentTests;
1248
1249 // OES_geometry_shader layout qualifiers.
1250 TLayoutPrimitiveType primitiveType;
1251 int invocations;
1252 int maxVertices;
1253
1254 // EXT_tessellation_shader shader layout qualifiers
1255 int vertices;
1256 TLayoutTessEvaluationType tesPrimitiveType;
1257 TLayoutTessEvaluationType tesVertexSpacingType;
1258 TLayoutTessEvaluationType tesOrderingType;
1259 TLayoutTessEvaluationType tesPointType;
1260
1261 // EXT_blend_func_extended fragment output layout qualifier
1262 int index;
1263
1264 // EXT_shader_framebuffer_fetch layout qualifiers.
1265 int inputAttachmentIndex;
1266 bool noncoherent;
1267
1268 private:
TLayoutQualifierTLayoutQualifier1269 explicit constexpr TLayoutQualifier(int /*placeholder*/)
1270 : location(-1),
1271 locationsSpecified(0),
1272 matrixPacking(EmpUnspecified),
1273 blockStorage(EbsUnspecified),
1274 localSize(-1),
1275 binding(-1),
1276 offset(-1),
1277 imageInternalFormat(EiifUnspecified),
1278 numViews(-1),
1279 yuv(false),
1280 earlyFragmentTests(false),
1281 primitiveType(EptUndefined),
1282 invocations(0),
1283 maxVertices(-1),
1284 vertices(0),
1285 tesPrimitiveType(EtetUndefined),
1286 tesVertexSpacingType(EtetUndefined),
1287 tesOrderingType(EtetUndefined),
1288 tesPointType(EtetUndefined),
1289 index(-1),
1290 inputAttachmentIndex(-1),
1291 noncoherent(false)
1292 {}
1293 };
1294
1295 struct TMemoryQualifier
1296 {
1297 // Must have a trivial default constructor since it is used in YYSTYPE.
1298 TMemoryQualifier() = default;
1299
isEmptyTMemoryQualifier1300 bool isEmpty() const
1301 {
1302 return !readonly && !writeonly && !coherent && !restrictQualifier && !volatileQualifier;
1303 }
1304
CreateTMemoryQualifier1305 constexpr static TMemoryQualifier Create() { return TMemoryQualifier(0); }
1306
1307 // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
1308 // An image can be qualified as both readonly and writeonly. It still can be can be used with
1309 // imageSize().
1310 bool readonly;
1311 bool writeonly;
1312 bool coherent;
1313
1314 // restrict and volatile are reserved keywords in C/C++
1315 bool restrictQualifier;
1316 bool volatileQualifier;
1317
1318 private:
TMemoryQualifierTMemoryQualifier1319 explicit constexpr TMemoryQualifier(int /*placeholder*/)
1320 : readonly(false),
1321 writeonly(false),
1322 coherent(false),
1323 restrictQualifier(false),
1324 volatileQualifier(false)
1325 {}
1326 };
1327
getWorkGroupSizeString(size_t dimension)1328 inline const char *getWorkGroupSizeString(size_t dimension)
1329 {
1330 switch (dimension)
1331 {
1332 case 0u:
1333 return "local_size_x";
1334 case 1u:
1335 return "local_size_y";
1336 case 2u:
1337 return "local_size_z";
1338 default:
1339 UNREACHABLE();
1340 return "dimension out of bounds";
1341 }
1342 }
1343
1344 //
1345 // This is just for debug and error message print out, carried along with the definitions above.
1346 //
getQualifierString(TQualifier q)1347 inline const char *getQualifierString(TQualifier q)
1348 {
1349 // clang-format off
1350 switch(q)
1351 {
1352 case EvqTemporary: return "Temporary";
1353 case EvqGlobal: return "Global";
1354 case EvqConst: return "const";
1355 case EvqAttribute: return "attribute";
1356 case EvqVaryingIn: return "varying";
1357 case EvqVaryingOut: return "varying";
1358 case EvqUniform: return "uniform";
1359 case EvqBuffer: return "buffer";
1360 case EvqPatch: return "patch";
1361 case EvqVertexIn: return "in";
1362 case EvqFragmentOut: return "out";
1363 case EvqVertexOut: return "out";
1364 case EvqFragmentIn: return "in";
1365 case EvqIn: return "in";
1366 case EvqOut: return "out";
1367 case EvqInOut: return "inout";
1368 case EvqConstReadOnly: return "const";
1369 case EvqInstanceID: return "InstanceID";
1370 case EvqVertexID: return "VertexID";
1371 case EvqPosition: return "Position";
1372 case EvqPointSize: return "PointSize";
1373 case EvqDrawID: return "DrawID";
1374 case EvqFragCoord: return "FragCoord";
1375 case EvqFrontFacing: return "FrontFacing";
1376 case EvqHelperInvocation: return "HelperInvocation";
1377 case EvqPointCoord: return "PointCoord";
1378 case EvqFragColor: return "FragColor";
1379 case EvqFragData: return "FragData";
1380 case EvqFragDepthEXT: return "FragDepth";
1381 case EvqFragDepth: return "FragDepth";
1382 case EvqSecondaryFragColorEXT: return "SecondaryFragColorEXT";
1383 case EvqSecondaryFragDataEXT: return "SecondaryFragDataEXT";
1384 case EvqViewIDOVR: return "ViewIDOVR";
1385 case EvqViewportIndex: return "ViewportIndex";
1386 case EvqLayer: return "Layer";
1387 case EvqLastFragColor: return "LastFragColor";
1388 case EvqLastFragData: return "LastFragData";
1389 case EvqFragmentInOut: return "inout";
1390 case EvqSmoothOut: return "smooth out";
1391 case EvqCentroidOut: return "smooth centroid out";
1392 case EvqFlatOut: return "flat out";
1393 case EvqNoPerspectiveOut: return "noperspective out";
1394 case EvqSmoothIn: return "smooth in";
1395 case EvqFlatIn: return "flat in";
1396 case EvqNoPerspectiveIn: return "noperspective in";
1397 case EvqCentroidIn: return "smooth centroid in";
1398 case EvqCentroid: return "centroid";
1399 case EvqFlat: return "flat";
1400 case EvqNoPerspective: return "noperspective";
1401 case EvqSmooth: return "smooth";
1402 case EvqShared: return "shared";
1403 case EvqComputeIn: return "in";
1404 case EvqNumWorkGroups: return "NumWorkGroups";
1405 case EvqWorkGroupSize: return "WorkGroupSize";
1406 case EvqWorkGroupID: return "WorkGroupID";
1407 case EvqLocalInvocationID: return "LocalInvocationID";
1408 case EvqGlobalInvocationID: return "GlobalInvocationID";
1409 case EvqLocalInvocationIndex: return "LocalInvocationIndex";
1410 case EvqReadOnly: return "readonly";
1411 case EvqWriteOnly: return "writeonly";
1412 case EvqGeometryIn: return "in";
1413 case EvqGeometryOut: return "out";
1414 case EvqPerVertexIn: return "gl_in";
1415 case EvqPrimitiveIDIn: return "gl_PrimitiveIDIn";
1416 case EvqInvocationID: return "gl_InvocationID";
1417 case EvqPrimitiveID: return "gl_PrimitiveID";
1418 case EvqPrecise: return "precise";
1419 case EvqClipDistance: return "ClipDistance";
1420 case EvqSample: return "sample";
1421 case EvqSampleIn: return "sample in";
1422 case EvqSampleOut: return "sample out";
1423 case EvqSampleID: return "SampleID";
1424 case EvqSamplePosition: return "SamplePosition";
1425 case EvqSampleMaskIn: return "SampleMaskIn";
1426 case EvqSampleMask: return "SampleMask";
1427 case EvqNumSamples: return "NumSamples";
1428 case EvqPatchIn: return "patch in";
1429 case EvqPatchOut: return "patch out";
1430 case EvqTessControlIn: return "in";
1431 case EvqTessControlOut: return "out";
1432 case EvqPerVertexOut: return "gl_out";
1433 case EvqPatchVerticesIn: return "PatchVerticesIn";
1434 case EvqTessLevelOuter: return "TessLevelOuter";
1435 case EvqTessLevelInner: return "TessLevelInner";
1436 case EvqTessEvaluationIn: return "in";
1437 case EvqTessEvaluationOut: return "out";
1438 case EvqTessCoord: return "TessCoord";
1439 default: UNREACHABLE(); return "unknown qualifier";
1440 }
1441 // clang-format on
1442 }
1443
getMatrixPackingString(TLayoutMatrixPacking mpq)1444 inline const char *getMatrixPackingString(TLayoutMatrixPacking mpq)
1445 {
1446 switch (mpq)
1447 {
1448 case EmpUnspecified:
1449 return "mp_unspecified";
1450 case EmpRowMajor:
1451 return "row_major";
1452 case EmpColumnMajor:
1453 return "column_major";
1454 default:
1455 UNREACHABLE();
1456 return "unknown matrix packing";
1457 }
1458 }
1459
getBlockStorageString(TLayoutBlockStorage bsq)1460 inline const char *getBlockStorageString(TLayoutBlockStorage bsq)
1461 {
1462 switch (bsq)
1463 {
1464 case EbsUnspecified:
1465 return "bs_unspecified";
1466 case EbsShared:
1467 return "shared";
1468 case EbsPacked:
1469 return "packed";
1470 case EbsStd140:
1471 return "std140";
1472 case EbsStd430:
1473 return "std430";
1474 default:
1475 UNREACHABLE();
1476 return "unknown block storage";
1477 }
1478 }
1479
getImageInternalFormatString(TLayoutImageInternalFormat iifq)1480 inline const char *getImageInternalFormatString(TLayoutImageInternalFormat iifq)
1481 {
1482 switch (iifq)
1483 {
1484 case EiifRGBA32F:
1485 return "rgba32f";
1486 case EiifRGBA16F:
1487 return "rgba16f";
1488 case EiifR32F:
1489 return "r32f";
1490 case EiifRGBA32UI:
1491 return "rgba32ui";
1492 case EiifRGBA16UI:
1493 return "rgba16ui";
1494 case EiifRGBA8UI:
1495 return "rgba8ui";
1496 case EiifR32UI:
1497 return "r32ui";
1498 case EiifRGBA32I:
1499 return "rgba32i";
1500 case EiifRGBA16I:
1501 return "rgba16i";
1502 case EiifRGBA8I:
1503 return "rgba8i";
1504 case EiifR32I:
1505 return "r32i";
1506 case EiifRGBA8:
1507 return "rgba8";
1508 case EiifRGBA8_SNORM:
1509 return "rgba8_snorm";
1510 default:
1511 UNREACHABLE();
1512 return "unknown internal image format";
1513 }
1514 }
1515
getYuvCscStandardEXT(const ImmutableString & str)1516 inline TYuvCscStandardEXT getYuvCscStandardEXT(const ImmutableString &str)
1517 {
1518 if (str == "itu_601")
1519 return EycsItu601;
1520 else if (str == "itu_601_full_range")
1521 return EycsItu601FullRange;
1522 else if (str == "itu_709")
1523 return EycsItu709;
1524 return EycsUndefined;
1525 }
1526
getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)1527 inline const char *getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)
1528 {
1529 switch (ycsq)
1530 {
1531 case EycsItu601:
1532 return "itu_601";
1533 case EycsItu601FullRange:
1534 return "itu_601_full_range";
1535 case EycsItu709:
1536 return "itu_709";
1537 default:
1538 UNREACHABLE();
1539 return "unknown color space conversion standard";
1540 }
1541 }
1542
getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)1543 inline const char *getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)
1544 {
1545 switch (primitiveType)
1546 {
1547 case EptPoints:
1548 return "points";
1549 case EptLines:
1550 return "lines";
1551 case EptTriangles:
1552 return "triangles";
1553 case EptLinesAdjacency:
1554 return "lines_adjacency";
1555 case EptTrianglesAdjacency:
1556 return "triangles_adjacency";
1557 case EptLineStrip:
1558 return "line_strip";
1559 case EptTriangleStrip:
1560 return "triangle_strip";
1561 default:
1562 UNREACHABLE();
1563 return "unknown geometry shader primitive type";
1564 }
1565 }
1566
getTessEvaluationShaderTypeString(TLayoutTessEvaluationType type)1567 inline const char *getTessEvaluationShaderTypeString(TLayoutTessEvaluationType type)
1568 {
1569 switch (type)
1570 {
1571 case EtetTriangles:
1572 return "triangles";
1573 case EtetQuads:
1574 return "quads";
1575 case EtetIsolines:
1576 return "isolines";
1577 case EtetEqualSpacing:
1578 return "equal_spacing";
1579 case EtetFractionalEvenSpacing:
1580 return "fractional_even_spacing";
1581 case EtetFractionalOddSpacing:
1582 return "fractional_odd_spacing";
1583 case EtetCw:
1584 return "cw";
1585 case EtetCcw:
1586 return "ccw";
1587 case EtetPointMode:
1588 return "point_mode";
1589 default:
1590 UNREACHABLE();
1591 return "unknown tessellation evaluation shader variable type";
1592 }
1593 }
1594
1595 } // namespace sh
1596
1597 #endif // COMPILER_TRANSLATOR_BASETYPES_H_
1598