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 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)? */ 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 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 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 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 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 */ 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 */ 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 */ 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 489 static inline bool GrProcessorEdgeTypeIsFill(const GrPrimitiveEdgeType edgeType) { 490 return (kFillAA_GrProcessorEdgeType == edgeType || kFillBW_GrProcessorEdgeType == edgeType); 491 } 492 493 static inline bool GrProcessorEdgeTypeIsInverseFill(const GrPrimitiveEdgeType edgeType) { 494 return (kInverseFillAA_GrProcessorEdgeType == edgeType || 495 kInverseFillBW_GrProcessorEdgeType == edgeType); 496 } 497 498 static inline bool GrProcessorEdgeTypeIsAA(const GrPrimitiveEdgeType edgeType) { 499 return (kFillBW_GrProcessorEdgeType != edgeType && 500 kInverseFillBW_GrProcessorEdgeType != edgeType); 501 } 502 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 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 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