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 "GrSharedEnums.h" 13 #include "GrTypes.h" 14 #include "SkCanvas.h" 15 #include "SkImageInfo.h" 16 #include "SkImageInfoPriv.h" 17 #include "SkRefCnt.h" 18 #include "SkWeakRefCnt.h" 19 20 class GrCaps; 21 22 // The old libstdc++ uses the draft name "monotonic_clock" rather than "steady_clock". This might 23 // not actually be monotonic, depending on how libstdc++ was built. However, this is only currently 24 // used for idle resource purging so it shouldn't cause a correctness problem. 25 #if defined(__GLIBCXX__) && (__GLIBCXX__ < 20130000) 26 using GrStdSteadyClock = std::chrono::monotonic_clock; 27 #else 28 using GrStdSteadyClock = std::chrono::steady_clock; 29 #endif 30 31 /** 32 * Pixel configurations. This type conflates texture formats, CPU pixel formats, and 33 * premultipliedness. We are moving away from it towards SkColorType and backend API (GL, Vulkan) 34 * texture formats in the public API. Right now this mostly refers to texture formats as we're 35 * migrating. 36 */ 37 enum GrPixelConfig { 38 kUnknown_GrPixelConfig, 39 kAlpha_8_GrPixelConfig, 40 kAlpha_8_as_Alpha_GrPixelConfig, 41 kAlpha_8_as_Red_GrPixelConfig, 42 kGray_8_GrPixelConfig, 43 kGray_8_as_Lum_GrPixelConfig, 44 kGray_8_as_Red_GrPixelConfig, 45 kRGB_565_GrPixelConfig, 46 kRGBA_4444_GrPixelConfig, 47 kRGBA_8888_GrPixelConfig, 48 kRGB_888_GrPixelConfig, 49 kRGB_888X_GrPixelConfig, 50 kRG_88_GrPixelConfig, 51 kBGRA_8888_GrPixelConfig, 52 kSRGBA_8888_GrPixelConfig, 53 kSBGRA_8888_GrPixelConfig, 54 kRGBA_1010102_GrPixelConfig, 55 kRGBA_float_GrPixelConfig, 56 kRG_float_GrPixelConfig, 57 kAlpha_half_GrPixelConfig, 58 kAlpha_half_as_Red_GrPixelConfig, 59 kRGBA_half_GrPixelConfig, 60 kRGBA_half_Clamped_GrPixelConfig, 61 kRGB_ETC1_GrPixelConfig, 62 63 kLast_GrPixelConfig = kRGB_ETC1_GrPixelConfig 64 }; 65 static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1; 66 67 // Aliases for pixel configs that match skia's byte order. 68 #ifndef SK_CPU_LENDIAN 69 #error "Skia gpu currently assumes little endian" 70 #endif 71 #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) 72 static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig; 73 #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A) 74 static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig; 75 #else 76 #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format." 77 #endif 78 79 /** 80 * Geometric primitives used for drawing. 81 */ 82 enum class GrPrimitiveType { 83 kTriangles, 84 kTriangleStrip, 85 kPoints, 86 kLines, // 1 pix wide only 87 kLineStrip, // 1 pix wide only 88 kLinesAdjacency // requires geometry shader support. 89 }; 90 static constexpr int kNumGrPrimitiveTypes = (int)GrPrimitiveType::kLinesAdjacency + 1; 91 92 static constexpr bool GrIsPrimTypeLines(GrPrimitiveType type) { 93 return GrPrimitiveType::kLines == type || 94 GrPrimitiveType::kLineStrip == type || 95 GrPrimitiveType::kLinesAdjacency == type; 96 } 97 98 static constexpr bool GrIsPrimTypeTris(GrPrimitiveType type) { 99 return GrPrimitiveType::kTriangles == type || GrPrimitiveType::kTriangleStrip == type; 100 } 101 102 static constexpr bool GrPrimTypeRequiresGeometryShaderSupport(GrPrimitiveType type) { 103 return GrPrimitiveType::kLinesAdjacency == type; 104 } 105 106 enum class GrPrimitiveRestart : bool { 107 kNo = false, 108 kYes = true 109 }; 110 111 /** 112 * Formats for masks, used by the font cache. Important that these are 0-based. 113 */ 114 enum GrMaskFormat { 115 kA8_GrMaskFormat, //!< 1-byte per pixel 116 kA565_GrMaskFormat, //!< 2-bytes per pixel, RGB represent 3-channel LCD coverage 117 kARGB_GrMaskFormat, //!< 4-bytes per pixel, color format 118 119 kLast_GrMaskFormat = kARGB_GrMaskFormat 120 }; 121 static const int kMaskFormatCount = kLast_GrMaskFormat + 1; 122 123 /** 124 * Return the number of bytes-per-pixel for the specified mask format. 125 */ 126 static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) { 127 SkASSERT(format < kMaskFormatCount); 128 // kA8 (0) -> 1 129 // kA565 (1) -> 2 130 // kARGB (2) -> 4 131 static const int sBytesPerPixel[] = {1, 2, 4}; 132 static_assert(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount, "array_size_mismatch"); 133 static_assert(kA8_GrMaskFormat == 0, "enum_order_dependency"); 134 static_assert(kA565_GrMaskFormat == 1, "enum_order_dependency"); 135 static_assert(kARGB_GrMaskFormat == 2, "enum_order_dependency"); 136 137 return sBytesPerPixel[(int)format]; 138 } 139 140 /** 141 * Optional bitfield flags that can be set on GrSurfaceDesc (below). 142 */ 143 enum GrSurfaceFlags { 144 kNone_GrSurfaceFlags = 0x0, 145 /** 146 * Creates a texture that can be rendered to as a GrRenderTarget. Use 147 * GrTexture::asRenderTarget() to access. 148 */ 149 kRenderTarget_GrSurfaceFlag = 0x1, 150 /** 151 * Clears to zero on creation. It will cause creation failure if initial data is supplied to the 152 * texture. This only affects the base level if the texture is created with MIP levels. 153 */ 154 kPerformInitialClear_GrSurfaceFlag = 0x2 155 }; 156 GR_MAKE_BITFIELD_OPS(GrSurfaceFlags) 157 158 typedef GrSurfaceFlags GrSurfaceDescFlags; 159 160 /** 161 * Describes a surface to be created. 162 */ 163 struct GrSurfaceDesc { 164 GrSurfaceDesc() 165 : fFlags(kNone_GrSurfaceFlags) 166 , fWidth(0) 167 , fHeight(0) 168 , fConfig(kUnknown_GrPixelConfig) 169 , fSampleCnt(1) {} 170 171 GrSurfaceDescFlags fFlags; //!< bitfield of TextureFlags 172 int fWidth; //!< Width of the texture 173 int fHeight; //!< Height of the texture 174 175 /** 176 * Format of source data of the texture. Not guaranteed to be the same as 177 * internal format used by 3D API. 178 */ 179 GrPixelConfig fConfig; 180 181 /** 182 * The number of samples per pixel. Zero is treated equivalently to 1. This only 183 * applies if the kRenderTarget_GrSurfaceFlag is set. The actual number 184 * of samples may not exactly match the request. The request will be rounded 185 * up to the next supported sample count. A value larger than the largest 186 * supported sample count will fail. 187 */ 188 int fSampleCnt; 189 }; 190 191 /** Ownership rules for external GPU resources imported into Skia. */ 192 enum GrWrapOwnership { 193 /** Skia will assume the client will keep the resource alive and Skia will not free it. */ 194 kBorrow_GrWrapOwnership, 195 196 /** Skia will assume ownership of the resource and free it. */ 197 kAdopt_GrWrapOwnership, 198 }; 199 200 enum class GrWrapCacheable : bool { 201 /** 202 * The wrapped resource will be removed from the cache as soon as it becomes purgeable. It may 203 * still be assigned and found by a unique key, but the presence of the key will not be used to 204 * keep the resource alive when it has no references. 205 */ 206 kNo = false, 207 /** 208 * The wrapped resource is allowed to remain in the GrResourceCache when it has no references 209 * but has a unique key. Such resources should only be given unique keys when it is known that 210 * the key will eventually be removed from the resource or invalidated via the message bus. 211 */ 212 kYes = true 213 }; 214 215 enum class GrBudgetedType : uint8_t { 216 /** The resource is budgeted and is subject to purging under budget pressure. */ 217 kBudgeted, 218 /** 219 * The resource is unbudgeted and is purged as soon as it has no refs regardless of whether 220 * it has a unique or scratch key. 221 */ 222 kUnbudgetedUncacheable, 223 /** 224 * The resource is unbudgeted and is allowed to remain in the cache with no refs if it 225 * has a unique key. Scratch keys are ignored. 226 */ 227 kUnbudgetedCacheable, 228 }; 229 230 /** 231 * Clips are composed from these objects. 232 */ 233 enum GrClipType { 234 kRect_ClipType, 235 kPath_ClipType 236 }; 237 238 enum class GrScissorTest : bool { 239 kDisabled = false, 240 kEnabled = true 241 }; 242 243 struct GrMipLevel { 244 const void* fPixels = nullptr; 245 size_t fRowBytes = 0; 246 }; 247 248 /** 249 * This enum is used to specify the load operation to be used when an opList/GrGpuCommandBuffer 250 * begins execution. 251 */ 252 enum class GrLoadOp { 253 kLoad, 254 kClear, 255 kDiscard, 256 }; 257 258 /** 259 * This enum is used to specify the store operation to be used when an opList/GrGpuCommandBuffer 260 * ends execution. 261 */ 262 enum class GrStoreOp { 263 kStore, 264 kDiscard, 265 }; 266 267 /** 268 * Used to control antialiasing in draw calls. 269 */ 270 enum class GrAA : bool { 271 kNo = false, 272 kYes = true 273 }; 274 275 /** This enum indicates the type of antialiasing to be performed. */ 276 enum class GrAAType : unsigned { 277 /** No antialiasing */ 278 kNone, 279 /** Use fragment shader code to compute a fractional pixel coverage. */ 280 kCoverage, 281 /** Use normal MSAA. */ 282 kMSAA, 283 /** 284 * Use "mixed samples" MSAA such that the stencil buffer is multisampled but the color buffer is 285 * not. 286 */ 287 kMixedSamples 288 }; 289 290 static inline bool GrAATypeIsHW(GrAAType type) { 291 switch (type) { 292 case GrAAType::kNone: 293 return false; 294 case GrAAType::kCoverage: 295 return false; 296 case GrAAType::kMSAA: 297 return true; 298 case GrAAType::kMixedSamples: 299 return true; 300 } 301 SK_ABORT("Unknown AA Type"); 302 return false; 303 } 304 305 /** The type of full scene antialiasing supported by a render target. */ 306 enum class GrFSAAType { 307 /** No FSAA */ 308 kNone, 309 /** Regular MSAA where each attachment has the same sample count. */ 310 kUnifiedMSAA, 311 /** One color sample, N stencil samples. */ 312 kMixedSamples, 313 }; 314 315 /** 316 * Not all drawing code paths support using mixed samples when available and instead use 317 * coverage-based aa. 318 */ 319 enum class GrAllowMixedSamples : bool { kNo = false, kYes = true }; 320 321 GrAAType GrChooseAAType(GrAA, GrFSAAType, GrAllowMixedSamples, const GrCaps&); 322 323 /* 324 * Some pixel configs are inherently clamped to [0,1], some are allowed to go outside that range, 325 * and some are FP but manually clamped in the XP. 326 */ 327 enum class GrClampType { 328 kAuto, // Normalized, fixed-point configs 329 kManual, // Clamped FP configs 330 kNone, // Normal (unclamped) FP configs 331 }; 332 333 /** 334 * A number of rectangle/quadrilateral drawing APIs can control anti-aliasing on a per edge basis. 335 * These masks specify which edges are AA'ed. The intent for this is to support tiling with seamless 336 * boundaries, where the inner edges are non-AA and the outer edges are AA. Regular draws (where AA 337 * is specified by GrAA) is almost equivalent to kNone or kAll, with the exception of how MSAA is 338 * handled. 339 * 340 * When tiling and there is MSAA, mixed edge rectangles are processed with MSAA, so in order for the 341 * tiled edges to remain seamless, inner tiles with kNone must also be processed with MSAA. In 342 * regular drawing, however, kNone should disable MSAA (if it's supported) to match the expected 343 * appearance. 344 * 345 * Therefore, APIs that use per-edge AA flags also take a GrAA value so that they can differentiate 346 * between the regular and tiling use case behaviors. Tiling operations should always pass 347 * GrAA::kYes while regular options should pass GrAA based on the SkPaint's anti-alias state. 348 */ 349 enum class GrQuadAAFlags { 350 kLeft = SkCanvas::kLeft_QuadAAFlag, 351 kTop = SkCanvas::kTop_QuadAAFlag, 352 kRight = SkCanvas::kRight_QuadAAFlag, 353 kBottom = SkCanvas::kBottom_QuadAAFlag, 354 355 kNone = SkCanvas::kNone_QuadAAFlags, 356 kAll = SkCanvas::kAll_QuadAAFlags 357 }; 358 359 GR_MAKE_BITFIELD_CLASS_OPS(GrQuadAAFlags) 360 361 static inline GrQuadAAFlags SkToGrQuadAAFlags(unsigned flags) { 362 return static_cast<GrQuadAAFlags>(flags); 363 } 364 365 /** 366 * Types of shader-language-specific boxed variables we can create. 367 */ 368 enum GrSLType { 369 kVoid_GrSLType, 370 kBool_GrSLType, 371 kByte_GrSLType, 372 kByte2_GrSLType, 373 kByte3_GrSLType, 374 kByte4_GrSLType, 375 kUByte_GrSLType, 376 kUByte2_GrSLType, 377 kUByte3_GrSLType, 378 kUByte4_GrSLType, 379 kShort_GrSLType, 380 kShort2_GrSLType, 381 kShort3_GrSLType, 382 kShort4_GrSLType, 383 kUShort_GrSLType, 384 kUShort2_GrSLType, 385 kUShort3_GrSLType, 386 kUShort4_GrSLType, 387 kFloat_GrSLType, 388 kFloat2_GrSLType, 389 kFloat3_GrSLType, 390 kFloat4_GrSLType, 391 kFloat2x2_GrSLType, 392 kFloat3x3_GrSLType, 393 kFloat4x4_GrSLType, 394 kHalf_GrSLType, 395 kHalf2_GrSLType, 396 kHalf3_GrSLType, 397 kHalf4_GrSLType, 398 kHalf2x2_GrSLType, 399 kHalf3x3_GrSLType, 400 kHalf4x4_GrSLType, 401 kInt_GrSLType, 402 kInt2_GrSLType, 403 kInt3_GrSLType, 404 kInt4_GrSLType, 405 kUint_GrSLType, 406 kUint2_GrSLType, 407 kTexture2DSampler_GrSLType, 408 kTextureExternalSampler_GrSLType, 409 kTexture2DRectSampler_GrSLType, 410 411 kLast_GrSLType = kTexture2DRectSampler_GrSLType 412 }; 413 static const int kGrSLTypeCount = kLast_GrSLType + 1; 414 415 /** 416 * The type of texture. Backends other than GL currently only use the 2D value but the type must 417 * still be known at the API-neutral layer as it used to determine whether MIP maps, renderability, 418 * and sampling parameters are legal for proxies that will be instantiated with wrapped textures. 419 */ 420 enum class GrTextureType { 421 k2D, 422 /* Rectangle uses unnormalized texture coordinates. */ 423 kRectangle, 424 kExternal 425 }; 426 427 enum GrShaderType { 428 kVertex_GrShaderType, 429 kGeometry_GrShaderType, 430 kFragment_GrShaderType, 431 432 kLastkFragment_GrShaderType = kFragment_GrShaderType 433 }; 434 static const int kGrShaderTypeCount = kLastkFragment_GrShaderType + 1; 435 436 enum GrShaderFlags { 437 kNone_GrShaderFlags = 0, 438 kVertex_GrShaderFlag = 1 << kVertex_GrShaderType, 439 kGeometry_GrShaderFlag = 1 << kGeometry_GrShaderType, 440 kFragment_GrShaderFlag = 1 << kFragment_GrShaderType 441 }; 442 GR_MAKE_BITFIELD_OPS(GrShaderFlags) 443 444 /** 445 * Precisions of shader language variables. Not all shading languages support precisions or actually 446 * vary the internal precision based on the qualifiers. These currently only apply to float types ( 447 * including float vectors and matrices). 448 */ 449 enum GrSLPrecision : int { 450 kLow_GrSLPrecision, 451 kMedium_GrSLPrecision, 452 kHigh_GrSLPrecision, 453 454 // Default precision is a special tag that means "whatever the default for the program/type 455 // combination is". In other words, it maps to the empty string in shader code. There are some 456 // scenarios where kDefault is not allowed (as the default precision for a program, or for 457 // varyings, for example). 458 kDefault_GrSLPrecision, 459 460 // We only consider the "real" precisions here 461 kLast_GrSLPrecision = kHigh_GrSLPrecision, 462 }; 463 464 static const int kGrSLPrecisionCount = kLast_GrSLPrecision + 1; 465 466 /** Is the shading language type float (including vectors/matrices)? */ 467 static inline bool GrSLTypeIsFloatType(GrSLType type) { 468 switch (type) { 469 case kFloat_GrSLType: 470 case kFloat2_GrSLType: 471 case kFloat3_GrSLType: 472 case kFloat4_GrSLType: 473 case kFloat2x2_GrSLType: 474 case kFloat3x3_GrSLType: 475 case kFloat4x4_GrSLType: 476 case kHalf_GrSLType: 477 case kHalf2_GrSLType: 478 case kHalf3_GrSLType: 479 case kHalf4_GrSLType: 480 case kHalf2x2_GrSLType: 481 case kHalf3x3_GrSLType: 482 case kHalf4x4_GrSLType: 483 return true; 484 485 case kVoid_GrSLType: 486 case kTexture2DSampler_GrSLType: 487 case kTextureExternalSampler_GrSLType: 488 case kTexture2DRectSampler_GrSLType: 489 case kBool_GrSLType: 490 case kByte_GrSLType: 491 case kByte2_GrSLType: 492 case kByte3_GrSLType: 493 case kByte4_GrSLType: 494 case kUByte_GrSLType: 495 case kUByte2_GrSLType: 496 case kUByte3_GrSLType: 497 case kUByte4_GrSLType: 498 case kShort_GrSLType: 499 case kShort2_GrSLType: 500 case kShort3_GrSLType: 501 case kShort4_GrSLType: 502 case kUShort_GrSLType: 503 case kUShort2_GrSLType: 504 case kUShort3_GrSLType: 505 case kUShort4_GrSLType: 506 case kInt_GrSLType: 507 case kInt2_GrSLType: 508 case kInt3_GrSLType: 509 case kInt4_GrSLType: 510 case kUint_GrSLType: 511 case kUint2_GrSLType: 512 return false; 513 } 514 SK_ABORT("Unexpected type"); 515 return false; 516 } 517 518 /** If the type represents a single value or vector return the vector length, else -1. */ 519 static inline int GrSLTypeVecLength(GrSLType type) { 520 switch (type) { 521 case kFloat_GrSLType: 522 case kHalf_GrSLType: 523 case kBool_GrSLType: 524 case kByte_GrSLType: 525 case kUByte_GrSLType: 526 case kShort_GrSLType: 527 case kUShort_GrSLType: 528 case kInt_GrSLType: 529 case kUint_GrSLType: 530 return 1; 531 532 case kFloat2_GrSLType: 533 case kHalf2_GrSLType: 534 case kByte2_GrSLType: 535 case kUByte2_GrSLType: 536 case kShort2_GrSLType: 537 case kUShort2_GrSLType: 538 case kInt2_GrSLType: 539 case kUint2_GrSLType: 540 return 2; 541 542 case kFloat3_GrSLType: 543 case kHalf3_GrSLType: 544 case kByte3_GrSLType: 545 case kUByte3_GrSLType: 546 case kShort3_GrSLType: 547 case kUShort3_GrSLType: 548 case kInt3_GrSLType: 549 return 3; 550 551 case kFloat4_GrSLType: 552 case kHalf4_GrSLType: 553 case kByte4_GrSLType: 554 case kUByte4_GrSLType: 555 case kShort4_GrSLType: 556 case kUShort4_GrSLType: 557 case kInt4_GrSLType: 558 return 4; 559 560 case kFloat2x2_GrSLType: 561 case kFloat3x3_GrSLType: 562 case kFloat4x4_GrSLType: 563 case kHalf2x2_GrSLType: 564 case kHalf3x3_GrSLType: 565 case kHalf4x4_GrSLType: 566 case kVoid_GrSLType: 567 case kTexture2DSampler_GrSLType: 568 case kTextureExternalSampler_GrSLType: 569 case kTexture2DRectSampler_GrSLType: 570 return -1; 571 } 572 SK_ABORT("Unexpected type"); 573 return -1; 574 } 575 576 static inline GrSLType GrSLCombinedSamplerTypeForTextureType(GrTextureType type) { 577 switch (type) { 578 case GrTextureType::k2D: 579 return kTexture2DSampler_GrSLType; 580 case GrTextureType::kRectangle: 581 return kTexture2DRectSampler_GrSLType; 582 case GrTextureType::kExternal: 583 return kTextureExternalSampler_GrSLType; 584 } 585 SK_ABORT("Unexpected texture type"); 586 return kTexture2DSampler_GrSLType; 587 } 588 589 /** Rectangle and external textures ony support the clamp wrap mode and do not support MIP maps. */ 590 static inline bool GrTextureTypeHasRestrictedSampling(GrTextureType type) { 591 switch (type) { 592 case GrTextureType::k2D: 593 return false; 594 case GrTextureType::kRectangle: 595 return true; 596 case GrTextureType::kExternal: 597 return true; 598 } 599 SK_ABORT("Unexpected texture type"); 600 return false; 601 } 602 603 static inline bool GrSLTypeIsCombinedSamplerType(GrSLType type) { 604 switch (type) { 605 case kTexture2DSampler_GrSLType: 606 case kTextureExternalSampler_GrSLType: 607 case kTexture2DRectSampler_GrSLType: 608 return true; 609 610 case kVoid_GrSLType: 611 case kFloat_GrSLType: 612 case kFloat2_GrSLType: 613 case kFloat3_GrSLType: 614 case kFloat4_GrSLType: 615 case kFloat2x2_GrSLType: 616 case kFloat3x3_GrSLType: 617 case kFloat4x4_GrSLType: 618 case kHalf_GrSLType: 619 case kHalf2_GrSLType: 620 case kHalf3_GrSLType: 621 case kHalf4_GrSLType: 622 case kHalf2x2_GrSLType: 623 case kHalf3x3_GrSLType: 624 case kHalf4x4_GrSLType: 625 case kInt_GrSLType: 626 case kInt2_GrSLType: 627 case kInt3_GrSLType: 628 case kInt4_GrSLType: 629 case kUint_GrSLType: 630 case kUint2_GrSLType: 631 case kBool_GrSLType: 632 case kByte_GrSLType: 633 case kByte2_GrSLType: 634 case kByte3_GrSLType: 635 case kByte4_GrSLType: 636 case kUByte_GrSLType: 637 case kUByte2_GrSLType: 638 case kUByte3_GrSLType: 639 case kUByte4_GrSLType: 640 case kShort_GrSLType: 641 case kShort2_GrSLType: 642 case kShort3_GrSLType: 643 case kShort4_GrSLType: 644 case kUShort_GrSLType: 645 case kUShort2_GrSLType: 646 case kUShort3_GrSLType: 647 case kUShort4_GrSLType: 648 return false; 649 } 650 SK_ABORT("Unexpected type"); 651 return false; 652 } 653 654 ////////////////////////////////////////////////////////////////////////////// 655 656 /** 657 * Types used to describe format of vertices in arrays. 658 */ 659 enum GrVertexAttribType { 660 kFloat_GrVertexAttribType = 0, 661 kFloat2_GrVertexAttribType, 662 kFloat3_GrVertexAttribType, 663 kFloat4_GrVertexAttribType, 664 kHalf_GrVertexAttribType, 665 kHalf2_GrVertexAttribType, 666 kHalf3_GrVertexAttribType, 667 kHalf4_GrVertexAttribType, 668 669 kInt2_GrVertexAttribType, // vector of 2 32-bit ints 670 kInt3_GrVertexAttribType, // vector of 3 32-bit ints 671 kInt4_GrVertexAttribType, // vector of 4 32-bit ints 672 673 674 kByte_GrVertexAttribType, // signed byte 675 kByte2_GrVertexAttribType, // vector of 2 8-bit signed bytes 676 kByte3_GrVertexAttribType, // vector of 3 8-bit signed bytes 677 kByte4_GrVertexAttribType, // vector of 4 8-bit signed bytes 678 kUByte_GrVertexAttribType, // unsigned byte 679 kUByte2_GrVertexAttribType, // vector of 2 8-bit unsigned bytes 680 kUByte3_GrVertexAttribType, // vector of 3 8-bit unsigned bytes 681 kUByte4_GrVertexAttribType, // vector of 4 8-bit unsigned bytes 682 683 kUByte_norm_GrVertexAttribType, // unsigned byte, e.g. coverage, 0 -> 0.0f, 255 -> 1.0f. 684 kUByte4_norm_GrVertexAttribType, // vector of 4 unsigned bytes, e.g. colors, 0 -> 0.0f, 685 // 255 -> 1.0f. 686 687 kShort2_GrVertexAttribType, // vector of 2 16-bit shorts. 688 kShort4_GrVertexAttribType, // vector of 4 16-bit shorts. 689 690 kUShort2_GrVertexAttribType, // vector of 2 unsigned shorts. 0 -> 0, 65535 -> 65535. 691 kUShort2_norm_GrVertexAttribType, // vector of 2 unsigned shorts. 0 -> 0.0f, 65535 -> 1.0f. 692 693 kInt_GrVertexAttribType, 694 kUint_GrVertexAttribType, 695 696 kLast_GrVertexAttribType = kUint_GrVertexAttribType 697 }; 698 static const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1; 699 700 ////////////////////////////////////////////////////////////////////////////// 701 702 static const int kGrClipEdgeTypeCnt = (int) GrClipEdgeType::kLast + 1; 703 704 static inline bool GrProcessorEdgeTypeIsFill(const GrClipEdgeType edgeType) { 705 return (GrClipEdgeType::kFillAA == edgeType || GrClipEdgeType::kFillBW == edgeType); 706 } 707 708 static inline bool GrProcessorEdgeTypeIsInverseFill(const GrClipEdgeType edgeType) { 709 return (GrClipEdgeType::kInverseFillAA == edgeType || 710 GrClipEdgeType::kInverseFillBW == edgeType); 711 } 712 713 static inline bool GrProcessorEdgeTypeIsAA(const GrClipEdgeType edgeType) { 714 return (GrClipEdgeType::kFillBW != edgeType && 715 GrClipEdgeType::kInverseFillBW != edgeType); 716 } 717 718 static inline GrClipEdgeType GrInvertProcessorEdgeType(const GrClipEdgeType edgeType) { 719 switch (edgeType) { 720 case GrClipEdgeType::kFillBW: 721 return GrClipEdgeType::kInverseFillBW; 722 case GrClipEdgeType::kFillAA: 723 return GrClipEdgeType::kInverseFillAA; 724 case GrClipEdgeType::kInverseFillBW: 725 return GrClipEdgeType::kFillBW; 726 case GrClipEdgeType::kInverseFillAA: 727 return GrClipEdgeType::kFillAA; 728 case GrClipEdgeType::kHairlineAA: 729 SK_ABORT("Hairline fill isn't invertible."); 730 } 731 return GrClipEdgeType::kFillAA; // suppress warning. 732 } 733 734 /** 735 * Indicates the type of pending IO operations that can be recorded for gpu resources. 736 */ 737 enum GrIOType { 738 kRead_GrIOType, 739 kWrite_GrIOType, 740 kRW_GrIOType 741 }; 742 743 /** 744 * Indicates the type of data that a GPU buffer will be used for. 745 */ 746 enum class GrGpuBufferType { 747 kVertex, 748 kIndex, 749 kXferCpuToGpu, 750 kXferGpuToCpu, 751 }; 752 static const int kGrGpuBufferTypeCount = static_cast<int>(GrGpuBufferType::kXferGpuToCpu) + 1; 753 754 /** 755 * Provides a performance hint regarding the frequency at which a data store will be accessed. 756 */ 757 enum GrAccessPattern { 758 /** Data store will be respecified repeatedly and used many times. */ 759 kDynamic_GrAccessPattern, 760 /** Data store will be specified once and used many times. (Thus disqualified from caching.) */ 761 kStatic_GrAccessPattern, 762 /** Data store will be specified once and used at most a few times. (Also can't be cached.) */ 763 kStream_GrAccessPattern, 764 765 kLast_GrAccessPattern = kStream_GrAccessPattern 766 }; 767 768 // Flags shared between the GrSurface & GrSurfaceProxy class hierarchies 769 enum class GrInternalSurfaceFlags { 770 kNone = 0, 771 772 // Surface-level 773 774 kNoPendingIO = 1 << 0, 775 776 kSurfaceMask = kNoPendingIO, 777 778 // Texture-level 779 780 // Means the pixels in the texture are read-only. Cannot also be a GrRenderTarget[Proxy]. 781 kReadOnly = 1 << 1, 782 783 kTextureMask = kReadOnly, 784 785 // RT-level 786 787 // For internal resources: 788 // this is enabled whenever MSAA is enabled and GrCaps reports mixed samples are supported 789 // For wrapped resources: 790 // this is disabled for FBO0 791 // but, otherwise, is enabled whenever MSAA is enabled and GrCaps reports mixed samples 792 // are supported 793 kMixedSampled = 1 << 2, 794 795 // This flag is for use with GL only. It tells us that the internal render target wraps FBO 0. 796 kGLRTFBOIDIs0 = 1 << 3, 797 798 kRenderTargetMask = kMixedSampled | kGLRTFBOIDIs0, 799 }; 800 GR_MAKE_BITFIELD_CLASS_OPS(GrInternalSurfaceFlags) 801 802 #ifdef SK_DEBUG 803 // Takes a pointer to a GrCaps, and will suppress prints if required 804 #define GrCapsDebugf(caps, ...) if (!(caps)->suppressPrints()) SkDebugf(__VA_ARGS__) 805 #else 806 #define GrCapsDebugf(caps, ...) do {} while (0) 807 #endif 808 809 /** 810 * Specifies if the holder owns the backend, OpenGL or Vulkan, object. 811 */ 812 enum class GrBackendObjectOwnership : bool { 813 /** Holder does not destroy the backend object. */ 814 kBorrowed = false, 815 /** Holder destroys the backend object. */ 816 kOwned = true 817 }; 818 819 template <typename T> 820 T* const* unique_ptr_address_as_pointer_address(std::unique_ptr<T> const* up) { 821 static_assert(sizeof(T*) == sizeof(std::unique_ptr<T>), "unique_ptr not expected size."); 822 return reinterpret_cast<T* const*>(up); 823 } 824 825 /* 826 * Object for CPU-GPU synchronization 827 */ 828 typedef uint64_t GrFence; 829 830 /** 831 * Used to include or exclude specific GPU path renderers for testing purposes. 832 */ 833 enum class GpuPathRenderers { 834 kNone = 0, // Always use sofware masks and/or GrDefaultPathRenderer. 835 kDashLine = 1 << 0, 836 kStencilAndCover = 1 << 1, 837 kCoverageCounting = 1 << 2, 838 kAAHairline = 1 << 3, 839 kAAConvex = 1 << 4, 840 kAALinearizing = 1 << 5, 841 kSmall = 1 << 6, 842 kTessellating = 1 << 7, 843 844 kAll = (kTessellating | (kTessellating - 1)) 845 }; 846 847 /** 848 * Used to describe the current state of Mips on a GrTexture 849 */ 850 enum class GrMipMapsStatus { 851 kNotAllocated, // Mips have not been allocated 852 kDirty, // Mips are allocated but the full mip tree does not have valid data 853 kValid, // All levels fully allocated and have valid data in them 854 }; 855 856 GR_MAKE_BITFIELD_CLASS_OPS(GpuPathRenderers) 857 858 /** 859 * Refers to the encoding of a GPU buffer as it will be interpreted by the GPU when sampling and 860 * blending. 861 */ 862 enum class GrSRGBEncoded : bool { kNo = false, kYes = true }; 863 864 /** 865 * Describes whether pixel data encoding should be converted to/from linear/sRGB encoding. 866 */ 867 enum class GrSRGBConversion { 868 kNone, 869 kSRGBToLinear, 870 kLinearToSRGB, 871 }; 872 873 /** 874 * Utility functions for GrPixelConfig 875 */ 876 877 // Returns whether the config's color channels are sRGB encoded. 878 static inline GrSRGBEncoded GrPixelConfigIsSRGBEncoded(GrPixelConfig config) { 879 switch (config) { 880 case kSRGBA_8888_GrPixelConfig: 881 case kSBGRA_8888_GrPixelConfig: 882 return GrSRGBEncoded::kYes; 883 case kUnknown_GrPixelConfig: 884 case kAlpha_8_GrPixelConfig: 885 case kAlpha_8_as_Alpha_GrPixelConfig: 886 case kAlpha_8_as_Red_GrPixelConfig: 887 case kGray_8_GrPixelConfig: 888 case kGray_8_as_Lum_GrPixelConfig: 889 case kGray_8_as_Red_GrPixelConfig: 890 case kRGB_565_GrPixelConfig: 891 case kRGBA_4444_GrPixelConfig: 892 case kRGB_888_GrPixelConfig: 893 case kRGB_888X_GrPixelConfig: 894 case kRG_88_GrPixelConfig: 895 case kRGBA_8888_GrPixelConfig: 896 case kBGRA_8888_GrPixelConfig: 897 case kRGBA_1010102_GrPixelConfig: 898 case kRGBA_float_GrPixelConfig: 899 case kRG_float_GrPixelConfig: 900 case kAlpha_half_GrPixelConfig: 901 case kAlpha_half_as_Red_GrPixelConfig: 902 case kRGBA_half_GrPixelConfig: 903 case kRGBA_half_Clamped_GrPixelConfig: 904 case kRGB_ETC1_GrPixelConfig: 905 return GrSRGBEncoded::kNo; 906 } 907 SK_ABORT("Invalid pixel config"); 908 return GrSRGBEncoded::kNo; 909 } 910 911 static inline bool GrPixelConfigIsSRGB(GrPixelConfig config) { 912 return GrSRGBEncoded::kYes == GrPixelConfigIsSRGBEncoded(config); 913 } 914 915 static inline size_t GrBytesPerPixel(GrPixelConfig config) { 916 switch (config) { 917 case kAlpha_8_GrPixelConfig: 918 case kAlpha_8_as_Alpha_GrPixelConfig: 919 case kAlpha_8_as_Red_GrPixelConfig: 920 case kGray_8_GrPixelConfig: 921 case kGray_8_as_Lum_GrPixelConfig: 922 case kGray_8_as_Red_GrPixelConfig: 923 return 1; 924 case kRGB_565_GrPixelConfig: 925 case kRGBA_4444_GrPixelConfig: 926 case kRG_88_GrPixelConfig: 927 case kAlpha_half_GrPixelConfig: 928 case kAlpha_half_as_Red_GrPixelConfig: 929 return 2; 930 case kRGBA_8888_GrPixelConfig: 931 case kRGB_888_GrPixelConfig: // Assuming GPUs store this 4-byte aligned. 932 case kRGB_888X_GrPixelConfig: 933 case kBGRA_8888_GrPixelConfig: 934 case kSRGBA_8888_GrPixelConfig: 935 case kSBGRA_8888_GrPixelConfig: 936 case kRGBA_1010102_GrPixelConfig: 937 return 4; 938 case kRGBA_half_GrPixelConfig: 939 case kRGBA_half_Clamped_GrPixelConfig: 940 return 8; 941 case kRGBA_float_GrPixelConfig: 942 return 16; 943 case kRG_float_GrPixelConfig: 944 return 8; 945 case kUnknown_GrPixelConfig: 946 case kRGB_ETC1_GrPixelConfig: 947 return 0; 948 } 949 SK_ABORT("Invalid pixel config"); 950 return 0; 951 } 952 953 static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) { 954 switch (config) { 955 case kRGB_565_GrPixelConfig: 956 case kRGB_888_GrPixelConfig: 957 case kRGB_888X_GrPixelConfig: 958 case kRG_88_GrPixelConfig: 959 case kGray_8_GrPixelConfig: 960 case kGray_8_as_Lum_GrPixelConfig: 961 case kGray_8_as_Red_GrPixelConfig: 962 case kRG_float_GrPixelConfig: 963 case kRGB_ETC1_GrPixelConfig: 964 return true; 965 case kAlpha_8_GrPixelConfig: 966 case kAlpha_8_as_Alpha_GrPixelConfig: 967 case kAlpha_8_as_Red_GrPixelConfig: 968 case kRGBA_4444_GrPixelConfig: 969 case kAlpha_half_GrPixelConfig: 970 case kAlpha_half_as_Red_GrPixelConfig: 971 case kRGBA_8888_GrPixelConfig: 972 case kBGRA_8888_GrPixelConfig: 973 case kSRGBA_8888_GrPixelConfig: 974 case kSBGRA_8888_GrPixelConfig: 975 case kRGBA_1010102_GrPixelConfig: 976 case kRGBA_half_GrPixelConfig: 977 case kRGBA_half_Clamped_GrPixelConfig: 978 case kRGBA_float_GrPixelConfig: 979 case kUnknown_GrPixelConfig: 980 return false; 981 } 982 SK_ABORT("Invalid pixel config"); 983 return false; 984 } 985 986 static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) { 987 switch (config) { 988 case kAlpha_8_GrPixelConfig: 989 case kAlpha_8_as_Alpha_GrPixelConfig: 990 case kAlpha_8_as_Red_GrPixelConfig: 991 case kAlpha_half_GrPixelConfig: 992 case kAlpha_half_as_Red_GrPixelConfig: 993 return true; 994 case kUnknown_GrPixelConfig: 995 case kGray_8_GrPixelConfig: 996 case kGray_8_as_Lum_GrPixelConfig: 997 case kGray_8_as_Red_GrPixelConfig: 998 case kRGB_565_GrPixelConfig: 999 case kRGBA_4444_GrPixelConfig: 1000 case kRGBA_8888_GrPixelConfig: 1001 case kRGB_888_GrPixelConfig: 1002 case kRGB_888X_GrPixelConfig: 1003 case kRG_88_GrPixelConfig: 1004 case kBGRA_8888_GrPixelConfig: 1005 case kSRGBA_8888_GrPixelConfig: 1006 case kSBGRA_8888_GrPixelConfig: 1007 case kRGBA_1010102_GrPixelConfig: 1008 case kRGBA_float_GrPixelConfig: 1009 case kRG_float_GrPixelConfig: 1010 case kRGBA_half_GrPixelConfig: 1011 case kRGBA_half_Clamped_GrPixelConfig: 1012 case kRGB_ETC1_GrPixelConfig: 1013 return false; 1014 } 1015 SK_ABORT("Invalid pixel config."); 1016 return false; 1017 } 1018 1019 static inline bool GrPixelConfigIsFloatingPoint(GrPixelConfig config) { 1020 switch (config) { 1021 case kUnknown_GrPixelConfig: 1022 case kAlpha_8_GrPixelConfig: 1023 case kAlpha_8_as_Alpha_GrPixelConfig: 1024 case kAlpha_8_as_Red_GrPixelConfig: 1025 case kGray_8_GrPixelConfig: 1026 case kGray_8_as_Lum_GrPixelConfig: 1027 case kGray_8_as_Red_GrPixelConfig: 1028 case kRGB_565_GrPixelConfig: 1029 case kRGBA_4444_GrPixelConfig: 1030 case kRGB_888_GrPixelConfig: 1031 case kRGB_888X_GrPixelConfig: 1032 case kRG_88_GrPixelConfig: 1033 case kRGBA_8888_GrPixelConfig: 1034 case kBGRA_8888_GrPixelConfig: 1035 case kSRGBA_8888_GrPixelConfig: 1036 case kSBGRA_8888_GrPixelConfig: 1037 case kRGBA_1010102_GrPixelConfig: 1038 case kRGB_ETC1_GrPixelConfig: 1039 return false; 1040 case kRGBA_float_GrPixelConfig: 1041 case kRG_float_GrPixelConfig: 1042 case kAlpha_half_GrPixelConfig: 1043 case kAlpha_half_as_Red_GrPixelConfig: 1044 case kRGBA_half_GrPixelConfig: 1045 case kRGBA_half_Clamped_GrPixelConfig: 1046 return true; 1047 } 1048 SK_ABORT("Invalid pixel config."); 1049 return false; 1050 } 1051 1052 static inline GrClampType GrPixelConfigClampType(GrPixelConfig config) { 1053 if (!GrPixelConfigIsFloatingPoint(config)) { 1054 return GrClampType::kAuto; 1055 } 1056 return kRGBA_half_Clamped_GrPixelConfig == config ? GrClampType::kManual : GrClampType::kNone; 1057 } 1058 1059 /** 1060 * Returns true if the pixel config is a GPU-specific compressed format 1061 * representation. 1062 */ 1063 static inline bool GrPixelConfigIsCompressed(GrPixelConfig config) { 1064 switch (config) { 1065 case kRGB_ETC1_GrPixelConfig: 1066 return true; 1067 case kUnknown_GrPixelConfig: 1068 case kAlpha_8_GrPixelConfig: 1069 case kAlpha_8_as_Alpha_GrPixelConfig: 1070 case kAlpha_8_as_Red_GrPixelConfig: 1071 case kGray_8_GrPixelConfig: 1072 case kGray_8_as_Lum_GrPixelConfig: 1073 case kGray_8_as_Red_GrPixelConfig: 1074 case kRGB_565_GrPixelConfig: 1075 case kRGBA_4444_GrPixelConfig: 1076 case kRGB_888_GrPixelConfig: 1077 case kRGB_888X_GrPixelConfig: 1078 case kRG_88_GrPixelConfig: 1079 case kRGBA_8888_GrPixelConfig: 1080 case kBGRA_8888_GrPixelConfig: 1081 case kSRGBA_8888_GrPixelConfig: 1082 case kSBGRA_8888_GrPixelConfig: 1083 case kRGBA_1010102_GrPixelConfig: 1084 case kRGBA_float_GrPixelConfig: 1085 case kRG_float_GrPixelConfig: 1086 case kAlpha_half_GrPixelConfig: 1087 case kAlpha_half_as_Red_GrPixelConfig: 1088 case kRGBA_half_GrPixelConfig: 1089 case kRGBA_half_Clamped_GrPixelConfig: 1090 return false; 1091 } 1092 SK_ABORT("Invalid pixel config"); 1093 return false; 1094 } 1095 1096 /** 1097 * If the pixel config is compressed, return an equivalent uncompressed format. 1098 */ 1099 static inline GrPixelConfig GrMakePixelConfigUncompressed(GrPixelConfig config) { 1100 switch (config) { 1101 case kRGB_ETC1_GrPixelConfig: 1102 return kRGBA_8888_GrPixelConfig; 1103 case kUnknown_GrPixelConfig: 1104 case kAlpha_8_GrPixelConfig: 1105 case kAlpha_8_as_Alpha_GrPixelConfig: 1106 case kAlpha_8_as_Red_GrPixelConfig: 1107 case kGray_8_GrPixelConfig: 1108 case kGray_8_as_Lum_GrPixelConfig: 1109 case kGray_8_as_Red_GrPixelConfig: 1110 case kRGB_565_GrPixelConfig: 1111 case kRGBA_4444_GrPixelConfig: 1112 case kRGB_888_GrPixelConfig: 1113 case kRGB_888X_GrPixelConfig: 1114 case kRG_88_GrPixelConfig: 1115 case kRGBA_8888_GrPixelConfig: 1116 case kBGRA_8888_GrPixelConfig: 1117 case kSRGBA_8888_GrPixelConfig: 1118 case kSBGRA_8888_GrPixelConfig: 1119 case kRGBA_1010102_GrPixelConfig: 1120 case kRGBA_float_GrPixelConfig: 1121 case kRG_float_GrPixelConfig: 1122 case kAlpha_half_GrPixelConfig: 1123 case kAlpha_half_as_Red_GrPixelConfig: 1124 case kRGBA_half_GrPixelConfig: 1125 case kRGBA_half_Clamped_GrPixelConfig: 1126 return config; 1127 } 1128 SK_ABORT("Invalid pixel config"); 1129 return config; 1130 } 1131 1132 /** 1133 * Returns the data size for the given compressed pixel config 1134 */ 1135 static inline size_t GrCompressedFormatDataSize(GrPixelConfig config, 1136 int width, int height) { 1137 SkASSERT(GrPixelConfigIsCompressed(config)); 1138 1139 switch (config) { 1140 case kRGB_ETC1_GrPixelConfig: 1141 SkASSERT((width & 3) == 0); 1142 SkASSERT((height & 3) == 0); 1143 return (width >> 2) * (height >> 2) * 8; 1144 1145 case kUnknown_GrPixelConfig: 1146 case kAlpha_8_GrPixelConfig: 1147 case kAlpha_8_as_Alpha_GrPixelConfig: 1148 case kAlpha_8_as_Red_GrPixelConfig: 1149 case kGray_8_GrPixelConfig: 1150 case kGray_8_as_Lum_GrPixelConfig: 1151 case kGray_8_as_Red_GrPixelConfig: 1152 case kRGB_565_GrPixelConfig: 1153 case kRGBA_4444_GrPixelConfig: 1154 case kRGB_888_GrPixelConfig: 1155 case kRGB_888X_GrPixelConfig: 1156 case kRG_88_GrPixelConfig: 1157 case kRGBA_8888_GrPixelConfig: 1158 case kBGRA_8888_GrPixelConfig: 1159 case kSRGBA_8888_GrPixelConfig: 1160 case kSBGRA_8888_GrPixelConfig: 1161 case kRGBA_1010102_GrPixelConfig: 1162 case kRGBA_float_GrPixelConfig: 1163 case kRG_float_GrPixelConfig: 1164 case kAlpha_half_GrPixelConfig: 1165 case kAlpha_half_as_Red_GrPixelConfig: 1166 case kRGBA_half_GrPixelConfig: 1167 case kRGBA_half_Clamped_GrPixelConfig: 1168 SK_ABORT("Unknown compressed pixel config"); 1169 return 4 * width * height; 1170 } 1171 1172 SK_ABORT("Invalid pixel config"); 1173 return 4 * width * height; 1174 } 1175 1176 /** 1177 * Precision qualifier that should be used with a sampler. 1178 */ 1179 static inline GrSLPrecision GrSLSamplerPrecision(GrPixelConfig config) { 1180 switch (config) { 1181 case kUnknown_GrPixelConfig: 1182 case kAlpha_8_GrPixelConfig: 1183 case kAlpha_8_as_Alpha_GrPixelConfig: 1184 case kAlpha_8_as_Red_GrPixelConfig: 1185 case kGray_8_GrPixelConfig: 1186 case kGray_8_as_Lum_GrPixelConfig: 1187 case kGray_8_as_Red_GrPixelConfig: 1188 case kRGB_565_GrPixelConfig: 1189 case kRGBA_4444_GrPixelConfig: 1190 case kRGBA_8888_GrPixelConfig: 1191 case kRGB_888_GrPixelConfig: 1192 case kRGB_888X_GrPixelConfig: 1193 case kRG_88_GrPixelConfig: 1194 case kBGRA_8888_GrPixelConfig: 1195 case kSRGBA_8888_GrPixelConfig: 1196 case kSBGRA_8888_GrPixelConfig: 1197 case kRGB_ETC1_GrPixelConfig: 1198 return kLow_GrSLPrecision; 1199 case kRGBA_float_GrPixelConfig: 1200 case kRG_float_GrPixelConfig: 1201 return kHigh_GrSLPrecision; 1202 case kAlpha_half_GrPixelConfig: 1203 case kAlpha_half_as_Red_GrPixelConfig: 1204 case kRGBA_half_GrPixelConfig: 1205 case kRGBA_half_Clamped_GrPixelConfig: 1206 case kRGBA_1010102_GrPixelConfig: 1207 return kMedium_GrSLPrecision; 1208 } 1209 SK_ABORT("Unexpected type"); 1210 return kHigh_GrSLPrecision; 1211 } 1212 1213 /** 1214 * Like SkColorType this describes a layout of pixel data in CPU memory. It specifies the channels, 1215 * their type, and width. This exists so that the GPU backend can have private types that have no 1216 * analog in the public facing SkColorType enum and omit types not implemented in the GPU backend. 1217 * It does not refer to a texture format and the mapping to texture formats may be many-to-many. 1218 * It does not specify the sRGB encoding of the stored values. 1219 */ 1220 enum class GrColorType { 1221 kUnknown, 1222 kAlpha_8, 1223 kRGB_565, 1224 kABGR_4444, // This name differs from SkColorType. kARGB_4444_SkColorType is misnamed. 1225 kRGBA_8888, 1226 kRGB_888x, 1227 kRG_88, 1228 kBGRA_8888, 1229 kRGBA_1010102, 1230 kGray_8, 1231 kAlpha_F16, 1232 kRGBA_F16, 1233 kRGBA_F16_Clamped, 1234 kRG_F32, 1235 kRGBA_F32, 1236 kRGB_ETC1, // This type doesn't appear in SkColorType at all. 1237 }; 1238 1239 static inline SkColorType GrColorTypeToSkColorType(GrColorType ct) { 1240 switch (ct) { 1241 case GrColorType::kUnknown: return kUnknown_SkColorType; 1242 case GrColorType::kAlpha_8: return kAlpha_8_SkColorType; 1243 case GrColorType::kRGB_565: return kRGB_565_SkColorType; 1244 case GrColorType::kABGR_4444: return kARGB_4444_SkColorType; 1245 case GrColorType::kRGBA_8888: return kRGBA_8888_SkColorType; 1246 case GrColorType::kRGB_888x: return kRGB_888x_SkColorType; 1247 case GrColorType::kRG_88: return kUnknown_SkColorType; 1248 case GrColorType::kBGRA_8888: return kBGRA_8888_SkColorType; 1249 case GrColorType::kRGBA_1010102: return kRGBA_1010102_SkColorType; 1250 case GrColorType::kGray_8: return kGray_8_SkColorType; 1251 case GrColorType::kAlpha_F16: return kUnknown_SkColorType; 1252 case GrColorType::kRGBA_F16: return kRGBA_F16_SkColorType; 1253 case GrColorType::kRGBA_F16_Clamped: return kRGBA_F16Norm_SkColorType; 1254 case GrColorType::kRG_F32: return kUnknown_SkColorType; 1255 case GrColorType::kRGBA_F32: return kRGBA_F32_SkColorType; 1256 case GrColorType::kRGB_ETC1: return kUnknown_SkColorType; 1257 } 1258 SK_ABORT("Invalid GrColorType"); 1259 return kUnknown_SkColorType; 1260 } 1261 1262 static inline GrColorType SkColorTypeToGrColorType(SkColorType ct) { 1263 switch (ct) { 1264 case kUnknown_SkColorType: return GrColorType::kUnknown; 1265 case kAlpha_8_SkColorType: return GrColorType::kAlpha_8; 1266 case kRGB_565_SkColorType: return GrColorType::kRGB_565; 1267 case kARGB_4444_SkColorType: return GrColorType::kABGR_4444; 1268 case kRGBA_8888_SkColorType: return GrColorType::kRGBA_8888; 1269 case kRGB_888x_SkColorType: return GrColorType::kRGB_888x; 1270 case kBGRA_8888_SkColorType: return GrColorType::kBGRA_8888; 1271 case kGray_8_SkColorType: return GrColorType::kGray_8; 1272 case kRGBA_F16Norm_SkColorType: return GrColorType::kRGBA_F16_Clamped; 1273 case kRGBA_F16_SkColorType: return GrColorType::kRGBA_F16; 1274 case kRGBA_1010102_SkColorType: return GrColorType::kRGBA_1010102; 1275 case kRGB_101010x_SkColorType: return GrColorType::kUnknown; 1276 case kRGBA_F32_SkColorType: return GrColorType::kRGBA_F32; 1277 } 1278 SK_ABORT("Invalid SkColorType"); 1279 return GrColorType::kUnknown; 1280 } 1281 1282 static inline uint32_t GrColorTypeComponentFlags(GrColorType ct) { 1283 switch (ct) { 1284 case GrColorType::kUnknown: return 0; 1285 case GrColorType::kAlpha_8: return kAlpha_SkColorTypeComponentFlag; 1286 case GrColorType::kRGB_565: return kRGB_SkColorTypeComponentFlags; 1287 case GrColorType::kABGR_4444: return kRGBA_SkColorTypeComponentFlags; 1288 case GrColorType::kRGBA_8888: return kRGBA_SkColorTypeComponentFlags; 1289 case GrColorType::kRGB_888x: return kRGB_SkColorTypeComponentFlags; 1290 case GrColorType::kRG_88: return kRed_SkColorTypeComponentFlag | 1291 kGreen_SkColorTypeComponentFlag; 1292 case GrColorType::kBGRA_8888: return kRGBA_SkColorTypeComponentFlags; 1293 case GrColorType::kRGBA_1010102: return kRGBA_SkColorTypeComponentFlags; 1294 case GrColorType::kGray_8: return kGray_SkColorTypeComponentFlag; 1295 case GrColorType::kAlpha_F16: return kAlpha_SkColorTypeComponentFlag; 1296 case GrColorType::kRGBA_F16: return kRGBA_SkColorTypeComponentFlags; 1297 case GrColorType::kRGBA_F16_Clamped: return kRGBA_SkColorTypeComponentFlags; 1298 case GrColorType::kRG_F32: return kRed_SkColorTypeComponentFlag | 1299 kGreen_SkColorTypeComponentFlag; 1300 case GrColorType::kRGBA_F32: return kRGBA_SkColorTypeComponentFlags; 1301 case GrColorType::kRGB_ETC1: return kRGB_SkColorTypeComponentFlags; 1302 } 1303 SK_ABORT("Invalid GrColorType"); 1304 return kUnknown_SkColorType; 1305 } 1306 1307 static inline bool GrColorTypeIsAlphaOnly(GrColorType ct) { 1308 return kAlpha_SkColorTypeComponentFlag == GrColorTypeComponentFlags(ct); 1309 } 1310 1311 static inline bool GrColorTypeHasAlpha(GrColorType ct) { 1312 return kAlpha_SkColorTypeComponentFlag & GrColorTypeComponentFlags(ct); 1313 } 1314 1315 static inline int GrColorTypeBytesPerPixel(GrColorType ct) { 1316 switch (ct) { 1317 case GrColorType::kUnknown: return 0; 1318 case GrColorType::kRGB_ETC1: return 0; 1319 case GrColorType::kAlpha_8: return 1; 1320 case GrColorType::kRGB_565: return 2; 1321 case GrColorType::kABGR_4444: return 2; 1322 case GrColorType::kRGBA_8888: return 4; 1323 case GrColorType::kRGB_888x: return 4; 1324 case GrColorType::kRG_88: return 2; 1325 case GrColorType::kBGRA_8888: return 4; 1326 case GrColorType::kRGBA_1010102: return 4; 1327 case GrColorType::kGray_8: return 1; 1328 case GrColorType::kAlpha_F16: return 2; 1329 case GrColorType::kRGBA_F16: return 8; 1330 case GrColorType::kRGBA_F16_Clamped: return 8; 1331 case GrColorType::kRG_F32: return 8; 1332 case GrColorType::kRGBA_F32: return 16; 1333 } 1334 SK_ABORT("Invalid GrColorType"); 1335 return 0; 1336 } 1337 1338 static inline GrColorType GrPixelConfigToColorTypeAndEncoding(GrPixelConfig config, 1339 GrSRGBEncoded* srgbEncoded) { 1340 SkASSERT(srgbEncoded); 1341 switch (config) { 1342 case kUnknown_GrPixelConfig: 1343 return GrColorType::kUnknown; 1344 case kAlpha_8_GrPixelConfig: 1345 *srgbEncoded = GrSRGBEncoded::kNo; 1346 return GrColorType::kAlpha_8; 1347 case kGray_8_GrPixelConfig: 1348 *srgbEncoded = GrSRGBEncoded::kNo; 1349 return GrColorType::kGray_8; 1350 case kRGB_565_GrPixelConfig: 1351 *srgbEncoded = GrSRGBEncoded::kNo; 1352 return GrColorType::kRGB_565; 1353 case kRGBA_4444_GrPixelConfig: 1354 *srgbEncoded = GrSRGBEncoded::kNo; 1355 return GrColorType::kABGR_4444; 1356 case kRGBA_8888_GrPixelConfig: 1357 *srgbEncoded = GrSRGBEncoded::kNo; 1358 return GrColorType::kRGBA_8888; 1359 case kRGB_888_GrPixelConfig: 1360 *srgbEncoded = GrSRGBEncoded::kNo; 1361 return GrColorType::kRGB_888x; 1362 case kRGB_888X_GrPixelConfig: 1363 *srgbEncoded = GrSRGBEncoded::kNo; 1364 return GrColorType::kRGB_888x; 1365 case kRG_88_GrPixelConfig: 1366 *srgbEncoded = GrSRGBEncoded::kNo; 1367 return GrColorType::kRG_88; 1368 case kBGRA_8888_GrPixelConfig: 1369 *srgbEncoded = GrSRGBEncoded::kNo; 1370 return GrColorType::kBGRA_8888; 1371 case kSRGBA_8888_GrPixelConfig: 1372 *srgbEncoded = GrSRGBEncoded::kYes; 1373 return GrColorType::kRGBA_8888; 1374 case kSBGRA_8888_GrPixelConfig: 1375 *srgbEncoded = GrSRGBEncoded::kYes; 1376 return GrColorType::kBGRA_8888; 1377 case kRGBA_1010102_GrPixelConfig: 1378 *srgbEncoded = GrSRGBEncoded::kNo; 1379 return GrColorType::kRGBA_1010102; 1380 case kRGBA_float_GrPixelConfig: 1381 *srgbEncoded = GrSRGBEncoded::kNo; 1382 return GrColorType::kRGBA_F32; 1383 case kRG_float_GrPixelConfig: 1384 *srgbEncoded = GrSRGBEncoded::kNo; 1385 return GrColorType::kRG_F32; 1386 case kAlpha_half_GrPixelConfig: 1387 *srgbEncoded = GrSRGBEncoded::kNo; 1388 return GrColorType::kAlpha_F16; 1389 case kRGBA_half_GrPixelConfig: 1390 *srgbEncoded = GrSRGBEncoded::kNo; 1391 return GrColorType::kRGBA_F16; 1392 case kRGBA_half_Clamped_GrPixelConfig: 1393 *srgbEncoded = GrSRGBEncoded::kNo; 1394 return GrColorType::kRGBA_F16_Clamped; 1395 case kRGB_ETC1_GrPixelConfig: 1396 *srgbEncoded = GrSRGBEncoded::kNo; 1397 return GrColorType::kRGB_ETC1; 1398 case kAlpha_8_as_Alpha_GrPixelConfig: 1399 *srgbEncoded = GrSRGBEncoded::kNo; 1400 return GrColorType::kAlpha_8; 1401 case kAlpha_8_as_Red_GrPixelConfig: 1402 *srgbEncoded = GrSRGBEncoded::kNo; 1403 return GrColorType::kAlpha_8; 1404 case kAlpha_half_as_Red_GrPixelConfig: 1405 *srgbEncoded = GrSRGBEncoded::kNo; 1406 return GrColorType::kAlpha_F16; 1407 case kGray_8_as_Lum_GrPixelConfig: 1408 *srgbEncoded = GrSRGBEncoded::kNo; 1409 return GrColorType::kGray_8; 1410 case kGray_8_as_Red_GrPixelConfig: 1411 *srgbEncoded = GrSRGBEncoded::kNo; 1412 return GrColorType::kGray_8; 1413 } 1414 SK_ABORT("Invalid GrPixelConfig"); 1415 return GrColorType::kUnknown; 1416 } 1417 1418 static inline GrColorType GrPixelConfigToColorType(GrPixelConfig config) { 1419 GrSRGBEncoded bogusEncoded; 1420 return GrPixelConfigToColorTypeAndEncoding(config, &bogusEncoded); 1421 } 1422 1423 static inline GrPixelConfig GrColorTypeToPixelConfig(GrColorType config, 1424 GrSRGBEncoded srgbEncoded) { 1425 switch (config) { 1426 case GrColorType::kUnknown: 1427 return kUnknown_GrPixelConfig; 1428 case GrColorType::kAlpha_8: 1429 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1430 : kAlpha_8_GrPixelConfig; 1431 1432 case GrColorType::kGray_8: 1433 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1434 : kGray_8_GrPixelConfig; 1435 1436 case GrColorType::kRGB_565: 1437 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1438 : kRGB_565_GrPixelConfig; 1439 1440 case GrColorType::kABGR_4444: 1441 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1442 : kRGBA_4444_GrPixelConfig; 1443 1444 case GrColorType::kRGBA_8888: 1445 return (GrSRGBEncoded::kYes == srgbEncoded) ? kSRGBA_8888_GrPixelConfig 1446 : kRGBA_8888_GrPixelConfig; 1447 1448 case GrColorType::kRGB_888x: 1449 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1450 : kRGB_888_GrPixelConfig; 1451 case GrColorType::kRG_88: 1452 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1453 : kRG_88_GrPixelConfig; 1454 1455 case GrColorType::kBGRA_8888: 1456 return (GrSRGBEncoded::kYes == srgbEncoded) ? kSBGRA_8888_GrPixelConfig 1457 : kBGRA_8888_GrPixelConfig; 1458 1459 case GrColorType::kRGBA_1010102: 1460 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1461 : kRGBA_1010102_GrPixelConfig; 1462 1463 case GrColorType::kRGBA_F32: 1464 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1465 : kRGBA_float_GrPixelConfig; 1466 1467 case GrColorType::kRG_F32: 1468 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1469 : kRG_float_GrPixelConfig; 1470 1471 case GrColorType::kAlpha_F16: 1472 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1473 : kAlpha_half_GrPixelConfig; 1474 1475 case GrColorType::kRGBA_F16: 1476 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1477 : kRGBA_half_GrPixelConfig; 1478 1479 case GrColorType::kRGBA_F16_Clamped: 1480 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1481 : kRGBA_half_Clamped_GrPixelConfig; 1482 1483 case GrColorType::kRGB_ETC1: 1484 return (GrSRGBEncoded::kYes == srgbEncoded) ? kUnknown_GrPixelConfig 1485 : kRGB_ETC1_GrPixelConfig; 1486 } 1487 SK_ABORT("Invalid GrColorType"); 1488 return kUnknown_GrPixelConfig; 1489 } 1490 1491 /** 1492 * Ref-counted object that calls a callback from its destructor. These can be chained together. Any 1493 * owner can cancel calling the callback via abandon(). 1494 */ 1495 class GrRefCntedCallback : public SkRefCnt { 1496 public: 1497 using Context = void*; 1498 using Callback = void (*)(Context); 1499 1500 GrRefCntedCallback(Callback proc, Context ctx) : fReleaseProc(proc), fReleaseCtx(ctx) { 1501 SkASSERT(proc); 1502 } 1503 ~GrRefCntedCallback() override { fReleaseProc ? fReleaseProc(fReleaseCtx) : void(); } 1504 1505 /** 1506 * After abandon is called the release proc will no longer be called in the destructor. This 1507 * does not recurse on child release procs or unref them. 1508 */ 1509 void abandon() { 1510 fReleaseProc = nullptr; 1511 fReleaseCtx = nullptr; 1512 } 1513 1514 /** Adds another GrRefCntedCallback that this will unref in its destructor. */ 1515 void addChild(sk_sp<GrRefCntedCallback> next) { 1516 if (!fNext) { 1517 fNext = std::move(next); 1518 return; 1519 } 1520 fNext->addChild(std::move(next)); 1521 } 1522 1523 Context context() const { return fReleaseCtx; } 1524 1525 private: 1526 sk_sp<GrRefCntedCallback> fNext; 1527 Callback fReleaseProc; 1528 Context fReleaseCtx; 1529 }; 1530 1531 #endif 1532
