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