1 //
2 // Copyright (c) 2002-2013 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 "common/debug.h"
14 #include "GLSLANG/ShaderLang.h"
15
16 namespace sh
17 {
18
19 //
20 // Precision qualifiers
21 //
22 enum TPrecision
23 {
24 // These need to be kept sorted
25 EbpUndefined,
26 EbpLow,
27 EbpMedium,
28 EbpHigh,
29
30 // end of list
31 EbpLast
32 };
33
getPrecisionString(TPrecision p)34 inline const char *getPrecisionString(TPrecision p)
35 {
36 switch (p)
37 {
38 case EbpHigh:
39 return "highp";
40 case EbpMedium:
41 return "mediump";
42 case EbpLow:
43 return "lowp";
44 default:
45 return "mediump"; // Safest fallback
46 }
47 }
48
49 //
50 // Basic type. Arrays, vectors, etc., are orthogonal to this.
51 //
52 enum TBasicType
53 {
54 EbtVoid,
55 EbtFloat,
56 EbtInt,
57 EbtUInt,
58 EbtBool,
59 EbtGVec4, // non type: represents vec4, ivec4, and uvec4
60 EbtGenType, // non type: represents float, vec2, vec3, and vec4
61 EbtGenIType, // non type: represents int, ivec2, ivec3, and ivec4
62 EbtGenUType, // non type: represents uint, uvec2, uvec3, and uvec4
63 EbtGenBType, // non type: represents bool, bvec2, bvec3, and bvec4
64 EbtVec, // non type: represents vec2, vec3, and vec4
65 EbtIVec, // non type: represents ivec2, ivec3, and ivec4
66 EbtUVec, // non type: represents uvec2, uvec3, and uvec4
67 EbtBVec, // non type: represents bvec2, bvec3, and bvec4
68 EbtYuvCscStandardEXT, // Only valid if EXT_YUV_target exists.
69 EbtGuardSamplerBegin, // non type: see implementation of IsSampler()
70 EbtSampler2D,
71 EbtSampler3D,
72 EbtSamplerCube,
73 EbtSampler2DArray,
74 EbtSamplerExternalOES, // Only valid if OES_EGL_image_external exists.
75 EbtSamplerExternal2DY2YEXT, // Only valid if GL_EXT_YUV_target exists.
76 EbtSampler2DRect, // Only valid if GL_ARB_texture_rectangle exists.
77 EbtSampler2DMS,
78 EbtISampler2D,
79 EbtISampler3D,
80 EbtISamplerCube,
81 EbtISampler2DArray,
82 EbtISampler2DMS,
83 EbtUSampler2D,
84 EbtUSampler3D,
85 EbtUSamplerCube,
86 EbtUSampler2DArray,
87 EbtUSampler2DMS,
88 EbtSampler2DShadow,
89 EbtSamplerCubeShadow,
90 EbtSampler2DArrayShadow,
91 EbtGuardSamplerEnd, // non type: see implementation of IsSampler()
92 EbtGSampler2D, // non type: represents sampler2D, isampler2D, and usampler2D
93 EbtGSampler3D, // non type: represents sampler3D, isampler3D, and usampler3D
94 EbtGSamplerCube, // non type: represents samplerCube, isamplerCube, and usamplerCube
95 EbtGSampler2DArray, // non type: represents sampler2DArray, isampler2DArray, and
96 // usampler2DArray
97 EbtGSampler2DMS, // non type: represents sampler2DMS, isampler2DMS, and usampler2DMS
98
99 // images
100 EbtGuardImageBegin,
101 EbtImage2D,
102 EbtIImage2D,
103 EbtUImage2D,
104 EbtImage3D,
105 EbtIImage3D,
106 EbtUImage3D,
107 EbtImage2DArray,
108 EbtIImage2DArray,
109 EbtUImage2DArray,
110 EbtImageCube,
111 EbtIImageCube,
112 EbtUImageCube,
113 EbtGuardImageEnd,
114
115 EbtGuardGImageBegin,
116 EbtGImage2D, // non type: represents image2D, uimage2D, iimage2D
117 EbtGImage3D, // non type: represents image3D, uimage3D, iimage3D
118 EbtGImage2DArray, // non type: represents image2DArray, uimage2DArray, iimage2DArray
119 EbtGImageCube, // non type: represents imageCube, uimageCube, iimageCube
120 EbtGuardGImageEnd,
121
122 EbtStruct,
123 EbtInterfaceBlock,
124 EbtAddress, // should be deprecated??
125
126 EbtAtomicCounter,
127
128 // end of list
129 EbtLast
130 };
131
convertGImageToFloatImage(TBasicType type)132 inline TBasicType convertGImageToFloatImage(TBasicType type)
133 {
134 switch (type)
135 {
136 case EbtGImage2D:
137 return EbtImage2D;
138 case EbtGImage3D:
139 return EbtImage3D;
140 case EbtGImage2DArray:
141 return EbtImage2DArray;
142 case EbtGImageCube:
143 return EbtImageCube;
144 default:
145 UNREACHABLE();
146 }
147 return EbtLast;
148 }
149
convertGImageToIntImage(TBasicType type)150 inline TBasicType convertGImageToIntImage(TBasicType type)
151 {
152 switch (type)
153 {
154 case EbtGImage2D:
155 return EbtIImage2D;
156 case EbtGImage3D:
157 return EbtIImage3D;
158 case EbtGImage2DArray:
159 return EbtIImage2DArray;
160 case EbtGImageCube:
161 return EbtIImageCube;
162 default:
163 UNREACHABLE();
164 }
165 return EbtLast;
166 }
167
convertGImageToUnsignedImage(TBasicType type)168 inline TBasicType convertGImageToUnsignedImage(TBasicType type)
169 {
170 switch (type)
171 {
172 case EbtGImage2D:
173 return EbtUImage2D;
174 case EbtGImage3D:
175 return EbtUImage3D;
176 case EbtGImage2DArray:
177 return EbtUImage2DArray;
178 case EbtGImageCube:
179 return EbtUImageCube;
180 default:
181 UNREACHABLE();
182 }
183 return EbtLast;
184 }
185
186 const char *getBasicString(TBasicType t);
187
IsSampler(TBasicType type)188 inline bool IsSampler(TBasicType type)
189 {
190 return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd;
191 }
192
IsImage(TBasicType type)193 inline bool IsImage(TBasicType type)
194 {
195 return type > EbtGuardImageBegin && type < EbtGuardImageEnd;
196 }
197
IsGImage(TBasicType type)198 inline bool IsGImage(TBasicType type)
199 {
200 return type > EbtGuardGImageBegin && type < EbtGuardGImageEnd;
201 }
202
IsAtomicCounter(TBasicType type)203 inline bool IsAtomicCounter(TBasicType type)
204 {
205 return type == EbtAtomicCounter;
206 }
207
IsOpaqueType(TBasicType type)208 inline bool IsOpaqueType(TBasicType type)
209 {
210 return IsSampler(type) || IsImage(type) || IsAtomicCounter(type);
211 }
212
IsIntegerSampler(TBasicType type)213 inline bool IsIntegerSampler(TBasicType type)
214 {
215 switch (type)
216 {
217 case EbtISampler2D:
218 case EbtISampler3D:
219 case EbtISamplerCube:
220 case EbtISampler2DArray:
221 case EbtISampler2DMS:
222 case EbtUSampler2D:
223 case EbtUSampler3D:
224 case EbtUSamplerCube:
225 case EbtUSampler2DArray:
226 case EbtUSampler2DMS:
227 return true;
228 case EbtSampler2D:
229 case EbtSampler3D:
230 case EbtSamplerCube:
231 case EbtSamplerExternalOES:
232 case EbtSamplerExternal2DY2YEXT:
233 case EbtSampler2DRect:
234 case EbtSampler2DArray:
235 case EbtSampler2DShadow:
236 case EbtSamplerCubeShadow:
237 case EbtSampler2DArrayShadow:
238 case EbtSampler2DMS:
239 return false;
240 default:
241 assert(!IsSampler(type));
242 }
243
244 return false;
245 }
246
IsSampler2DMS(TBasicType type)247 inline bool IsSampler2DMS(TBasicType type)
248 {
249 switch (type)
250 {
251 case EbtSampler2DMS:
252 case EbtISampler2DMS:
253 case EbtUSampler2DMS:
254 return true;
255 default:
256 return false;
257 }
258 }
259
IsFloatImage(TBasicType type)260 inline bool IsFloatImage(TBasicType type)
261 {
262 switch (type)
263 {
264 case EbtImage2D:
265 case EbtImage3D:
266 case EbtImage2DArray:
267 case EbtImageCube:
268 return true;
269 default:
270 break;
271 }
272
273 return false;
274 }
275
IsIntegerImage(TBasicType type)276 inline bool IsIntegerImage(TBasicType type)
277 {
278
279 switch (type)
280 {
281 case EbtIImage2D:
282 case EbtIImage3D:
283 case EbtIImage2DArray:
284 case EbtIImageCube:
285 return true;
286 default:
287 break;
288 }
289
290 return false;
291 }
292
IsUnsignedImage(TBasicType type)293 inline bool IsUnsignedImage(TBasicType type)
294 {
295
296 switch (type)
297 {
298 case EbtUImage2D:
299 case EbtUImage3D:
300 case EbtUImage2DArray:
301 case EbtUImageCube:
302 return true;
303 default:
304 break;
305 }
306
307 return false;
308 }
309
IsSampler2D(TBasicType type)310 inline bool IsSampler2D(TBasicType type)
311 {
312 switch (type)
313 {
314 case EbtSampler2D:
315 case EbtISampler2D:
316 case EbtUSampler2D:
317 case EbtSampler2DArray:
318 case EbtISampler2DArray:
319 case EbtUSampler2DArray:
320 case EbtSampler2DRect:
321 case EbtSamplerExternalOES:
322 case EbtSamplerExternal2DY2YEXT:
323 case EbtSampler2DShadow:
324 case EbtSampler2DArrayShadow:
325 case EbtSampler2DMS:
326 case EbtISampler2DMS:
327 case EbtUSampler2DMS:
328 return true;
329 case EbtSampler3D:
330 case EbtISampler3D:
331 case EbtUSampler3D:
332 case EbtISamplerCube:
333 case EbtUSamplerCube:
334 case EbtSamplerCube:
335 case EbtSamplerCubeShadow:
336 return false;
337 default:
338 assert(!IsSampler(type));
339 }
340
341 return false;
342 }
343
IsSamplerCube(TBasicType type)344 inline bool IsSamplerCube(TBasicType type)
345 {
346 switch (type)
347 {
348 case EbtSamplerCube:
349 case EbtISamplerCube:
350 case EbtUSamplerCube:
351 case EbtSamplerCubeShadow:
352 return true;
353 case EbtSampler2D:
354 case EbtSampler3D:
355 case EbtSamplerExternalOES:
356 case EbtSamplerExternal2DY2YEXT:
357 case EbtSampler2DRect:
358 case EbtSampler2DArray:
359 case EbtSampler2DMS:
360 case EbtISampler2D:
361 case EbtISampler3D:
362 case EbtISampler2DArray:
363 case EbtISampler2DMS:
364 case EbtUSampler2D:
365 case EbtUSampler3D:
366 case EbtUSampler2DArray:
367 case EbtUSampler2DMS:
368 case EbtSampler2DShadow:
369 case EbtSampler2DArrayShadow:
370 return false;
371 default:
372 assert(!IsSampler(type));
373 }
374
375 return false;
376 }
377
IsSampler3D(TBasicType type)378 inline bool IsSampler3D(TBasicType type)
379 {
380 switch (type)
381 {
382 case EbtSampler3D:
383 case EbtISampler3D:
384 case EbtUSampler3D:
385 return true;
386 case EbtSampler2D:
387 case EbtSamplerCube:
388 case EbtSamplerExternalOES:
389 case EbtSamplerExternal2DY2YEXT:
390 case EbtSampler2DRect:
391 case EbtSampler2DArray:
392 case EbtSampler2DMS:
393 case EbtISampler2D:
394 case EbtISamplerCube:
395 case EbtISampler2DArray:
396 case EbtISampler2DMS:
397 case EbtUSampler2D:
398 case EbtUSamplerCube:
399 case EbtUSampler2DArray:
400 case EbtUSampler2DMS:
401 case EbtSampler2DShadow:
402 case EbtSamplerCubeShadow:
403 case EbtSampler2DArrayShadow:
404 return false;
405 default:
406 assert(!IsSampler(type));
407 }
408
409 return false;
410 }
411
IsSamplerArray(TBasicType type)412 inline bool IsSamplerArray(TBasicType type)
413 {
414 switch (type)
415 {
416 case EbtSampler2DArray:
417 case EbtISampler2DArray:
418 case EbtUSampler2DArray:
419 case EbtSampler2DArrayShadow:
420 return true;
421 case EbtSampler2D:
422 case EbtISampler2D:
423 case EbtUSampler2D:
424 case EbtSampler2DRect:
425 case EbtSamplerExternalOES:
426 case EbtSamplerExternal2DY2YEXT:
427 case EbtSampler3D:
428 case EbtISampler3D:
429 case EbtUSampler3D:
430 case EbtISamplerCube:
431 case EbtUSamplerCube:
432 case EbtSamplerCube:
433 case EbtSampler2DShadow:
434 case EbtSamplerCubeShadow:
435 case EbtSampler2DMS:
436 case EbtISampler2DMS:
437 case EbtUSampler2DMS:
438 return false;
439 default:
440 assert(!IsSampler(type));
441 }
442
443 return false;
444 }
445
IsShadowSampler(TBasicType type)446 inline bool IsShadowSampler(TBasicType type)
447 {
448 switch (type)
449 {
450 case EbtSampler2DShadow:
451 case EbtSamplerCubeShadow:
452 case EbtSampler2DArrayShadow:
453 return true;
454 case EbtISampler2D:
455 case EbtISampler3D:
456 case EbtISamplerCube:
457 case EbtISampler2DArray:
458 case EbtISampler2DMS:
459 case EbtUSampler2D:
460 case EbtUSampler3D:
461 case EbtUSamplerCube:
462 case EbtUSampler2DArray:
463 case EbtUSampler2DMS:
464 case EbtSampler2D:
465 case EbtSampler3D:
466 case EbtSamplerCube:
467 case EbtSamplerExternalOES:
468 case EbtSamplerExternal2DY2YEXT:
469 case EbtSampler2DRect:
470 case EbtSampler2DArray:
471 case EbtSampler2DMS:
472 return false;
473 default:
474 assert(!IsSampler(type));
475 }
476
477 return false;
478 }
479
IsImage2D(TBasicType type)480 inline bool IsImage2D(TBasicType type)
481 {
482 switch (type)
483 {
484 case EbtImage2D:
485 case EbtIImage2D:
486 case EbtUImage2D:
487 return true;
488 case EbtImage3D:
489 case EbtIImage3D:
490 case EbtUImage3D:
491 case EbtImage2DArray:
492 case EbtIImage2DArray:
493 case EbtUImage2DArray:
494 case EbtImageCube:
495 case EbtIImageCube:
496 case EbtUImageCube:
497 return false;
498 default:
499 assert(!IsImage(type));
500 }
501
502 return false;
503 }
504
IsImage3D(TBasicType type)505 inline bool IsImage3D(TBasicType type)
506 {
507 switch (type)
508 {
509 case EbtImage3D:
510 case EbtIImage3D:
511 case EbtUImage3D:
512 return true;
513 case EbtImage2D:
514 case EbtIImage2D:
515 case EbtUImage2D:
516 case EbtImage2DArray:
517 case EbtIImage2DArray:
518 case EbtUImage2DArray:
519 case EbtImageCube:
520 case EbtIImageCube:
521 case EbtUImageCube:
522 return false;
523 default:
524 assert(!IsImage(type));
525 }
526
527 return false;
528 }
529
IsImage2DArray(TBasicType type)530 inline bool IsImage2DArray(TBasicType type)
531 {
532 switch (type)
533 {
534 case EbtImage2DArray:
535 case EbtIImage2DArray:
536 case EbtUImage2DArray:
537 return true;
538 case EbtImage2D:
539 case EbtIImage2D:
540 case EbtUImage2D:
541 case EbtImage3D:
542 case EbtIImage3D:
543 case EbtUImage3D:
544 case EbtImageCube:
545 case EbtIImageCube:
546 case EbtUImageCube:
547 return false;
548 default:
549 assert(!IsImage(type));
550 }
551
552 return false;
553 }
554
IsImageCube(TBasicType type)555 inline bool IsImageCube(TBasicType type)
556 {
557 switch (type)
558 {
559 case EbtImageCube:
560 case EbtIImageCube:
561 case EbtUImageCube:
562 return true;
563 case EbtImage2D:
564 case EbtIImage2D:
565 case EbtUImage2D:
566 case EbtImage3D:
567 case EbtIImage3D:
568 case EbtUImage3D:
569 case EbtImage2DArray:
570 case EbtIImage2DArray:
571 case EbtUImage2DArray:
572 return false;
573 default:
574 assert(!IsImage(type));
575 }
576
577 return false;
578 }
579
IsInteger(TBasicType type)580 inline bool IsInteger(TBasicType type)
581 {
582 return type == EbtInt || type == EbtUInt;
583 }
584
SupportsPrecision(TBasicType type)585 inline bool SupportsPrecision(TBasicType type)
586 {
587 return type == EbtFloat || type == EbtInt || type == EbtUInt || IsOpaqueType(type);
588 }
589
590 //
591 // Qualifiers and built-ins. These are mainly used to see what can be read
592 // or written, and by the machine dependent translator to know which registers
593 // to allocate variables in. Since built-ins tend to go to different registers
594 // than varying or uniform, it makes sense they are peers, not sub-classes.
595 //
596 enum TQualifier
597 {
598 EvqTemporary, // For temporaries (within a function), read/write
599 EvqGlobal, // For globals read/write
600 EvqConst, // User defined constants and non-output parameters in functions
601 EvqAttribute, // Readonly
602 EvqVaryingIn, // readonly, fragment shaders only
603 EvqVaryingOut, // vertex shaders only read/write
604 EvqUniform, // Readonly, vertex and fragment
605 EvqBuffer, // read/write, vertex, fragment and compute shader
606
607 EvqVertexIn, // Vertex shader input
608 EvqFragmentOut, // Fragment shader output
609 EvqVertexOut, // Vertex shader output
610 EvqFragmentIn, // Fragment shader input
611
612 // parameters
613 EvqIn,
614 EvqOut,
615 EvqInOut,
616 EvqConstReadOnly,
617
618 // built-ins read by vertex shader
619 EvqInstanceID,
620 EvqVertexID,
621
622 // built-ins written by vertex shader
623 EvqPosition,
624 EvqPointSize,
625
626 // built-ins read by fragment shader
627 EvqFragCoord,
628 EvqFrontFacing,
629 EvqPointCoord,
630
631 // built-ins written by fragment shader
632 EvqFragColor,
633 EvqFragData,
634
635 EvqFragDepth, // gl_FragDepth for ESSL300.
636 EvqFragDepthEXT, // gl_FragDepthEXT for ESSL100, EXT_frag_depth.
637
638 EvqSecondaryFragColorEXT, // EXT_blend_func_extended
639 EvqSecondaryFragDataEXT, // EXT_blend_func_extended
640
641 EvqViewIDOVR, // OVR_multiview
642 EvqViewportIndex, // gl_ViewportIndex
643
644 // built-ins written by the shader_framebuffer_fetch extension(s)
645 EvqLastFragColor,
646 EvqLastFragData,
647
648 // GLSL ES 3.0 vertex output and fragment input
649 EvqSmooth, // Incomplete qualifier, smooth is the default
650 EvqFlat, // Incomplete qualifier
651 EvqCentroid, // Incomplete qualifier
652 EvqSmoothOut,
653 EvqFlatOut,
654 EvqCentroidOut, // Implies smooth
655 EvqSmoothIn,
656 EvqFlatIn,
657 EvqCentroidIn, // Implies smooth
658
659 // GLSL ES 3.1 compute shader special variables
660 EvqShared,
661 EvqComputeIn,
662 EvqNumWorkGroups,
663 EvqWorkGroupSize,
664 EvqWorkGroupID,
665 EvqLocalInvocationID,
666 EvqGlobalInvocationID,
667 EvqLocalInvocationIndex,
668
669 // GLSL ES 3.1 memory qualifiers
670 EvqReadOnly,
671 EvqWriteOnly,
672 EvqCoherent,
673 EvqRestrict,
674 EvqVolatile,
675
676 // GLSL ES 3.1 extension OES_geometry_shader qualifiers
677 EvqGeometryIn,
678 EvqGeometryOut,
679 EvqPerVertexIn, // gl_in
680 EvqPrimitiveIDIn, // gl_PrimitiveIDIn
681 EvqInvocationID, // gl_InvocationID
682 EvqPrimitiveID, // gl_PrimitiveID
683 EvqLayer, // gl_Layer
684
685 // end of list
686 EvqLast
687 };
688
IsQualifierUnspecified(TQualifier qualifier)689 inline bool IsQualifierUnspecified(TQualifier qualifier)
690 {
691 return (qualifier == EvqTemporary || qualifier == EvqGlobal);
692 }
693
694 enum TLayoutImageInternalFormat
695 {
696 EiifUnspecified,
697 EiifRGBA32F,
698 EiifRGBA16F,
699 EiifR32F,
700 EiifRGBA32UI,
701 EiifRGBA16UI,
702 EiifRGBA8UI,
703 EiifR32UI,
704 EiifRGBA32I,
705 EiifRGBA16I,
706 EiifRGBA8I,
707 EiifR32I,
708 EiifRGBA8,
709 EiifRGBA8_SNORM
710 };
711
712 enum TLayoutMatrixPacking
713 {
714 EmpUnspecified,
715 EmpRowMajor,
716 EmpColumnMajor
717 };
718
719 enum TLayoutBlockStorage
720 {
721 EbsUnspecified,
722 EbsShared,
723 EbsPacked,
724 EbsStd140,
725 EbsStd430
726 };
727
728 enum TYuvCscStandardEXT
729 {
730 EycsUndefined,
731 EycsItu601,
732 EycsItu601FullRange,
733 EycsItu709
734 };
735
736 enum TLayoutPrimitiveType
737 {
738 EptUndefined,
739 EptPoints,
740 EptLines,
741 EptLinesAdjacency,
742 EptTriangles,
743 EptTrianglesAdjacency,
744 EptLineStrip,
745 EptTriangleStrip
746 };
747
748 struct TLayoutQualifier
749 {
750 // Must have a trivial default constructor since it is used in YYSTYPE.
751 TLayoutQualifier() = default;
752
CreateTLayoutQualifier753 constexpr static TLayoutQualifier Create() { return TLayoutQualifier(0); }
754
isEmptyTLayoutQualifier755 bool isEmpty() const
756 {
757 return location == -1 && binding == -1 && offset == -1 && numViews == -1 && yuv == false &&
758 matrixPacking == EmpUnspecified && blockStorage == EbsUnspecified &&
759 !localSize.isAnyValueSet() && imageInternalFormat == EiifUnspecified &&
760 primitiveType == EptUndefined && invocations == 0 && maxVertices == -1;
761 }
762
isCombinationValidTLayoutQualifier763 bool isCombinationValid() const
764 {
765 bool workSizeSpecified = localSize.isAnyValueSet();
766 bool numViewsSet = (numViews != -1);
767 bool geometryShaderSpecified =
768 (primitiveType != EptUndefined) || (invocations != 0) || (maxVertices != -1);
769 bool otherLayoutQualifiersSpecified =
770 (location != -1 || binding != -1 || matrixPacking != EmpUnspecified ||
771 blockStorage != EbsUnspecified || imageInternalFormat != EiifUnspecified);
772
773 // we can have either the work group size specified, or number of views,
774 // or yuv layout qualifier, or the other layout qualifiers.
775 return (workSizeSpecified ? 1 : 0) + (numViewsSet ? 1 : 0) + (yuv ? 1 : 0) +
776 (otherLayoutQualifiersSpecified ? 1 : 0) + (geometryShaderSpecified ? 1 : 0) <=
777 1;
778 }
779
isLocalSizeEqualTLayoutQualifier780 bool isLocalSizeEqual(const sh::WorkGroupSize &localSizeIn) const
781 {
782 return localSize.isWorkGroupSizeMatching(localSizeIn);
783 }
784
785 int location;
786 unsigned int locationsSpecified;
787 TLayoutMatrixPacking matrixPacking;
788 TLayoutBlockStorage blockStorage;
789
790 // Compute shader layout qualifiers.
791 sh::WorkGroupSize localSize;
792
793 int binding;
794 int offset;
795
796 // Image format layout qualifier
797 TLayoutImageInternalFormat imageInternalFormat;
798
799 // OVR_multiview num_views.
800 int numViews;
801
802 // EXT_YUV_target yuv layout qualifier.
803 bool yuv;
804
805 // OES_geometry_shader layout qualifiers.
806 TLayoutPrimitiveType primitiveType;
807 int invocations;
808 int maxVertices;
809
810 private:
TLayoutQualifierTLayoutQualifier811 explicit constexpr TLayoutQualifier(int /*placeholder*/)
812 : location(-1),
813 locationsSpecified(0),
814 matrixPacking(EmpUnspecified),
815 blockStorage(EbsUnspecified),
816 localSize(-1),
817 binding(-1),
818 offset(-1),
819 imageInternalFormat(EiifUnspecified),
820 numViews(-1),
821 yuv(false),
822 primitiveType(EptUndefined),
823 invocations(0),
824 maxVertices(-1)
825 {
826 }
827 };
828
829 struct TMemoryQualifier
830 {
831 // Must have a trivial default constructor since it is used in YYSTYPE.
832 TMemoryQualifier() = default;
833
isEmptyTMemoryQualifier834 bool isEmpty() const
835 {
836 return !readonly && !writeonly && !coherent && !restrictQualifier && !volatileQualifier;
837 }
838
CreateTMemoryQualifier839 constexpr static TMemoryQualifier Create() { return TMemoryQualifier(0); }
840
841 // GLSL ES 3.10 Revision 4, 4.9 Memory Access Qualifiers
842 // An image can be qualified as both readonly and writeonly. It still can be can be used with
843 // imageSize().
844 bool readonly;
845 bool writeonly;
846 bool coherent;
847
848 // restrict and volatile are reserved keywords in C/C++
849 bool restrictQualifier;
850 bool volatileQualifier;
851
852 private:
TMemoryQualifierTMemoryQualifier853 explicit constexpr TMemoryQualifier(int /*placeholder*/)
854 : readonly(false),
855 writeonly(false),
856 coherent(false),
857 restrictQualifier(false),
858 volatileQualifier(false)
859 {
860 }
861 };
862
getWorkGroupSizeString(size_t dimension)863 inline const char *getWorkGroupSizeString(size_t dimension)
864 {
865 switch (dimension)
866 {
867 case 0u:
868 return "local_size_x";
869 case 1u:
870 return "local_size_y";
871 case 2u:
872 return "local_size_z";
873 default:
874 UNREACHABLE();
875 return "dimension out of bounds";
876 }
877 }
878
879 //
880 // This is just for debug and error message print out, carried along with the definitions above.
881 //
getQualifierString(TQualifier q)882 inline const char *getQualifierString(TQualifier q)
883 {
884 // clang-format off
885 switch(q)
886 {
887 case EvqTemporary: return "Temporary";
888 case EvqGlobal: return "Global";
889 case EvqConst: return "const";
890 case EvqAttribute: return "attribute";
891 case EvqVaryingIn: return "varying";
892 case EvqVaryingOut: return "varying";
893 case EvqUniform: return "uniform";
894 case EvqBuffer: return "buffer";
895 case EvqVertexIn: return "in";
896 case EvqFragmentOut: return "out";
897 case EvqVertexOut: return "out";
898 case EvqFragmentIn: return "in";
899 case EvqIn: return "in";
900 case EvqOut: return "out";
901 case EvqInOut: return "inout";
902 case EvqConstReadOnly: return "const";
903 case EvqInstanceID: return "InstanceID";
904 case EvqVertexID: return "VertexID";
905 case EvqPosition: return "Position";
906 case EvqPointSize: return "PointSize";
907 case EvqFragCoord: return "FragCoord";
908 case EvqFrontFacing: return "FrontFacing";
909 case EvqPointCoord: return "PointCoord";
910 case EvqFragColor: return "FragColor";
911 case EvqFragData: return "FragData";
912 case EvqFragDepthEXT: return "FragDepth";
913 case EvqFragDepth: return "FragDepth";
914 case EvqSecondaryFragColorEXT: return "SecondaryFragColorEXT";
915 case EvqSecondaryFragDataEXT: return "SecondaryFragDataEXT";
916 case EvqViewIDOVR: return "ViewIDOVR";
917 case EvqViewportIndex: return "ViewportIndex";
918 case EvqLayer: return "Layer";
919 case EvqLastFragColor: return "LastFragColor";
920 case EvqLastFragData: return "LastFragData";
921 case EvqSmoothOut: return "smooth out";
922 case EvqCentroidOut: return "smooth centroid out";
923 case EvqFlatOut: return "flat out";
924 case EvqSmoothIn: return "smooth in";
925 case EvqFlatIn: return "flat in";
926 case EvqCentroidIn: return "smooth centroid in";
927 case EvqCentroid: return "centroid";
928 case EvqFlat: return "flat";
929 case EvqSmooth: return "smooth";
930 case EvqShared: return "shared";
931 case EvqComputeIn: return "in";
932 case EvqNumWorkGroups: return "NumWorkGroups";
933 case EvqWorkGroupSize: return "WorkGroupSize";
934 case EvqWorkGroupID: return "WorkGroupID";
935 case EvqLocalInvocationID: return "LocalInvocationID";
936 case EvqGlobalInvocationID: return "GlobalInvocationID";
937 case EvqLocalInvocationIndex: return "LocalInvocationIndex";
938 case EvqReadOnly: return "readonly";
939 case EvqWriteOnly: return "writeonly";
940 case EvqGeometryIn: return "in";
941 case EvqGeometryOut: return "out";
942 case EvqPerVertexIn: return "gl_in";
943 default: UNREACHABLE(); return "unknown qualifier";
944 }
945 // clang-format on
946 }
947
getMatrixPackingString(TLayoutMatrixPacking mpq)948 inline const char *getMatrixPackingString(TLayoutMatrixPacking mpq)
949 {
950 switch (mpq)
951 {
952 case EmpUnspecified:
953 return "mp_unspecified";
954 case EmpRowMajor:
955 return "row_major";
956 case EmpColumnMajor:
957 return "column_major";
958 default:
959 UNREACHABLE();
960 return "unknown matrix packing";
961 }
962 }
963
getBlockStorageString(TLayoutBlockStorage bsq)964 inline const char *getBlockStorageString(TLayoutBlockStorage bsq)
965 {
966 switch (bsq)
967 {
968 case EbsUnspecified:
969 return "bs_unspecified";
970 case EbsShared:
971 return "shared";
972 case EbsPacked:
973 return "packed";
974 case EbsStd140:
975 return "std140";
976 case EbsStd430:
977 return "std430";
978 default:
979 UNREACHABLE();
980 return "unknown block storage";
981 }
982 }
983
getImageInternalFormatString(TLayoutImageInternalFormat iifq)984 inline const char *getImageInternalFormatString(TLayoutImageInternalFormat iifq)
985 {
986 switch (iifq)
987 {
988 case EiifRGBA32F:
989 return "rgba32f";
990 case EiifRGBA16F:
991 return "rgba16f";
992 case EiifR32F:
993 return "r32f";
994 case EiifRGBA32UI:
995 return "rgba32ui";
996 case EiifRGBA16UI:
997 return "rgba16ui";
998 case EiifRGBA8UI:
999 return "rgba8ui";
1000 case EiifR32UI:
1001 return "r32ui";
1002 case EiifRGBA32I:
1003 return "rgba32i";
1004 case EiifRGBA16I:
1005 return "rgba16i";
1006 case EiifRGBA8I:
1007 return "rgba8i";
1008 case EiifR32I:
1009 return "r32i";
1010 case EiifRGBA8:
1011 return "rgba8";
1012 case EiifRGBA8_SNORM:
1013 return "rgba8_snorm";
1014 default:
1015 UNREACHABLE();
1016 return "unknown internal image format";
1017 }
1018 }
1019
getYuvCscStandardEXT(const std::string & str)1020 inline TYuvCscStandardEXT getYuvCscStandardEXT(const std::string &str)
1021 {
1022 if (str == "itu_601")
1023 return EycsItu601;
1024 else if (str == "itu_601_full_range")
1025 return EycsItu601FullRange;
1026 else if (str == "itu_709")
1027 return EycsItu709;
1028 return EycsUndefined;
1029 }
1030
getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)1031 inline const char *getYuvCscStandardEXTString(TYuvCscStandardEXT ycsq)
1032 {
1033 switch (ycsq)
1034 {
1035 case EycsItu601:
1036 return "itu_601";
1037 case EycsItu601FullRange:
1038 return "itu_601_full_range";
1039 case EycsItu709:
1040 return "itu_709";
1041 default:
1042 UNREACHABLE();
1043 return "unknown color space conversion standard";
1044 }
1045 }
1046
getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)1047 inline const char *getGeometryShaderPrimitiveTypeString(TLayoutPrimitiveType primitiveType)
1048 {
1049 switch (primitiveType)
1050 {
1051 case EptPoints:
1052 return "points";
1053 case EptLines:
1054 return "lines";
1055 case EptTriangles:
1056 return "triangles";
1057 case EptLinesAdjacency:
1058 return "lines_adjacency";
1059 case EptTrianglesAdjacency:
1060 return "triangles_adjacency";
1061 case EptLineStrip:
1062 return "line_strip";
1063 case EptTriangleStrip:
1064 return "triangle_strip";
1065 default:
1066 UNREACHABLE();
1067 return "unknown geometry shader primitive type";
1068 }
1069 }
1070
1071 } // namespace sh
1072
1073 #endif // COMPILER_TRANSLATOR_BASETYPES_H_
1074