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
IsSampler2DArray(TBasicType type)621 inline bool IsSampler2DArray(TBasicType type)
622 {
623 switch (type)
624 {
625 case EbtSampler2DArray:
626 case EbtISampler2DArray:
627 case EbtUSampler2DArray:
628 case EbtSampler2DMSArray:
629 case EbtISampler2DMSArray:
630 case EbtUSampler2DMSArray:
631 case EbtSampler2DArrayShadow:
632 return true;
633 case EbtSampler2D:
634 case EbtISampler2D:
635 case EbtUSampler2D:
636 case EbtSampler2DRect:
637 case EbtISampler2DRect:
638 case EbtUSampler2DRect:
639 case EbtSampler2DRectShadow:
640 case EbtSamplerExternalOES:
641 case EbtSamplerExternal2DY2YEXT:
642 case EbtSampler2DShadow:
643 case EbtSampler2DMS:
644 case EbtISampler2DMS:
645 case EbtUSampler2DMS:
646 case EbtSamplerVideoWEBGL:
647 case EbtSampler3D:
648 case EbtISampler3D:
649 case EbtUSampler3D:
650 case EbtISamplerCube:
651 case EbtUSamplerCube:
652 case EbtSamplerCube:
653 case EbtSamplerCubeShadow:
654 case EbtSamplerBuffer:
655 case EbtSamplerCubeArray:
656 case EbtSamplerCubeArrayShadow:
657 case EbtISamplerBuffer:
658 case EbtISamplerCubeArray:
659 case EbtUSamplerBuffer:
660 case EbtUSamplerCubeArray:
661 return false;
662 default:
663 ASSERT(!IsSampler(type));
664 }
665
666 return false;
667 }
668
IsSamplerBuffer(TBasicType type)669 inline bool IsSamplerBuffer(TBasicType type)
670 {
671 switch (type)
672 {
673 case EbtSamplerBuffer:
674 case EbtISamplerBuffer:
675 case EbtUSamplerBuffer:
676 return true;
677 default:
678 return false;
679 }
680 }
681
IsShadowSampler(TBasicType type)682 inline bool IsShadowSampler(TBasicType type)
683 {
684 switch (type)
685 {
686 case EbtSampler2DShadow:
687 case EbtSamplerCubeShadow:
688 case EbtSampler2DArrayShadow:
689 case EbtSamplerCubeArrayShadow:
690 case EbtSampler2DRectShadow:
691 return true;
692 case EbtISampler2D:
693 case EbtISampler3D:
694 case EbtISamplerCube:
695 case EbtISampler2DArray:
696 case EbtISampler2DMS:
697 case EbtISampler2DMSArray:
698 case EbtUSampler2D:
699 case EbtUSampler3D:
700 case EbtUSamplerCube:
701 case EbtUSampler2DArray:
702 case EbtUSampler2DMS:
703 case EbtUSampler2DMSArray:
704 case EbtSampler2D:
705 case EbtSampler3D:
706 case EbtSamplerCube:
707 case EbtSamplerExternalOES:
708 case EbtSamplerExternal2DY2YEXT:
709 case EbtSampler2DRect:
710 case EbtSampler2DArray:
711 case EbtSampler2DMS:
712 case EbtSampler2DMSArray:
713 case EbtSamplerBuffer:
714 case EbtSamplerCubeArray:
715 case EbtISampler2DRect:
716 case EbtISamplerBuffer:
717 case EbtISamplerCubeArray:
718 case EbtUSampler2DRect:
719 case EbtUSamplerBuffer:
720 case EbtUSamplerCubeArray:
721 case EbtSamplerVideoWEBGL:
722 return false;
723 default:
724 ASSERT(!IsSampler(type));
725 }
726
727 return false;
728 }
729
IsImage2D(TBasicType type)730 inline bool IsImage2D(TBasicType type)
731 {
732 switch (type)
733 {
734 case EbtImage2D:
735 case EbtIImage2D:
736 case EbtUImage2D:
737 case EbtImage2DMS:
738 case EbtIImage2DMS:
739 case EbtUImage2DMS:
740 return true;
741 case EbtImage3D:
742 case EbtIImage3D:
743 case EbtUImage3D:
744 case EbtImage2DArray:
745 case EbtIImage2DArray:
746 case EbtUImage2DArray:
747 case EbtImageCube:
748 case EbtIImageCube:
749 case EbtUImageCube:
750 case EbtImage2DMSArray:
751 case EbtIImage2DMSArray:
752 case EbtUImage2DMSArray:
753 case EbtImageCubeArray:
754 case EbtIImageCubeArray:
755 case EbtUImageCubeArray:
756 case EbtImageRect:
757 case EbtIImageRect:
758 case EbtUImageRect:
759 case EbtImageBuffer:
760 case EbtIImageBuffer:
761 case EbtUImageBuffer:
762 return false;
763 default:
764 ASSERT(!IsImage(type));
765 }
766
767 return false;
768 }
769
IsImage3D(TBasicType type)770 inline bool IsImage3D(TBasicType type)
771 {
772 switch (type)
773 {
774 case EbtImage3D:
775 case EbtIImage3D:
776 case EbtUImage3D:
777 return true;
778 case EbtImage2D:
779 case EbtIImage2D:
780 case EbtUImage2D:
781 case EbtImage2DArray:
782 case EbtIImage2DArray:
783 case EbtUImage2DArray:
784 case EbtImageCube:
785 case EbtIImageCube:
786 case EbtUImageCube:
787 case EbtImage2DMS:
788 case EbtIImage2DMS:
789 case EbtUImage2DMS:
790 case EbtImage2DMSArray:
791 case EbtIImage2DMSArray:
792 case EbtUImage2DMSArray:
793 case EbtImageCubeArray:
794 case EbtIImageCubeArray:
795 case EbtUImageCubeArray:
796 case EbtImageRect:
797 case EbtIImageRect:
798 case EbtUImageRect:
799 case EbtImageBuffer:
800 case EbtIImageBuffer:
801 case EbtUImageBuffer:
802 return false;
803 default:
804 ASSERT(!IsImage(type));
805 }
806
807 return false;
808 }
809
IsImage2DArray(TBasicType type)810 inline bool IsImage2DArray(TBasicType type)
811 {
812 switch (type)
813 {
814 case EbtImage2DArray:
815 case EbtIImage2DArray:
816 case EbtUImage2DArray:
817 case EbtImage2DMSArray:
818 case EbtIImage2DMSArray:
819 case EbtUImage2DMSArray:
820 return true;
821 case EbtImage2D:
822 case EbtIImage2D:
823 case EbtUImage2D:
824 case EbtImage3D:
825 case EbtIImage3D:
826 case EbtUImage3D:
827 case EbtImageCube:
828 case EbtIImageCube:
829 case EbtUImageCube:
830 case EbtImage2DMS:
831 case EbtIImage2DMS:
832 case EbtUImage2DMS:
833 case EbtImageCubeArray:
834 case EbtIImageCubeArray:
835 case EbtUImageCubeArray:
836 case EbtImageRect:
837 case EbtIImageRect:
838 case EbtUImageRect:
839 case EbtImageBuffer:
840 case EbtIImageBuffer:
841 case EbtUImageBuffer:
842 return false;
843 default:
844 ASSERT(!IsImage(type));
845 }
846
847 return false;
848 }
849
IsImageCube(TBasicType type)850 inline bool IsImageCube(TBasicType type)
851 {
852 switch (type)
853 {
854 case EbtImageCube:
855 case EbtIImageCube:
856 case EbtUImageCube:
857 return true;
858 case EbtImage2D:
859 case EbtIImage2D:
860 case EbtUImage2D:
861 case EbtImage3D:
862 case EbtIImage3D:
863 case EbtUImage3D:
864 case EbtImage2DArray:
865 case EbtIImage2DArray:
866 case EbtUImage2DArray:
867 case EbtImage2DMS:
868 case EbtIImage2DMS:
869 case EbtUImage2DMS:
870 case EbtImage2DMSArray:
871 case EbtIImage2DMSArray:
872 case EbtUImage2DMSArray:
873 case EbtImageCubeArray:
874 case EbtIImageCubeArray:
875 case EbtUImageCubeArray:
876 case EbtImageRect:
877 case EbtIImageRect:
878 case EbtUImageRect:
879 case EbtImageBuffer:
880 case EbtIImageBuffer:
881 case EbtUImageBuffer:
882 return false;
883 default:
884 ASSERT(!IsImage(type));
885 }
886
887 return false;
888 }
889
IsImageBuffer(TBasicType type)890 inline bool IsImageBuffer(TBasicType type)
891 {
892 switch (type)
893 {
894 case EbtImageBuffer:
895 case EbtIImageBuffer:
896 case EbtUImageBuffer:
897 return true;
898 default:
899 return false;
900 }
901 }
902
IsInteger(TBasicType type)903 inline bool IsInteger(TBasicType type)
904 {
905 return type == EbtInt || type == EbtUInt;
906 }
907
SupportsPrecision(TBasicType type)908 inline bool SupportsPrecision(TBasicType type)
909 {
910 return type == EbtFloat || type == EbtInt || type == EbtUInt || IsOpaqueType(type);
911 }
912
913 //
914 // Qualifiers and built-ins. These are mainly used to see what can be read
915 // or written, and by the machine dependent translator to know which registers
916 // to allocate variables in. Since built-ins tend to go to different registers
917 // than varying or uniform, it makes sense they are peers, not sub-classes.
918 //
919 enum TQualifier
920 {
921 EvqTemporary, // For temporaries (within a function), read/write
922 EvqGlobal, // For globals read/write
923 EvqConst, // User defined constants
924 EvqAttribute, // Readonly
925 EvqVaryingIn, // readonly, fragment shaders only
926 EvqVaryingOut, // vertex shaders only read/write
927 EvqUniform, // Readonly, vertex and fragment
928 EvqBuffer, // read/write, vertex, fragment and compute shader
929 EvqPatch, // EXT_tessellation_shader storage qualifier
930
931 EvqVertexIn, // Vertex shader input
932 EvqFragmentOut, // Fragment shader output
933 EvqVertexOut, // Vertex shader output
934 EvqFragmentIn, // Fragment shader input
935
936 EvqFragmentInOut, // EXT_shader_framebuffer_fetch qualifier
937
938 // parameters
939 EvqParamIn,
940 EvqParamOut,
941 EvqParamInOut,
942 EvqParamConst,
943
944 // built-ins read by vertex shader
945 EvqInstanceID,
946 EvqVertexID,
947
948 // built-ins written by vertex shader
949 EvqPosition,
950 EvqPointSize,
951
952 EvqDrawID, // ANGLE_multi_draw
953
954 // built-ins read by fragment shader
955 EvqFragCoord,
956 EvqFrontFacing,
957 EvqPointCoord,
958 EvqHelperInvocation,
959
960 // built-ins written by fragment shader
961 EvqFragColor,
962 EvqFragData,
963 EvqFragDepth, // gl_FragDepth for ESSL300, or gl_FragDepthEXT for ESSL100, EXT_frag_depth.
964
965 EvqSecondaryFragColorEXT, // EXT_blend_func_extended
966 EvqSecondaryFragDataEXT, // EXT_blend_func_extended
967
968 EvqViewIDOVR, // OVR_multiview
969
970 EvqClipDistance, // APPLE_clip_distance / EXT_clip_cull_distance / ANGLE_clip_cull_distance
971 EvqCullDistance, // EXT_clip_cull_distance / ANGLE_clip_cull_distance
972
973 // built-ins written by the shader_framebuffer_fetch extension(s)
974 EvqLastFragColor,
975 EvqLastFragData,
976 // built-ins written by the shader_framebuffer_fetch_depth_stencil extension
977 EvqLastFragDepth,
978 EvqLastFragStencil,
979
980 // GLSL ES 3.0 vertex output and fragment input
981
982 // This section combines
983 // * storage (in/out),
984 // * auxiliary storage (<none>/centroid/sample), and
985 // * interpolation (<none>/smooth/flat/noperspective)
986 // qualifiers into a flat list.
987
988 // Qualifiers not ending with 'In' or 'Out' are considered incomplete
989 // and are used only internally. Some combinations are redundant
990 // because they represent the same effective qualifiers. Specifically:
991 // * 'smooth' is implied when an interpolation qualifier is omitted
992 // * 'flat' makes 'centroid' and 'sample' irrelevant
993
994 // <none> <none> -> original storage qualifier, e.g., EvqFragmentIn, implies smooth
995 // <none> centroid -> EvqCentroid
996 // <none> sample -> EvqSample
997 // smooth <none> -> EvqSmooth
998 // smooth centroid -> EvqCentroid
999 // smooth sample -> EvqSample
1000 // flat <none> -> EvqFlat
1001 // flat centroid -> EvqFlat
1002 // flat sample -> EvqFlat
1003 // noperspective <none> -> EvqNoPerspective
1004 // noperspective centroid -> EvqNoPerspectiveCentroid
1005 // noperspective sample -> EvqNoPerspectiveSample
1006
1007 EvqSmooth, // Incomplete
1008 EvqFlat, // Incomplete
1009 EvqNoPerspective, // Incomplete
1010 EvqCentroid, // Incomplete
1011 EvqSample, // Incomplete
1012 EvqNoPerspectiveCentroid, // Incomplete
1013 EvqNoPerspectiveSample, // Incomplete
1014 EvqSmoothOut,
1015 EvqFlatOut,
1016 EvqNoPerspectiveOut,
1017 EvqCentroidOut, // Implies smooth
1018 EvqSampleOut, // Implies smooth
1019 EvqNoPerspectiveCentroidOut,
1020 EvqNoPerspectiveSampleOut,
1021 EvqSmoothIn,
1022 EvqFlatIn,
1023 EvqNoPerspectiveIn,
1024 EvqCentroidIn, // Implies smooth
1025 EvqSampleIn, // Implies smooth
1026 EvqNoPerspectiveCentroidIn,
1027 EvqNoPerspectiveSampleIn,
1028
1029 // GLSL ES 3.0 extension OES_sample_variables
1030 EvqSampleID,
1031 EvqSamplePosition,
1032 EvqSampleMaskIn,
1033 EvqSampleMask,
1034 EvqNumSamples,
1035
1036 // GLSL ES 3.1 compute shader special variables
1037 EvqShared,
1038 EvqComputeIn,
1039 EvqNumWorkGroups,
1040 EvqWorkGroupSize,
1041 EvqWorkGroupID,
1042 EvqLocalInvocationID,
1043 EvqGlobalInvocationID,
1044 EvqLocalInvocationIndex,
1045
1046 // GLSL ES 3.1 memory qualifiers
1047 EvqReadOnly,
1048 EvqWriteOnly,
1049 EvqCoherent,
1050 EvqRestrict,
1051 EvqVolatile,
1052
1053 // GLSL ES 3.1 extension EXT_geometry_shader qualifiers
1054 EvqGeometryIn,
1055 EvqGeometryOut,
1056 EvqPerVertexIn, // gl_in
1057 EvqPrimitiveIDIn, // gl_PrimitiveIDIn
1058 EvqInvocationID, // gl_InvocationID
1059 EvqPrimitiveID, // gl_PrimitiveID
1060 EvqLayerOut, // gl_Layer (GS output)
1061 EvqLayerIn, // gl_Layer (FS input)
1062
1063 // GLSL ES 3.1 extension EXT_gpu_shader5 qualifiers
1064 EvqPrecise,
1065
1066 // GLES ES 3.1 extension EXT_tessellation_shader qualifiers
1067 EvqPatchIn,
1068 EvqPatchOut,
1069
1070 EvqTessControlIn,
1071 EvqTessControlOut,
1072 EvqPerVertexOut,
1073 EvqPatchVerticesIn,
1074 EvqTessLevelOuter,
1075 EvqTessLevelInner,
1076
1077 // GLES ES 3.1 extension EXT_primitive_bounding_box/OES_primitive_bounding_box
1078 EvqBoundingBox,
1079
1080 EvqTessEvaluationIn,
1081 EvqTessEvaluationOut,
1082 EvqTessCoord,
1083
1084 // A specialization constant, which is not valid GLSL ES, but is there to support Vulkan output
1085 // generation. In that case, TLayoutQualifier::location will contain the somewhat equivalent
1086 // constant_id.
1087 EvqSpecConst,
1088
1089 // __pixel_localEXT from EXT_shader_pixel_local_storage.
1090 EvqPixelLocalEXT,
1091
1092 // end of list
1093 EvqLast
1094 };
1095
IsQualifierUnspecified(TQualifier qualifier)1096 inline bool IsQualifierUnspecified(TQualifier qualifier)
1097 {
1098 return (qualifier == EvqTemporary || qualifier == EvqGlobal);
1099 }
1100
IsStorageBuffer(TQualifier qualifier)1101 inline bool IsStorageBuffer(TQualifier qualifier)
1102 {
1103 return qualifier == EvqBuffer;
1104 }
1105
IsShaderIn(TQualifier qualifier)1106 inline bool IsShaderIn(TQualifier qualifier)
1107 {
1108 switch (qualifier)
1109 {
1110 case EvqVertexIn:
1111 case EvqTessControlIn:
1112 case EvqTessEvaluationIn:
1113 case EvqGeometryIn:
1114 case EvqFragmentIn:
1115 case EvqPerVertexIn:
1116 case EvqAttribute:
1117 case EvqVaryingIn:
1118 case EvqSmoothIn:
1119 case EvqFlatIn:
1120 case EvqNoPerspectiveIn:
1121 case EvqCentroidIn:
1122 case EvqSampleIn:
1123 case EvqNoPerspectiveCentroidIn:
1124 case EvqNoPerspectiveSampleIn:
1125 case EvqPatchIn:
1126 return true;
1127 default:
1128 return false;
1129 }
1130 }
1131
IsShaderOut(TQualifier qualifier)1132 inline bool IsShaderOut(TQualifier qualifier)
1133 {
1134 switch (qualifier)
1135 {
1136 case EvqVertexOut:
1137 case EvqTessControlOut:
1138 case EvqTessEvaluationOut:
1139 case EvqGeometryOut:
1140 case EvqFragmentOut:
1141 case EvqPerVertexOut:
1142 case EvqVaryingOut:
1143 case EvqSmoothOut:
1144 case EvqFlatOut:
1145 case EvqNoPerspectiveOut:
1146 case EvqCentroidOut:
1147 case EvqSampleOut:
1148 case EvqNoPerspectiveCentroidOut:
1149 case EvqNoPerspectiveSampleOut:
1150 case EvqPatchOut:
1151 case EvqFragmentInOut:
1152 return true;
1153 default:
1154 return false;
1155 }
1156 }
1157
IsShaderIoBlock(TQualifier qualifier)1158 inline bool IsShaderIoBlock(TQualifier qualifier)
1159 {
1160 switch (qualifier)
1161 {
1162 case EvqPerVertexIn:
1163 case EvqPerVertexOut:
1164 case EvqVertexOut:
1165 case EvqTessControlIn:
1166 case EvqTessControlOut:
1167 case EvqTessEvaluationIn:
1168 case EvqTessEvaluationOut:
1169 case EvqPatchIn:
1170 case EvqPatchOut:
1171 case EvqGeometryIn:
1172 case EvqGeometryOut:
1173 case EvqFragmentIn:
1174 return true;
1175 default:
1176 return false;
1177 }
1178 }
1179
1180 enum TLayoutImageInternalFormat
1181 {
1182 EiifUnspecified,
1183 EiifRGBA32F,
1184 EiifRGBA16F,
1185 EiifR32F,
1186 EiifRGBA32UI,
1187 EiifRGBA16UI,
1188 EiifRGBA8UI,
1189 EiifR32UI,
1190 EiifRGBA32I,
1191 EiifRGBA16I,
1192 EiifRGBA8I,
1193 EiifR32I,
1194 EiifRGBA8,
1195 EiifRGBA8_SNORM,
1196
1197 EiifLast = EiifRGBA8_SNORM,
1198 };
1199
1200 enum TLayoutMatrixPacking
1201 {
1202 EmpUnspecified,
1203 EmpRowMajor,
1204 EmpColumnMajor,
1205
1206 EmpLast = EmpColumnMajor,
1207 };
1208
1209 enum TLayoutBlockStorage
1210 {
1211 EbsUnspecified,
1212 EbsShared,
1213 EbsPacked,
1214 EbsStd140,
1215 EbsStd430,
1216
1217 EbsLast = EbsStd430,
1218 };
1219
1220 enum TLayoutDepth
1221 {
1222 EdUnspecified,
1223 EdAny,
1224 EdGreater,
1225 EdLess,
1226 EdUnchanged,
1227 };
1228
1229 enum TYuvCscStandardEXT
1230 {
1231 EycsUndefined,
1232 EycsItu601,
1233 EycsItu601FullRange,
1234 EycsItu709
1235 };
1236
1237 enum TLayoutPrimitiveType
1238 {
1239 EptUndefined,
1240 EptPoints,
1241 EptLines,
1242 EptLinesAdjacency,
1243 EptTriangles,
1244 EptTrianglesAdjacency,
1245 EptLineStrip,
1246 EptTriangleStrip
1247 };
1248
1249 enum TLayoutTessEvaluationType
1250 {
1251 EtetUndefined,
1252 EtetTriangles,
1253 EtetQuads,
1254 EtetIsolines,
1255 EtetEqualSpacing,
1256 EtetFractionalEvenSpacing,
1257 EtetFractionalOddSpacing,
1258 EtetCw,
1259 EtetCcw,
1260 EtetPointMode
1261 };
1262
1263 class AdvancedBlendEquations
1264 {
1265 public:
1266 // Must have a trivial default constructor since it is used in YYSTYPE.
1267 AdvancedBlendEquations() = default;
AdvancedBlendEquations(uint32_t initialState)1268 explicit constexpr AdvancedBlendEquations(uint32_t initialState)
1269 : mEnabledBlendEquations(initialState)
1270 {}
1271
1272 bool any() const;
1273 bool all() const;
1274 bool anyHsl() const;
1275
1276 void setAll();
reset()1277 void reset() { mEnabledBlendEquations = 0; }
1278
1279 // Parameter is gl::BlendEquationType, but PackedEnums.h include is not possible here.
1280 void set(uint32_t blendEquation);
1281
bits()1282 uint32_t bits() const { return mEnabledBlendEquations; }
1283
1284 AdvancedBlendEquations operator|=(AdvancedBlendEquations other)
1285 {
1286 mEnabledBlendEquations |= other.mEnabledBlendEquations;
1287 return *this;
1288 }
1289
1290 static const char *GetLayoutString(uint32_t blendEquation);
1291 static const char *GetAllEquationsLayoutString();
1292
1293 private:
1294 uint32_t mEnabledBlendEquations;
1295 };
1296
1297 struct TLayoutQualifier
1298 {
1299 // Must have a trivial default constructor since it is used in YYSTYPE.
1300 TLayoutQualifier() = default;
1301
CreateTLayoutQualifier1302 constexpr static TLayoutQualifier Create() { return TLayoutQualifier(0); }
1303
isEmptyTLayoutQualifier1304 bool isEmpty() const
1305 {
1306 return location == -1 && binding == -1 && offset == -1 && numViews == -1 && yuv == false &&
1307 earlyFragmentTests == false && matrixPacking == EmpUnspecified &&
1308 blockStorage == EbsUnspecified && !localSize.isAnyValueSet() &&
1309 imageInternalFormat == EiifUnspecified && primitiveType == EptUndefined &&
1310 invocations == 0 && maxVertices == -1 && vertices == 0 && depth == EdUnspecified &&
1311 tesPrimitiveType == EtetUndefined && tesVertexSpacingType == EtetUndefined &&
1312 tesOrderingType == EtetUndefined && tesPointType == EtetUndefined && index == -1 &&
1313 inputAttachmentIndex == -1 && noncoherent == false &&
1314 !advancedBlendEquations.any() && !pushConstant;
1315 }
1316
isCombinationValidTLayoutQualifier1317 bool isCombinationValid() const
1318 {
1319 bool workGroupSizeSpecified = localSize.isAnyValueSet();
1320 bool numViewsSet = (numViews != -1);
1321 bool geometryShaderSpecified =
1322 (primitiveType != EptUndefined) || (invocations != 0) || (maxVertices != -1);
1323 bool subpassInputSpecified = (inputAttachmentIndex != -1);
1324 bool otherLayoutQualifiersSpecified =
1325 (location != -1 || binding != -1 || index != -1 || matrixPacking != EmpUnspecified ||
1326 blockStorage != EbsUnspecified || imageInternalFormat != EiifUnspecified);
1327 bool blendEquationSpecified = advancedBlendEquations.any();
1328
1329 // we can have either the work group size specified, or number of views,
1330 // or yuv layout qualifier, or early_fragment_tests layout qualifier, or the other layout
1331 // qualifiers.
1332 return (workGroupSizeSpecified ? 1 : 0) + (numViewsSet ? 1 : 0) + (yuv ? 1 : 0) +
1333 (earlyFragmentTests ? 1 : 0) + (otherLayoutQualifiersSpecified ? 1 : 0) +
1334 (geometryShaderSpecified ? 1 : 0) + (subpassInputSpecified ? 1 : 0) +
1335 (noncoherent ? 1 : 0) + (blendEquationSpecified ? 1 : 0) <=
1336 1;
1337 }
1338
isLocalSizeEqualTLayoutQualifier1339 bool isLocalSizeEqual(const WorkGroupSize &localSizeIn) const
1340 {
1341 return localSize.isWorkGroupSizeMatching(localSizeIn);
1342 }
1343
1344 int location;
1345 unsigned int locationsSpecified;
1346 TLayoutMatrixPacking matrixPacking;
1347 TLayoutBlockStorage blockStorage;
1348
1349 // Compute shader layout qualifiers.
1350 WorkGroupSize localSize;
1351
1352 int binding;
1353 int offset;
1354
1355 bool pushConstant;
1356
1357 // Depth layout qualifier
1358 TLayoutDepth depth;
1359
1360 // Image format layout qualifier
1361 TLayoutImageInternalFormat imageInternalFormat;
1362
1363 // OVR_multiview num_views.
1364 int numViews;
1365
1366 // EXT_YUV_target yuv layout qualifier.
1367 bool yuv;
1368
1369 // early_fragment_tests qualifier.
1370 bool earlyFragmentTests;
1371
1372 // OES_geometry_shader layout qualifiers.
1373 TLayoutPrimitiveType primitiveType;
1374 int invocations;
1375 int maxVertices;
1376
1377 // EXT_tessellation_shader shader layout qualifiers
1378 int vertices;
1379 TLayoutTessEvaluationType tesPrimitiveType;
1380 TLayoutTessEvaluationType tesVertexSpacingType;
1381 TLayoutTessEvaluationType tesOrderingType;
1382 TLayoutTessEvaluationType tesPointType;
1383
1384 // EXT_blend_func_extended fragment output layout qualifier
1385 int index;
1386
1387 // EXT_shader_framebuffer_fetch layout qualifiers.
1388 int inputAttachmentIndex;
1389 bool noncoherent;
1390
1391 // KHR_blend_equation_advanced layout qualifiers.
1392 AdvancedBlendEquations advancedBlendEquations;
1393
1394 // D3D 11.3 Rasterizer Order Views (ROVs).
1395 // This qualifier is only used internally by ANGLE; it is not visible to the application.
1396 bool rasterOrdered;
1397
1398 private:
TLayoutQualifierTLayoutQualifier1399 explicit constexpr TLayoutQualifier(int /*placeholder*/)
1400 : location(-1),
1401 locationsSpecified(0),
1402 matrixPacking(EmpUnspecified),
1403 blockStorage(EbsUnspecified),
1404 localSize(-1),
1405 binding(-1),
1406 offset(-1),
1407 pushConstant(false),
1408 depth(EdUnspecified),
1409 imageInternalFormat(EiifUnspecified),
1410 numViews(-1),
1411 yuv(false),
1412 earlyFragmentTests(false),
1413 primitiveType(EptUndefined),
1414 invocations(0),
1415 maxVertices(-1),
1416 vertices(0),
1417 tesPrimitiveType(EtetUndefined),
1418 tesVertexSpacingType(EtetUndefined),
1419 tesOrderingType(EtetUndefined),
1420 tesPointType(EtetUndefined),
1421 index(-1),
1422 inputAttachmentIndex(-1),
1423 noncoherent(false),
1424 advancedBlendEquations(0),
1425 rasterOrdered(false)
1426 {}
1427 };
1428
1429 struct TMemoryQualifier
1430 {
1431 // Must have a trivial default constructor since it is used in YYSTYPE.
1432 TMemoryQualifier() = default;
1433
isEmptyTMemoryQualifier1434 bool isEmpty() const
1435 {
1436 return !readonly && !writeonly && !coherent && !restrictQualifier && !volatileQualifier;
1437 }
1438
CreateTMemoryQualifier1439 constexpr static TMemoryQualifier Create() { return TMemoryQualifier(0); }
1440
1441 // Used for GLSL generation, debugging and error messages.
getAnyQualifierStringTMemoryQualifier1442 inline const char *getAnyQualifierString() const
1443 {
1444 if (readonly)
1445 {
1446 return "readonly";
1447 }
1448 if (writeonly)
1449 {
1450 return "writeonly";
1451 }
1452 if (coherent)
1453 {
1454 return "coherent";
1455 }
1456 if (restrictQualifier)
1457 {
1458 return "restrict";
1459 }
1460 if (volatileQualifier)
1461 {
1462 return "volatile";
1463 }
1464 ASSERT(isEmpty());
1465 return "";
1466 }
1467
1468 // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
1469 // An image can be qualified as both readonly and writeonly. It still can be can be used with
1470 // imageSize().
1471 bool readonly;
1472 bool writeonly;
1473 bool coherent;
1474
1475 // restrict and volatile are reserved keywords in C/C++
1476 bool restrictQualifier;
1477 bool volatileQualifier;
1478
1479 private:
TMemoryQualifierTMemoryQualifier1480 explicit constexpr TMemoryQualifier(int /*placeholder*/)
1481 : readonly(false),
1482 writeonly(false),
1483 coherent(false),
1484 restrictQualifier(false),
1485 volatileQualifier(false)
1486 {}
1487 };
1488
getWorkGroupSizeString(size_t dimension)1489 inline const char *getWorkGroupSizeString(size_t dimension)
1490 {
1491 switch (dimension)
1492 {
1493 case 0u:
1494 return "local_size_x";
1495 case 1u:
1496 return "local_size_y";
1497 case 2u:
1498 return "local_size_z";
1499 default:
1500 UNREACHABLE();
1501 return "dimension out of bounds";
1502 }
1503 }
1504
1505 // Used for GLSL generation, debugging and error messages.
getQualifierString(TQualifier q)1506 inline const char *getQualifierString(TQualifier q)
1507 {
1508 // clang-format off
1509 switch(q)
1510 {
1511 case EvqTemporary: return "Temporary";
1512 case EvqGlobal: return "Global";
1513 case EvqConst: return "const";
1514 case EvqAttribute: return "attribute";
1515 case EvqVaryingIn: return "varying";
1516 case EvqVaryingOut: return "varying";
1517 case EvqUniform: return "uniform";
1518 case EvqBuffer: return "buffer";
1519 case EvqPatch: return "patch";
1520 case EvqVertexIn: return "in";
1521 case EvqFragmentOut: return "out";
1522 case EvqVertexOut: return "out";
1523 case EvqFragmentIn: return "in";
1524 case EvqParamIn: return "in";
1525 case EvqParamOut: return "out";
1526 case EvqParamInOut: return "inout";
1527 case EvqParamConst: return "const";
1528 case EvqInstanceID: return "InstanceID";
1529 case EvqVertexID: return "VertexID";
1530 case EvqPosition: return "Position";
1531 case EvqPointSize: return "PointSize";
1532 case EvqDrawID: return "DrawID";
1533 case EvqFragCoord: return "FragCoord";
1534 case EvqFrontFacing: return "FrontFacing";
1535 case EvqHelperInvocation: return "HelperInvocation";
1536 case EvqPointCoord: return "PointCoord";
1537 case EvqFragColor: return "FragColor";
1538 case EvqFragData: return "FragData";
1539 case EvqFragDepth: return "FragDepth";
1540 case EvqSecondaryFragColorEXT: return "SecondaryFragColorEXT";
1541 case EvqSecondaryFragDataEXT: return "SecondaryFragDataEXT";
1542 case EvqViewIDOVR: return "ViewIDOVR";
1543 case EvqLayerOut: return "LayerOut";
1544 case EvqLayerIn: return "LayerIn";
1545 case EvqLastFragColor: return "LastFragColor";
1546 case EvqLastFragData: return "LastFragData";
1547 case EvqLastFragDepth: return "LastFragDepthARM";
1548 case EvqLastFragStencil: return "LastFragStencilARM";
1549 case EvqFragmentInOut: return "inout";
1550 case EvqSmoothOut: return "smooth out";
1551 case EvqCentroidOut: return "smooth centroid out";
1552 case EvqFlatOut: return "flat out";
1553 case EvqNoPerspectiveOut: return "noperspective out";
1554 case EvqNoPerspectiveCentroidOut: return "noperspective centroid out";
1555 case EvqNoPerspectiveSampleOut: return "noperspective sample out";
1556 case EvqSmoothIn: return "smooth in";
1557 case EvqFlatIn: return "flat in";
1558 case EvqNoPerspectiveIn: return "noperspective in";
1559 case EvqNoPerspectiveCentroidIn: return "noperspective centroid in";
1560 case EvqNoPerspectiveSampleIn: return "noperspective sample in";
1561 case EvqCentroidIn: return "smooth centroid in";
1562 case EvqCentroid: return "centroid";
1563 case EvqFlat: return "flat";
1564 case EvqNoPerspective: return "noperspective";
1565 case EvqNoPerspectiveCentroid: return "noperspective centroid";
1566 case EvqNoPerspectiveSample: return "noperspective sample";
1567 case EvqSmooth: return "smooth";
1568 case EvqShared: return "shared";
1569 case EvqComputeIn: return "in";
1570 case EvqNumWorkGroups: return "NumWorkGroups";
1571 case EvqWorkGroupSize: return "WorkGroupSize";
1572 case EvqWorkGroupID: return "WorkGroupID";
1573 case EvqLocalInvocationID: return "LocalInvocationID";
1574 case EvqGlobalInvocationID: return "GlobalInvocationID";
1575 case EvqLocalInvocationIndex: return "LocalInvocationIndex";
1576 case EvqReadOnly: return "readonly";
1577 case EvqWriteOnly: return "writeonly";
1578 case EvqCoherent: return "coherent";
1579 case EvqRestrict: return "restrict";
1580 case EvqVolatile: return "volatile";
1581 case EvqGeometryIn: return "in";
1582 case EvqGeometryOut: return "out";
1583 case EvqPerVertexIn: return "gl_in";
1584 case EvqPrimitiveIDIn: return "gl_PrimitiveIDIn";
1585 case EvqInvocationID: return "gl_InvocationID";
1586 case EvqPrimitiveID: return "gl_PrimitiveID";
1587 case EvqPrecise: return "precise";
1588 case EvqClipDistance: return "ClipDistance";
1589 case EvqCullDistance: return "CullDistance";
1590 case EvqSample: return "sample";
1591 case EvqSampleIn: return "sample in";
1592 case EvqSampleOut: return "sample out";
1593 case EvqSampleID: return "SampleID";
1594 case EvqSamplePosition: return "SamplePosition";
1595 case EvqSampleMaskIn: return "SampleMaskIn";
1596 case EvqSampleMask: return "SampleMask";
1597 case EvqNumSamples: return "NumSamples";
1598 case EvqPatchIn: return "patch in";
1599 case EvqPatchOut: return "patch out";
1600 case EvqTessControlIn: return "in";
1601 case EvqTessControlOut: return "out";
1602 case EvqPerVertexOut: return "out";
1603 case EvqPatchVerticesIn: return "PatchVerticesIn";
1604 case EvqTessLevelOuter: return "TessLevelOuter";
1605 case EvqTessLevelInner: return "TessLevelInner";
1606 case EvqBoundingBox: return "BoundingBox";
1607 case EvqTessEvaluationIn: return "in";
1608 case EvqTessEvaluationOut: return "out";
1609 case EvqTessCoord: return "TessCoord";
1610 case EvqSpecConst: return "const";
1611 case EvqPixelLocalEXT: return "__pixel_localEXT";
1612 default: UNREACHABLE(); return "unknown qualifier";
1613 }
1614 // clang-format on
1615 }
1616
getMatrixPackingString(TLayoutMatrixPacking mpq)1617 inline const char *getMatrixPackingString(TLayoutMatrixPacking mpq)
1618 {
1619 switch (mpq)
1620 {
1621 case EmpUnspecified:
1622 return "mp_unspecified";
1623 case EmpRowMajor:
1624 return "row_major";
1625 case EmpColumnMajor:
1626 return "column_major";
1627 default:
1628 UNREACHABLE();
1629 return "unknown matrix packing";
1630 }
1631 }
1632
getBlockStorageString(TLayoutBlockStorage bsq)1633 inline const char *getBlockStorageString(TLayoutBlockStorage bsq)
1634 {
1635 switch (bsq)
1636 {
1637 case EbsUnspecified:
1638 return "bs_unspecified";
1639 case EbsShared:
1640 return "shared";
1641 case EbsPacked:
1642 return "packed";
1643 case EbsStd140:
1644 return "std140";
1645 case EbsStd430:
1646 return "std430";
1647 default:
1648 UNREACHABLE();
1649 return "unknown block storage";
1650 }
1651 }
1652
getImageInternalFormatString(TLayoutImageInternalFormat iifq)1653 inline const char *getImageInternalFormatString(TLayoutImageInternalFormat iifq)
1654 {
1655 switch (iifq)
1656 {
1657 case EiifRGBA32F:
1658 return "rgba32f";
1659 case EiifRGBA16F:
1660 return "rgba16f";
1661 case EiifR32F:
1662 return "r32f";
1663 case EiifRGBA32UI:
1664 return "rgba32ui";
1665 case EiifRGBA16UI:
1666 return "rgba16ui";
1667 case EiifRGBA8UI:
1668 return "rgba8ui";
1669 case EiifR32UI:
1670 return "r32ui";
1671 case EiifRGBA32I:
1672 return "rgba32i";
1673 case EiifRGBA16I:
1674 return "rgba16i";
1675 case EiifRGBA8I:
1676 return "rgba8i";
1677 case EiifR32I:
1678 return "r32i";
1679 case EiifRGBA8:
1680 return "rgba8";
1681 case EiifRGBA8_SNORM:
1682 return "rgba8_snorm";
1683 default:
1684 UNREACHABLE();
1685 return "unknown internal image format";
1686 }
1687 }
1688
getDepthString(TLayoutDepth depth)1689 inline const char *getDepthString(TLayoutDepth depth)
1690 {
1691 switch (depth)
1692 {
1693 case EdUnspecified:
1694 return "depth_unspecified";
1695 case EdAny:
1696 return "depth_any";
1697 case EdGreater:
1698 return "depth_greater";
1699 case EdLess:
1700 return "depth_less";
1701 case EdUnchanged:
1702 return "depth_unchanged";
1703 default:
1704 UNREACHABLE();
1705 return "unknown depth";
1706 }
1707 }
1708
getYuvCscStandardEXT(const ImmutableString & str)1709 inline TYuvCscStandardEXT getYuvCscStandardEXT(const ImmutableString &str)
1710 {
1711 if (str == "itu_601")
1712 return EycsItu601;
1713 else if (str == "itu_601_full_range")
1714 return EycsItu601FullRange;
1715 else if (str == "itu_709")
1716 return EycsItu709;
1717 return EycsUndefined;
1718 }
1719
getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)1720 inline const char *getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)
1721 {
1722 switch (ycsq)
1723 {
1724 case EycsItu601:
1725 return "itu_601";
1726 case EycsItu601FullRange:
1727 return "itu_601_full_range";
1728 case EycsItu709:
1729 return "itu_709";
1730 default:
1731 UNREACHABLE();
1732 return "unknown color space conversion standard";
1733 }
1734 }
1735
getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)1736 inline const char *getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)
1737 {
1738 switch (primitiveType)
1739 {
1740 case EptPoints:
1741 return "points";
1742 case EptLines:
1743 return "lines";
1744 case EptTriangles:
1745 return "triangles";
1746 case EptLinesAdjacency:
1747 return "lines_adjacency";
1748 case EptTrianglesAdjacency:
1749 return "triangles_adjacency";
1750 case EptLineStrip:
1751 return "line_strip";
1752 case EptTriangleStrip:
1753 return "triangle_strip";
1754 default:
1755 UNREACHABLE();
1756 return "unknown geometry shader primitive type";
1757 }
1758 }
1759
getTessEvaluationShaderTypeString(TLayoutTessEvaluationType type)1760 inline const char *getTessEvaluationShaderTypeString(TLayoutTessEvaluationType type)
1761 {
1762 switch (type)
1763 {
1764 case EtetTriangles:
1765 return "triangles";
1766 case EtetQuads:
1767 return "quads";
1768 case EtetIsolines:
1769 return "isolines";
1770 case EtetEqualSpacing:
1771 return "equal_spacing";
1772 case EtetFractionalEvenSpacing:
1773 return "fractional_even_spacing";
1774 case EtetFractionalOddSpacing:
1775 return "fractional_odd_spacing";
1776 case EtetCw:
1777 return "cw";
1778 case EtetCcw:
1779 return "ccw";
1780 case EtetPointMode:
1781 return "point_mode";
1782 default:
1783 UNREACHABLE();
1784 return "unknown tessellation evaluation shader variable type";
1785 }
1786 }
1787
1788 } // namespace sh
1789
1790 #endif // COMPILER_TRANSLATOR_BASETYPES_H_
1791