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