1 /*
2 * Copyright 2013 Google Inc.
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8 #ifndef GrTypesPriv_DEFINED
9 #define GrTypesPriv_DEFINED
10
11 #include <chrono>
12 #include "GrTypes.h"
13 #include "SkRefCnt.h"
14
15 class GrCaps;
16
17 // The old libstdc++ uses the draft name "monotonic_clock" rather than "steady_clock". This might
18 // not actually be monotonic, depending on how libstdc++ was built. However, this is only currently
19 // used for idle resource purging so it shouldn't cause a correctness problem.
20 #if defined(__GLIBCXX__) && (__GLIBCXX__ < 20130000)
21 using GrStdSteadyClock = std::chrono::monotonic_clock;
22 #else
23 using GrStdSteadyClock = std::chrono::steady_clock;
24 #endif
25
26 /** This enum indicates the type of antialiasing to be performed. */
27 enum class GrAAType : unsigned {
28 /** No antialiasing */
29 kNone,
30 /** Use fragment shader code to compute a fractional pixel coverage. */
31 kCoverage,
32 /** Use normal MSAA. */
33 kMSAA,
34 /**
35 * Use "mixed samples" MSAA such that the stencil buffer is multisampled but the color buffer is
36 * not.
37 */
38 kMixedSamples
39 };
40
GrAATypeIsHW(GrAAType type)41 static inline bool GrAATypeIsHW(GrAAType type) {
42 switch (type) {
43 case GrAAType::kNone:
44 return false;
45 case GrAAType::kCoverage:
46 return false;
47 case GrAAType::kMSAA:
48 return true;
49 case GrAAType::kMixedSamples:
50 return true;
51 }
52 SkFAIL("Unknown AA Type");
53 return false;
54 }
55
56 /** The type of full scene antialiasing supported by a render target. */
57 enum class GrFSAAType {
58 /** No FSAA */
59 kNone,
60 /** Regular MSAA where each attachment has the same sample count. */
61 kUnifiedMSAA,
62 /** One color sample, N stencil samples. */
63 kMixedSamples,
64 };
65
66 /**
67 * Not all drawing code paths support using mixed samples when available and instead use
68 * coverage-based aa.
69 */
70 enum class GrAllowMixedSamples { kNo, kYes };
71
72 GrAAType GrChooseAAType(GrAA, GrFSAAType, GrAllowMixedSamples, const GrCaps&);
73
74 /**
75 * Types of shader-language-specific boxed variables we can create. (Currently only GrGLShaderVars,
76 * but should be applicable to other shader languages.)
77 */
78 enum GrSLType {
79 kVoid_GrSLType,
80 kBool_GrSLType,
81 kInt_GrSLType,
82 kUint_GrSLType,
83 kFloat_GrSLType,
84 kVec2f_GrSLType,
85 kVec3f_GrSLType,
86 kVec4f_GrSLType,
87 kVec2i_GrSLType,
88 kVec3i_GrSLType,
89 kVec4i_GrSLType,
90 kMat22f_GrSLType,
91 kMat33f_GrSLType,
92 kMat44f_GrSLType,
93 kTexture2DSampler_GrSLType,
94 kITexture2DSampler_GrSLType,
95 kTextureExternalSampler_GrSLType,
96 kTexture2DRectSampler_GrSLType,
97 kBufferSampler_GrSLType,
98 kTexture2D_GrSLType,
99 kSampler_GrSLType,
100 kImageStorage2D_GrSLType,
101 kIImageStorage2D_GrSLType,
102 };
103
104 enum GrShaderType {
105 kVertex_GrShaderType,
106 kGeometry_GrShaderType,
107 kFragment_GrShaderType,
108
109 kLastkFragment_GrShaderType = kFragment_GrShaderType
110 };
111 static const int kGrShaderTypeCount = kLastkFragment_GrShaderType + 1;
112
113 enum GrShaderFlags {
114 kNone_GrShaderFlags = 0,
115 kVertex_GrShaderFlag = 1 << kVertex_GrShaderType,
116 kGeometry_GrShaderFlag = 1 << kGeometry_GrShaderType,
117 kFragment_GrShaderFlag = 1 << kFragment_GrShaderType
118 };
119 GR_MAKE_BITFIELD_OPS(GrShaderFlags);
120
121 /**
122 * Precisions of shader language variables. Not all shading languages support precisions or actually
123 * vary the internal precision based on the qualifiers. These currently only apply to float types (
124 * including float vectors and matrices).
125 */
126 enum GrSLPrecision {
127 kLow_GrSLPrecision,
128 kMedium_GrSLPrecision,
129 kHigh_GrSLPrecision,
130
131 // Default precision is a special tag that means "whatever the default for the program/type
132 // combination is". In other words, it maps to the empty string in shader code. There are some
133 // scenarios where kDefault is not allowed (as the default precision for a program, or for
134 // varyings, for example).
135 kDefault_GrSLPrecision,
136
137 // We only consider the "real" precisions here
138 kLast_GrSLPrecision = kHigh_GrSLPrecision,
139 };
140
141 static const int kGrSLPrecisionCount = kLast_GrSLPrecision + 1;
142
143 /** Is the shading language type float (including vectors/matrices)? */
GrSLTypeIsFloatType(GrSLType type)144 static inline bool GrSLTypeIsFloatType(GrSLType type) {
145 switch (type) {
146 case kFloat_GrSLType:
147 case kVec2f_GrSLType:
148 case kVec3f_GrSLType:
149 case kVec4f_GrSLType:
150 case kMat22f_GrSLType:
151 case kMat33f_GrSLType:
152 case kMat44f_GrSLType:
153 return true;
154
155 case kVoid_GrSLType:
156 case kTexture2DSampler_GrSLType:
157 case kITexture2DSampler_GrSLType:
158 case kTextureExternalSampler_GrSLType:
159 case kTexture2DRectSampler_GrSLType:
160 case kBufferSampler_GrSLType:
161 case kBool_GrSLType:
162 case kInt_GrSLType:
163 case kUint_GrSLType:
164 case kVec2i_GrSLType:
165 case kVec3i_GrSLType:
166 case kVec4i_GrSLType:
167 case kTexture2D_GrSLType:
168 case kSampler_GrSLType:
169 case kImageStorage2D_GrSLType:
170 case kIImageStorage2D_GrSLType:
171 return false;
172 }
173 SkFAIL("Unexpected type");
174 return false;
175 }
176
GrSLTypeIs2DCombinedSamplerType(GrSLType type)177 static inline bool GrSLTypeIs2DCombinedSamplerType(GrSLType type) {
178 switch (type) {
179 case kTexture2DSampler_GrSLType:
180 case kITexture2DSampler_GrSLType:
181 case kTextureExternalSampler_GrSLType:
182 case kTexture2DRectSampler_GrSLType:
183 return true;
184
185 case kVoid_GrSLType:
186 case kFloat_GrSLType:
187 case kVec2f_GrSLType:
188 case kVec3f_GrSLType:
189 case kVec4f_GrSLType:
190 case kVec2i_GrSLType:
191 case kVec3i_GrSLType:
192 case kVec4i_GrSLType:
193 case kMat22f_GrSLType:
194 case kMat33f_GrSLType:
195 case kMat44f_GrSLType:
196 case kBufferSampler_GrSLType:
197 case kInt_GrSLType:
198 case kUint_GrSLType:
199 case kBool_GrSLType:
200 case kTexture2D_GrSLType:
201 case kSampler_GrSLType:
202 case kImageStorage2D_GrSLType:
203 case kIImageStorage2D_GrSLType:
204 return false;
205 }
206 SkFAIL("Unexpected type");
207 return false;
208 }
209
GrSLTypeIsCombinedSamplerType(GrSLType type)210 static inline bool GrSLTypeIsCombinedSamplerType(GrSLType type) {
211 switch (type) {
212 case kTexture2DSampler_GrSLType:
213 case kITexture2DSampler_GrSLType:
214 case kTextureExternalSampler_GrSLType:
215 case kTexture2DRectSampler_GrSLType:
216 case kBufferSampler_GrSLType:
217 return true;
218
219 case kVoid_GrSLType:
220 case kFloat_GrSLType:
221 case kVec2f_GrSLType:
222 case kVec3f_GrSLType:
223 case kVec4f_GrSLType:
224 case kVec2i_GrSLType:
225 case kVec3i_GrSLType:
226 case kVec4i_GrSLType:
227 case kMat22f_GrSLType:
228 case kMat33f_GrSLType:
229 case kMat44f_GrSLType:
230 case kInt_GrSLType:
231 case kUint_GrSLType:
232 case kBool_GrSLType:
233 case kTexture2D_GrSLType:
234 case kSampler_GrSLType:
235 case kImageStorage2D_GrSLType:
236 case kIImageStorage2D_GrSLType:
237 return false;
238 }
239 SkFAIL("Unexpected type");
240 return false;
241 }
242
GrSLTypeIsImageStorage(GrSLType type)243 static inline bool GrSLTypeIsImageStorage(GrSLType type) {
244 switch (type) {
245 case kImageStorage2D_GrSLType:
246 case kIImageStorage2D_GrSLType:
247 return true;
248
249 case kVoid_GrSLType:
250 case kFloat_GrSLType:
251 case kVec2f_GrSLType:
252 case kVec3f_GrSLType:
253 case kVec4f_GrSLType:
254 case kVec2i_GrSLType:
255 case kVec3i_GrSLType:
256 case kVec4i_GrSLType:
257 case kMat22f_GrSLType:
258 case kMat33f_GrSLType:
259 case kMat44f_GrSLType:
260 case kInt_GrSLType:
261 case kUint_GrSLType:
262 case kBool_GrSLType:
263 case kTexture2D_GrSLType:
264 case kSampler_GrSLType:
265 case kTexture2DSampler_GrSLType:
266 case kITexture2DSampler_GrSLType:
267 case kTextureExternalSampler_GrSLType:
268 case kTexture2DRectSampler_GrSLType:
269 case kBufferSampler_GrSLType:
270 return false;
271 }
272 SkFAIL("Unexpected type");
273 return false;
274 }
275
GrSLTypeAcceptsPrecision(GrSLType type)276 static inline bool GrSLTypeAcceptsPrecision(GrSLType type) {
277 switch (type) {
278 case kInt_GrSLType:
279 case kUint_GrSLType:
280 case kFloat_GrSLType:
281 case kVec2f_GrSLType:
282 case kVec3f_GrSLType:
283 case kVec4f_GrSLType:
284 case kVec2i_GrSLType:
285 case kVec3i_GrSLType:
286 case kVec4i_GrSLType:
287 case kMat22f_GrSLType:
288 case kMat33f_GrSLType:
289 case kMat44f_GrSLType:
290 case kTexture2DSampler_GrSLType:
291 case kITexture2DSampler_GrSLType:
292 case kTextureExternalSampler_GrSLType:
293 case kTexture2DRectSampler_GrSLType:
294 case kBufferSampler_GrSLType:
295 case kTexture2D_GrSLType:
296 case kSampler_GrSLType:
297 case kImageStorage2D_GrSLType:
298 case kIImageStorage2D_GrSLType:
299 return true;
300
301 case kVoid_GrSLType:
302 case kBool_GrSLType:
303 return false;
304 }
305 SkFAIL("Unexpected type");
306 return false;
307 }
308
309 //////////////////////////////////////////////////////////////////////////////
310
311 /**
312 * Types used to describe format of vertices in arrays.
313 */
314 enum GrVertexAttribType {
315 kFloat_GrVertexAttribType = 0,
316 kVec2f_GrVertexAttribType,
317 kVec3f_GrVertexAttribType,
318 kVec4f_GrVertexAttribType,
319
320 kVec2i_GrVertexAttribType, // vector of 2 32-bit ints
321 kVec3i_GrVertexAttribType, // vector of 3 32-bit ints
322 kVec4i_GrVertexAttribType, // vector of 4 32-bit ints
323
324 kUByte_GrVertexAttribType, // unsigned byte, e.g. coverage
325 kVec4ub_GrVertexAttribType, // vector of 4 unsigned bytes, e.g. colors
326
327 kVec2us_GrVertexAttribType, // vector of 2 shorts, e.g. texture coordinates
328
329 kInt_GrVertexAttribType,
330 kUint_GrVertexAttribType,
331
332 kLast_GrVertexAttribType = kUint_GrVertexAttribType
333 };
334 static const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1;
335
336 /**
337 * Returns the size of the attrib type in bytes.
338 */
GrVertexAttribTypeSize(GrVertexAttribType type)339 static inline size_t GrVertexAttribTypeSize(GrVertexAttribType type) {
340 switch (type) {
341 case kFloat_GrVertexAttribType:
342 return sizeof(float);
343 case kVec2f_GrVertexAttribType:
344 return 2 * sizeof(float);
345 case kVec3f_GrVertexAttribType:
346 return 3 * sizeof(float);
347 case kVec4f_GrVertexAttribType:
348 return 4 * sizeof(float);
349 case kVec2i_GrVertexAttribType:
350 return 2 * sizeof(int32_t);
351 case kVec3i_GrVertexAttribType:
352 return 3 * sizeof(int32_t);
353 case kVec4i_GrVertexAttribType:
354 return 4 * sizeof(int32_t);
355 case kUByte_GrVertexAttribType:
356 return 1 * sizeof(char);
357 case kVec4ub_GrVertexAttribType:
358 return 4 * sizeof(char);
359 case kVec2us_GrVertexAttribType:
360 return 2 * sizeof(int16_t);
361 case kInt_GrVertexAttribType:
362 return sizeof(int32_t);
363 case kUint_GrVertexAttribType:
364 return sizeof(uint32_t);
365 }
366 SkFAIL("Unexpected attribute type");
367 return 0;
368 }
369
370 /**
371 * Is the attrib type integral?
372 */
GrVertexAttribTypeIsIntType(GrVertexAttribType type)373 static inline bool GrVertexAttribTypeIsIntType(GrVertexAttribType type) {
374 switch (type) {
375 case kFloat_GrVertexAttribType:
376 return false;
377 case kVec2f_GrVertexAttribType:
378 return false;
379 case kVec3f_GrVertexAttribType:
380 return false;
381 case kVec4f_GrVertexAttribType:
382 return false;
383 case kVec2i_GrVertexAttribType:
384 return true;
385 case kVec3i_GrVertexAttribType:
386 return true;
387 case kVec4i_GrVertexAttribType:
388 return true;
389 case kUByte_GrVertexAttribType:
390 return false;
391 case kVec4ub_GrVertexAttribType:
392 return false;
393 case kVec2us_GrVertexAttribType:
394 return false;
395 case kInt_GrVertexAttribType:
396 return true;
397 case kUint_GrVertexAttribType:
398 return true;
399 }
400 SkFAIL("Unexpected attribute type");
401 return false;
402 }
403
404 /**
405 * converts a GrVertexAttribType to a GrSLType
406 */
GrVertexAttribTypeToSLType(GrVertexAttribType type)407 static inline GrSLType GrVertexAttribTypeToSLType(GrVertexAttribType type) {
408 switch (type) {
409 case kUByte_GrVertexAttribType:
410 case kFloat_GrVertexAttribType:
411 return kFloat_GrSLType;
412 case kVec2us_GrVertexAttribType:
413 case kVec2f_GrVertexAttribType:
414 return kVec2f_GrSLType;
415 case kVec3f_GrVertexAttribType:
416 return kVec3f_GrSLType;
417 case kVec4ub_GrVertexAttribType:
418 case kVec4f_GrVertexAttribType:
419 return kVec4f_GrSLType;
420 case kVec2i_GrVertexAttribType:
421 return kVec2i_GrSLType;
422 case kVec3i_GrVertexAttribType:
423 return kVec3i_GrSLType;
424 case kVec4i_GrVertexAttribType:
425 return kVec4i_GrSLType;
426 case kInt_GrVertexAttribType:
427 return kInt_GrSLType;
428 case kUint_GrVertexAttribType:
429 return kUint_GrSLType;
430 }
431 SkFAIL("Unsupported type conversion");
432 return kVoid_GrSLType;
433 }
434
435 //////////////////////////////////////////////////////////////////////////////
436
437 enum class GrImageStorageFormat {
438 kRGBA8,
439 kRGBA8i,
440 kRGBA16f,
441 kRGBA32f,
442 };
443
444 /**
445 * Describes types of caching and compiler optimizations allowed for certain variable types
446 * (currently only image storages).
447 **/
448 enum class GrSLMemoryModel {
449 /** No special restrctions on memory accesses or compiler optimizations */
450 kNone,
451 /** Cache coherent across shader invocations */
452 kCoherent,
453 /**
454 * Disallows compiler from eliding loads or stores that appear redundant in a single
455 * invocation. Implies coherent.
456 */
457 kVolatile
458 };
459
460 /**
461 * If kYes then the memory backing the varialble is only accessed via the variable. This is
462 * currently only used with image storages.
463 */
464 enum class GrSLRestrict {
465 kYes,
466 kNo,
467 };
468
469 //////////////////////////////////////////////////////////////////////////////
470
471 /**
472 * We have coverage effects that clip rendering to the edge of some geometric primitive.
473 * This enum specifies how that clipping is performed. Not all factories that take a
474 * GrProcessorEdgeType will succeed with all values and it is up to the caller to check for
475 * a NULL return.
476 */
477 enum GrPrimitiveEdgeType {
478 kFillBW_GrProcessorEdgeType,
479 kFillAA_GrProcessorEdgeType,
480 kInverseFillBW_GrProcessorEdgeType,
481 kInverseFillAA_GrProcessorEdgeType,
482 kHairlineAA_GrProcessorEdgeType,
483
484 kLast_GrProcessorEdgeType = kHairlineAA_GrProcessorEdgeType
485 };
486
487 static const int kGrProcessorEdgeTypeCnt = kLast_GrProcessorEdgeType + 1;
488
GrProcessorEdgeTypeIsFill(const GrPrimitiveEdgeType edgeType)489 static inline bool GrProcessorEdgeTypeIsFill(const GrPrimitiveEdgeType edgeType) {
490 return (kFillAA_GrProcessorEdgeType == edgeType || kFillBW_GrProcessorEdgeType == edgeType);
491 }
492
GrProcessorEdgeTypeIsInverseFill(const GrPrimitiveEdgeType edgeType)493 static inline bool GrProcessorEdgeTypeIsInverseFill(const GrPrimitiveEdgeType edgeType) {
494 return (kInverseFillAA_GrProcessorEdgeType == edgeType ||
495 kInverseFillBW_GrProcessorEdgeType == edgeType);
496 }
497
GrProcessorEdgeTypeIsAA(const GrPrimitiveEdgeType edgeType)498 static inline bool GrProcessorEdgeTypeIsAA(const GrPrimitiveEdgeType edgeType) {
499 return (kFillBW_GrProcessorEdgeType != edgeType &&
500 kInverseFillBW_GrProcessorEdgeType != edgeType);
501 }
502
GrInvertProcessorEdgeType(const GrPrimitiveEdgeType edgeType)503 static inline GrPrimitiveEdgeType GrInvertProcessorEdgeType(const GrPrimitiveEdgeType edgeType) {
504 switch (edgeType) {
505 case kFillBW_GrProcessorEdgeType:
506 return kInverseFillBW_GrProcessorEdgeType;
507 case kFillAA_GrProcessorEdgeType:
508 return kInverseFillAA_GrProcessorEdgeType;
509 case kInverseFillBW_GrProcessorEdgeType:
510 return kFillBW_GrProcessorEdgeType;
511 case kInverseFillAA_GrProcessorEdgeType:
512 return kFillAA_GrProcessorEdgeType;
513 case kHairlineAA_GrProcessorEdgeType:
514 SkFAIL("Hairline fill isn't invertible.");
515 }
516 return kFillAA_GrProcessorEdgeType; // suppress warning.
517 }
518
519 /**
520 * Indicates the type of pending IO operations that can be recorded for gpu resources.
521 */
522 enum GrIOType {
523 kRead_GrIOType,
524 kWrite_GrIOType,
525 kRW_GrIOType
526 };
527
528 /**
529 * Indicates the type of data that a GPU buffer will be used for.
530 */
531 enum GrBufferType {
532 kVertex_GrBufferType,
533 kIndex_GrBufferType,
534 kTexel_GrBufferType,
535 kDrawIndirect_GrBufferType,
536 kXferCpuToGpu_GrBufferType,
537 kXferGpuToCpu_GrBufferType,
538
539 kLast_GrBufferType = kXferGpuToCpu_GrBufferType
540 };
541 static const int kGrBufferTypeCount = kLast_GrBufferType + 1;
542
GrBufferTypeIsVertexOrIndex(GrBufferType type)543 static inline bool GrBufferTypeIsVertexOrIndex(GrBufferType type) {
544 SkASSERT(type >= 0 && type < kGrBufferTypeCount);
545 return type <= kIndex_GrBufferType;
546
547 GR_STATIC_ASSERT(0 == kVertex_GrBufferType);
548 GR_STATIC_ASSERT(1 == kIndex_GrBufferType);
549 }
550
551 /**
552 * Provides a performance hint regarding the frequency at which a data store will be accessed.
553 */
554 enum GrAccessPattern {
555 /** Data store will be respecified repeatedly and used many times. */
556 kDynamic_GrAccessPattern,
557 /** Data store will be specified once and used many times. (Thus disqualified from caching.) */
558 kStatic_GrAccessPattern,
559 /** Data store will be specified once and used at most a few times. (Also can't be cached.) */
560 kStream_GrAccessPattern,
561
562 kLast_GrAccessPattern = kStream_GrAccessPattern
563 };
564
565 // Flags shared between GrRenderTarget and GrRenderTargetProxy
566 enum class GrRenderTargetFlags {
567 kNone = 0,
568
569 // For internal resources:
570 // this is enabled whenever MSAA is enabled and GrCaps reports mixed samples are supported
571 // For wrapped resources:
572 // this is disabled for FBO0
573 // but, otherwise, is enabled whenever MSAA is enabled and GrCaps reports mixed samples
574 // are supported
575 kMixedSampled = 1 << 0,
576
577 // For internal resources:
578 // this is enabled whenever GrCaps reports window rect support
579 // For wrapped resources1
580 // this is disabled for FBO0
581 // but, otherwise, is enabled whenever GrCaps reports window rect support
582 kWindowRectsSupport = 1 << 1
583 };
584 GR_MAKE_BITFIELD_CLASS_OPS(GrRenderTargetFlags)
585
586 #ifdef SK_DEBUG
587 // Takes a pointer to a GrCaps, and will suppress prints if required
588 #define GrCapsDebugf(caps, ...) \
589 if (!(caps)->suppressPrints()) { \
590 SkDebugf(__VA_ARGS__); \
591 }
592 #else
593 #define GrCapsDebugf(caps, ...)
594 #endif
595
596 /**
597 * Specifies if the holder owns the backend, OpenGL or Vulkan, object.
598 */
599 enum class GrBackendObjectOwnership : bool {
600 /** Holder does not destroy the backend object. */
601 kBorrowed = false,
602 /** Holder destroys the backend object. */
603 kOwned = true
604 };
605
sk_sp_address_as_pointer_address(sk_sp<T> const * sp)606 template <typename T> T * const * sk_sp_address_as_pointer_address(sk_sp<T> const * sp) {
607 static_assert(sizeof(T*) == sizeof(sk_sp<T>), "sk_sp not expected size.");
608 return reinterpret_cast<T * const *>(sp);
609 }
610
611 /*
612 * Object for CPU-GPU synchronization
613 */
614 typedef uint64_t GrFence;
615
616 #endif
617