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 _BASICTYPES_INCLUDED_
8 #define _BASICTYPES_INCLUDED_
9
10 #include <assert.h>
11
12 //
13 // Precision qualifiers
14 //
15 enum TPrecision
16 {
17 // These need to be kept sorted
18 EbpUndefined,
19 EbpLow,
20 EbpMedium,
21 EbpHigh
22 };
23
getPrecisionString(TPrecision p)24 inline const char* getPrecisionString(TPrecision p)
25 {
26 switch(p)
27 {
28 case EbpHigh: return "highp"; break;
29 case EbpMedium: return "mediump"; break;
30 case EbpLow: return "lowp"; break;
31 default: return "mediump"; break; // Safest fallback
32 }
33 }
34
35 //
36 // Basic type. Arrays, vectors, etc., are orthogonal to this.
37 //
38 enum TBasicType
39 {
40 EbtVoid,
41 EbtFloat,
42 EbtInt,
43 EbtUInt,
44 EbtBool,
45 EbtGVec4, // non type: represents vec4, ivec4 and uvec4
46 EbtGuardSamplerBegin, // non type: see implementation of IsSampler()
47 EbtSampler2D,
48 EbtSampler3D,
49 EbtSamplerCube,
50 EbtSampler2DArray,
51 EbtSamplerExternalOES, // Only valid if OES_EGL_image_external exists.
52 EbtSampler2DRect, // Only valid if GL_ARB_texture_rectangle exists.
53 EbtISampler2D,
54 EbtISampler3D,
55 EbtISamplerCube,
56 EbtISampler2DArray,
57 EbtUSampler2D,
58 EbtUSampler3D,
59 EbtUSamplerCube,
60 EbtUSampler2DArray,
61 EbtSampler2DShadow,
62 EbtSamplerCubeShadow,
63 EbtSampler2DArrayShadow,
64 EbtGuardSamplerEnd, // non type: see implementation of IsSampler()
65 EbtGSampler2D, // non type: represents sampler2D, isampler2D and usampler2D
66 EbtGSampler3D, // non type: represents sampler3D, isampler3D and usampler3D
67 EbtGSamplerCube, // non type: represents samplerCube, isamplerCube and usamplerCube
68 EbtGSampler2DArray, // non type: represents sampler2DArray, isampler2DArray and usampler2DArray
69 EbtStruct,
70 EbtInterfaceBlock,
71 EbtAddress, // should be deprecated??
72 };
73
74 const char* getBasicString(TBasicType t);
75
IsSampler(TBasicType type)76 inline bool IsSampler(TBasicType type)
77 {
78 return type > EbtGuardSamplerBegin && type < EbtGuardSamplerEnd;
79 }
80
IsIntegerSampler(TBasicType type)81 inline bool IsIntegerSampler(TBasicType type)
82 {
83 switch (type)
84 {
85 case EbtISampler2D:
86 case EbtISampler3D:
87 case EbtISamplerCube:
88 case EbtISampler2DArray:
89 case EbtUSampler2D:
90 case EbtUSampler3D:
91 case EbtUSamplerCube:
92 case EbtUSampler2DArray:
93 return true;
94 case EbtSampler2D:
95 case EbtSampler3D:
96 case EbtSamplerCube:
97 case EbtSamplerExternalOES:
98 case EbtSampler2DRect:
99 case EbtSampler2DArray:
100 case EbtSampler2DShadow:
101 case EbtSamplerCubeShadow:
102 case EbtSampler2DArrayShadow:
103 return false;
104 default:
105 assert(!IsSampler(type));
106 }
107
108 return false;
109 }
110
IsSampler2D(TBasicType type)111 inline bool IsSampler2D(TBasicType type)
112 {
113 switch (type)
114 {
115 case EbtSampler2D:
116 case EbtISampler2D:
117 case EbtUSampler2D:
118 case EbtSampler2DArray:
119 case EbtISampler2DArray:
120 case EbtUSampler2DArray:
121 case EbtSampler2DRect:
122 case EbtSamplerExternalOES:
123 case EbtSampler2DShadow:
124 case EbtSampler2DArrayShadow:
125 return true;
126 case EbtSampler3D:
127 case EbtISampler3D:
128 case EbtUSampler3D:
129 case EbtISamplerCube:
130 case EbtUSamplerCube:
131 case EbtSamplerCube:
132 case EbtSamplerCubeShadow:
133 return false;
134 default:
135 assert(!IsSampler(type));
136 }
137
138 return false;
139 }
140
IsSamplerCube(TBasicType type)141 inline bool IsSamplerCube(TBasicType type)
142 {
143 switch (type)
144 {
145 case EbtSamplerCube:
146 case EbtISamplerCube:
147 case EbtUSamplerCube:
148 case EbtSamplerCubeShadow:
149 return true;
150 case EbtSampler2D:
151 case EbtSampler3D:
152 case EbtSamplerExternalOES:
153 case EbtSampler2DRect:
154 case EbtSampler2DArray:
155 case EbtISampler2D:
156 case EbtISampler3D:
157 case EbtISampler2DArray:
158 case EbtUSampler2D:
159 case EbtUSampler3D:
160 case EbtUSampler2DArray:
161 case EbtSampler2DShadow:
162 case EbtSampler2DArrayShadow:
163 return false;
164 default:
165 assert(!IsSampler(type));
166 }
167
168 return false;
169 }
170
IsSampler3D(TBasicType type)171 inline bool IsSampler3D(TBasicType type)
172 {
173 switch (type)
174 {
175 case EbtSampler3D:
176 case EbtISampler3D:
177 case EbtUSampler3D:
178 return true;
179 case EbtSampler2D:
180 case EbtSamplerCube:
181 case EbtSamplerExternalOES:
182 case EbtSampler2DRect:
183 case EbtSampler2DArray:
184 case EbtISampler2D:
185 case EbtISamplerCube:
186 case EbtISampler2DArray:
187 case EbtUSampler2D:
188 case EbtUSamplerCube:
189 case EbtUSampler2DArray:
190 case EbtSampler2DShadow:
191 case EbtSamplerCubeShadow:
192 case EbtSampler2DArrayShadow:
193 return false;
194 default:
195 assert(!IsSampler(type));
196 }
197
198 return false;
199 }
200
IsSamplerArray(TBasicType type)201 inline bool IsSamplerArray(TBasicType type)
202 {
203 switch (type)
204 {
205 case EbtSampler2DArray:
206 case EbtISampler2DArray:
207 case EbtUSampler2DArray:
208 case EbtSampler2DArrayShadow:
209 return true;
210 case EbtSampler2D:
211 case EbtISampler2D:
212 case EbtUSampler2D:
213 case EbtSampler2DRect:
214 case EbtSamplerExternalOES:
215 case EbtSampler3D:
216 case EbtISampler3D:
217 case EbtUSampler3D:
218 case EbtISamplerCube:
219 case EbtUSamplerCube:
220 case EbtSamplerCube:
221 case EbtSampler2DShadow:
222 case EbtSamplerCubeShadow:
223 return false;
224 default:
225 assert(!IsSampler(type));
226 }
227
228 return false;
229 }
230
IsShadowSampler(TBasicType type)231 inline bool IsShadowSampler(TBasicType type)
232 {
233 switch (type)
234 {
235 case EbtSampler2DShadow:
236 case EbtSamplerCubeShadow:
237 case EbtSampler2DArrayShadow:
238 return true;
239 case EbtISampler2D:
240 case EbtISampler3D:
241 case EbtISamplerCube:
242 case EbtISampler2DArray:
243 case EbtUSampler2D:
244 case EbtUSampler3D:
245 case EbtUSamplerCube:
246 case EbtUSampler2DArray:
247 case EbtSampler2D:
248 case EbtSampler3D:
249 case EbtSamplerCube:
250 case EbtSamplerExternalOES:
251 case EbtSampler2DRect:
252 case EbtSampler2DArray:
253 return false;
254 default:
255 assert(!IsSampler(type));
256 }
257
258 return false;
259 }
260
SupportsPrecision(TBasicType type)261 inline bool SupportsPrecision(TBasicType type)
262 {
263 return type == EbtFloat || type == EbtInt || type == EbtUInt || IsSampler(type);
264 }
265
266 //
267 // Qualifiers and built-ins. These are mainly used to see what can be read
268 // or written, and by the machine dependent translator to know which registers
269 // to allocate variables in. Since built-ins tend to go to different registers
270 // than varying or uniform, it makes sense they are peers, not sub-classes.
271 //
272 enum TQualifier
273 {
274 EvqTemporary, // For temporaries (within a function), read/write
275 EvqGlobal, // For globals read/write
276 EvqInternal, // For internal use, not visible to the user
277 EvqConst, // User defined constants and non-output parameters in functions
278 EvqAttribute, // Readonly
279 EvqVaryingIn, // readonly, fragment shaders only
280 EvqVaryingOut, // vertex shaders only read/write
281 EvqInvariantVaryingIn, // readonly, fragment shaders only
282 EvqInvariantVaryingOut, // vertex shaders only read/write
283 EvqUniform, // Readonly, vertex and fragment
284
285 EvqVertexIn, // Vertex shader input
286 EvqFragmentOut, // Fragment shader output
287 EvqVertexOut, // Vertex shader output
288 EvqFragmentIn, // Fragment shader input
289
290 // parameters
291 EvqIn,
292 EvqOut,
293 EvqInOut,
294 EvqConstReadOnly,
295
296 // built-ins written by vertex shader
297 EvqPosition,
298 EvqPointSize,
299
300 // built-ins read by fragment shader
301 EvqFragCoord,
302 EvqFrontFacing,
303 EvqPointCoord,
304
305 // built-ins written by fragment shader
306 EvqFragColor,
307 EvqFragData,
308 EvqFragDepth,
309
310 // GLSL ES 3.0 vertex output and fragment input
311 EvqSmooth, // Incomplete qualifier, smooth is the default
312 EvqFlat, // Incomplete qualifier
313 EvqSmoothOut = EvqSmooth,
314 EvqFlatOut = EvqFlat,
315 EvqCentroidOut, // Implies smooth
316 EvqSmoothIn,
317 EvqFlatIn,
318 EvqCentroidIn, // Implies smooth
319
320 // end of list
321 EvqLast
322 };
323
324 enum TLayoutMatrixPacking
325 {
326 EmpUnspecified,
327 EmpRowMajor,
328 EmpColumnMajor
329 };
330
331 enum TLayoutBlockStorage
332 {
333 EbsUnspecified,
334 EbsShared,
335 EbsPacked,
336 EbsStd140
337 };
338
339 struct TLayoutQualifier
340 {
341 int location;
342 TLayoutMatrixPacking matrixPacking;
343 TLayoutBlockStorage blockStorage;
344
createTLayoutQualifier345 static TLayoutQualifier create()
346 {
347 TLayoutQualifier layoutQualifier;
348
349 layoutQualifier.location = -1;
350 layoutQualifier.matrixPacking = EmpUnspecified;
351 layoutQualifier.blockStorage = EbsUnspecified;
352
353 return layoutQualifier;
354 }
355
isEmptyTLayoutQualifier356 bool isEmpty() const
357 {
358 return location == -1 && matrixPacking == EmpUnspecified && blockStorage == EbsUnspecified;
359 }
360 };
361
362 //
363 // This is just for debug print out, carried along with the definitions above.
364 //
getQualifierString(TQualifier q)365 inline const char* getQualifierString(TQualifier q)
366 {
367 switch(q)
368 {
369 case EvqTemporary: return "Temporary"; break;
370 case EvqGlobal: return "Global"; break;
371 case EvqConst: return "const"; break;
372 case EvqConstReadOnly: return "const"; break;
373 case EvqAttribute: return "attribute"; break;
374 case EvqVaryingIn: return "varying"; break;
375 case EvqVaryingOut: return "varying"; break;
376 case EvqInvariantVaryingIn: return "invariant varying"; break;
377 case EvqInvariantVaryingOut:return "invariant varying"; break;
378 case EvqUniform: return "uniform"; break;
379 case EvqVertexIn: return "in"; break;
380 case EvqFragmentOut: return "out"; break;
381 case EvqVertexOut: return "out"; break;
382 case EvqFragmentIn: return "in"; break;
383 case EvqIn: return "in"; break;
384 case EvqOut: return "out"; break;
385 case EvqInOut: return "inout"; break;
386 case EvqPosition: return "Position"; break;
387 case EvqPointSize: return "PointSize"; break;
388 case EvqFragCoord: return "FragCoord"; break;
389 case EvqFrontFacing: return "FrontFacing"; break;
390 case EvqFragColor: return "FragColor"; break;
391 case EvqFragData: return "FragData"; break;
392 case EvqFragDepth: return "FragDepth"; break;
393 case EvqSmoothOut: return "smooth out"; break;
394 case EvqCentroidOut: return "centroid out"; break;
395 case EvqFlatOut: return "flat out"; break;
396 case EvqSmoothIn: return "smooth in"; break;
397 case EvqCentroidIn: return "centroid in"; break;
398 case EvqFlatIn: return "flat in"; break;
399 default: return "unknown qualifier";
400 }
401 }
402
getMatrixPackingString(TLayoutMatrixPacking mpq)403 inline const char* getMatrixPackingString(TLayoutMatrixPacking mpq)
404 {
405 switch (mpq)
406 {
407 case EmpUnspecified: return "mp_unspecified";
408 case EmpRowMajor: return "row_major";
409 case EmpColumnMajor: return "column_major";
410 default: return "unknown matrix packing";
411 }
412 }
413
getBlockStorageString(TLayoutBlockStorage bsq)414 inline const char* getBlockStorageString(TLayoutBlockStorage bsq)
415 {
416 switch (bsq)
417 {
418 case EbsUnspecified: return "bs_unspecified";
419 case EbsShared: return "shared";
420 case EbsPacked: return "packed";
421 case EbsStd140: return "std140";
422 default: return "unknown block storage";
423 }
424 }
425
getInterpolationString(TQualifier q)426 inline const char* getInterpolationString(TQualifier q)
427 {
428 switch(q)
429 {
430 case EvqSmoothOut: return "smooth"; break;
431 case EvqCentroidOut: return "centroid"; break;
432 case EvqFlatOut: return "flat"; break;
433 case EvqSmoothIn: return "smooth"; break;
434 case EvqCentroidIn: return "centroid"; break;
435 case EvqFlatIn: return "flat"; break;
436 default: return "unknown interpolation";
437 }
438 }
439
440 #endif // _BASICTYPES_INCLUDED_
441