1 /* 2 * Copyright 2010 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 GrTypes_DEFINED 9 #define GrTypes_DEFINED 10 11 #include "SkMath.h" 12 #include "SkTypes.h" 13 #include "GrConfig.h" 14 15 //////////////////////////////////////////////////////////////////////////////// 16 17 /** 18 * Defines overloaded bitwise operators to make it easier to use an enum as a 19 * bitfield. 20 */ 21 #define GR_MAKE_BITFIELD_OPS(X) \ 22 inline X operator |(X a, X b) { \ 23 return (X) (+a | +b); \ 24 } \ 25 inline X& operator |=(X& a, X b) { \ 26 return (a = a | b); \ 27 } \ 28 inline X operator &(X a, X b) { \ 29 return (X) (+a & +b); \ 30 } \ 31 inline X& operator &=(X& a, X b) { \ 32 return (a = a & b); \ 33 } \ 34 template <typename T> \ 35 inline X operator &(T a, X b) { \ 36 return (X) (+a & +b); \ 37 } \ 38 template <typename T> \ 39 inline X operator &(X a, T b) { \ 40 return (X) (+a & +b); \ 41 } \ 42 43 #define GR_DECL_BITFIELD_OPS_FRIENDS(X) \ 44 friend X operator |(X a, X b); \ 45 friend X& operator |=(X& a, X b); \ 46 \ 47 friend X operator &(X a, X b); \ 48 friend X& operator &=(X& a, X b); \ 49 \ 50 template <typename T> \ 51 friend X operator &(T a, X b); \ 52 \ 53 template <typename T> \ 54 friend X operator &(X a, T b); \ 55 56 /** 57 * Wraps a C++11 enum that we use as a bitfield, and enables a limited amount of 58 * masking with type safety. Instantiated with the ~ operator. 59 */ 60 template<typename TFlags> class GrTFlagsMask { 61 public: 62 constexpr explicit GrTFlagsMask(TFlags value) : GrTFlagsMask(static_cast<int>(value)) {} 63 constexpr explicit GrTFlagsMask(int value) : fValue(value) {} 64 constexpr int value() const { return fValue; } 65 private: 66 const int fValue; 67 }; 68 69 // Or-ing a mask always returns another mask. 70 template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(GrTFlagsMask<TFlags> a, 71 GrTFlagsMask<TFlags> b) { 72 return GrTFlagsMask<TFlags>(a.value() | b.value()); 73 } 74 template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(GrTFlagsMask<TFlags> a, 75 TFlags b) { 76 return GrTFlagsMask<TFlags>(a.value() | static_cast<int>(b)); 77 } 78 template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator|(TFlags a, 79 GrTFlagsMask<TFlags> b) { 80 return GrTFlagsMask<TFlags>(static_cast<int>(a) | b.value()); 81 } 82 template<typename TFlags> inline GrTFlagsMask<TFlags>& operator|=(GrTFlagsMask<TFlags>& a, 83 GrTFlagsMask<TFlags> b) { 84 return (a = a | b); 85 } 86 87 // And-ing two masks returns another mask; and-ing one with regular flags returns flags. 88 template<typename TFlags> constexpr GrTFlagsMask<TFlags> operator&(GrTFlagsMask<TFlags> a, 89 GrTFlagsMask<TFlags> b) { 90 return GrTFlagsMask<TFlags>(a.value() & b.value()); 91 } 92 template<typename TFlags> constexpr TFlags operator&(GrTFlagsMask<TFlags> a, TFlags b) { 93 return static_cast<TFlags>(a.value() & static_cast<int>(b)); 94 } 95 template<typename TFlags> constexpr TFlags operator&(TFlags a, GrTFlagsMask<TFlags> b) { 96 return static_cast<TFlags>(static_cast<int>(a) & b.value()); 97 } 98 template<typename TFlags> inline TFlags& operator&=(TFlags& a, GrTFlagsMask<TFlags> b) { 99 return (a = a & b); 100 } 101 102 /** 103 * Defines bitwise operators that make it possible to use an enum class as a 104 * basic bitfield. 105 */ 106 #define GR_MAKE_BITFIELD_CLASS_OPS(X) \ 107 constexpr GrTFlagsMask<X> operator~(X a) { \ 108 return GrTFlagsMask<X>(~static_cast<int>(a)); \ 109 } \ 110 constexpr X operator|(X a, X b) { \ 111 return static_cast<X>(static_cast<int>(a) | static_cast<int>(b)); \ 112 } \ 113 inline X& operator|=(X& a, X b) { \ 114 return (a = a | b); \ 115 } \ 116 constexpr bool operator&(X a, X b) { \ 117 return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \ 118 } \ 119 120 #define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \ 121 friend constexpr GrTFlagsMask<X> operator ~(X); \ 122 friend constexpr X operator |(X, X); \ 123 friend X& operator |=(X&, X); \ 124 friend constexpr bool operator &(X, X); 125 126 //////////////////////////////////////////////////////////////////////////////// 127 128 // compile time versions of min/max 129 #define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b)) 130 #define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a)) 131 132 /** 133 * divide, rounding up 134 */ 135 static inline int32_t GrIDivRoundUp(int x, int y) { 136 SkASSERT(y > 0); 137 return (x + (y-1)) / y; 138 } 139 static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) { 140 return (x + (y-1)) / y; 141 } 142 static inline size_t GrSizeDivRoundUp(size_t x, size_t y) { 143 return (x + (y-1)) / y; 144 } 145 146 // compile time, evaluates Y multiple times 147 #define GR_CT_DIV_ROUND_UP(X, Y) (((X) + ((Y)-1)) / (Y)) 148 149 /** 150 * align up 151 */ 152 static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) { 153 return GrUIDivRoundUp(x, alignment) * alignment; 154 } 155 static inline size_t GrSizeAlignUp(size_t x, size_t alignment) { 156 return GrSizeDivRoundUp(x, alignment) * alignment; 157 } 158 159 // compile time, evaluates A multiple times 160 #define GR_CT_ALIGN_UP(X, A) (GR_CT_DIV_ROUND_UP((X),(A)) * (A)) 161 162 /** 163 * amount of pad needed to align up 164 */ 165 static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) { 166 return (alignment - x % alignment) % alignment; 167 } 168 static inline size_t GrSizeAlignUpPad(size_t x, size_t alignment) { 169 return (alignment - x % alignment) % alignment; 170 } 171 172 /** 173 * align down 174 */ 175 static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) { 176 return (x / alignment) * alignment; 177 } 178 static inline size_t GrSizeAlignDown(size_t x, uint32_t alignment) { 179 return (x / alignment) * alignment; 180 } 181 182 /////////////////////////////////////////////////////////////////////////////// 183 184 /** 185 * Possible 3D APIs that may be used by Ganesh. 186 */ 187 enum GrBackend { 188 kOpenGL_GrBackend, 189 kVulkan_GrBackend, 190 191 kLast_GrBackend = kVulkan_GrBackend 192 }; 193 const int kBackendCount = kLast_GrBackend + 1; 194 195 /** 196 * Backend-specific 3D context handle 197 * GrGLInterface* for OpenGL. If NULL will use the default GL interface. 198 * GrVkBackendContext* for Vulkan. 199 */ 200 typedef intptr_t GrBackendContext; 201 202 /////////////////////////////////////////////////////////////////////////////// 203 204 /** 205 * Used to control antialiasing in draw calls. 206 */ 207 enum class GrAA { 208 kYes, 209 kNo 210 }; 211 212 static inline GrAA GrBoolToAA(bool aa) { return aa ? GrAA::kYes : GrAA::kNo; } 213 214 /////////////////////////////////////////////////////////////////////////////// 215 216 /** 217 * Geometric primitives used for drawing. 218 */ 219 enum GrPrimitiveType { 220 kTriangles_GrPrimitiveType, 221 kTriangleStrip_GrPrimitiveType, 222 kTriangleFan_GrPrimitiveType, 223 kPoints_GrPrimitiveType, 224 kLines_GrPrimitiveType, // 1 pix wide only 225 kLineStrip_GrPrimitiveType, // 1 pix wide only 226 kLast_GrPrimitiveType = kLineStrip_GrPrimitiveType 227 }; 228 229 static inline bool GrIsPrimTypeLines(GrPrimitiveType type) { 230 return kLines_GrPrimitiveType == type || kLineStrip_GrPrimitiveType == type; 231 } 232 233 static inline bool GrIsPrimTypeTris(GrPrimitiveType type) { 234 return kTriangles_GrPrimitiveType == type || 235 kTriangleStrip_GrPrimitiveType == type || 236 kTriangleFan_GrPrimitiveType == type; 237 } 238 239 /** 240 * Formats for masks, used by the font cache. 241 * Important that these are 0-based. 242 */ 243 enum GrMaskFormat { 244 kA8_GrMaskFormat, //!< 1-byte per pixel 245 kA565_GrMaskFormat, //!< 2-bytes per pixel, RGB represent 3-channel LCD coverage 246 kARGB_GrMaskFormat, //!< 4-bytes per pixel, color format 247 248 kLast_GrMaskFormat = kARGB_GrMaskFormat 249 }; 250 static const int kMaskFormatCount = kLast_GrMaskFormat + 1; 251 252 /** 253 * Return the number of bytes-per-pixel for the specified mask format. 254 */ 255 static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) { 256 SkASSERT(format < kMaskFormatCount); 257 // kA8 (0) -> 1 258 // kA565 (1) -> 2 259 // kARGB (2) -> 4 260 static const int sBytesPerPixel[] = { 1, 2, 4 }; 261 static_assert(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount, "array_size_mismatch"); 262 static_assert(kA8_GrMaskFormat == 0, "enum_order_dependency"); 263 static_assert(kA565_GrMaskFormat == 1, "enum_order_dependency"); 264 static_assert(kARGB_GrMaskFormat == 2, "enum_order_dependency"); 265 266 return sBytesPerPixel[(int) format]; 267 } 268 269 /** 270 * Pixel configurations. 271 */ 272 enum GrPixelConfig { 273 kUnknown_GrPixelConfig, 274 kAlpha_8_GrPixelConfig, 275 kGray_8_GrPixelConfig, 276 kRGB_565_GrPixelConfig, 277 /** 278 * Premultiplied 279 */ 280 kRGBA_4444_GrPixelConfig, 281 /** 282 * Premultiplied. Byte order is r,g,b,a. 283 */ 284 kRGBA_8888_GrPixelConfig, 285 /** 286 * Premultiplied. Byte order is b,g,r,a. 287 */ 288 kBGRA_8888_GrPixelConfig, 289 /** 290 * Premultiplied and sRGB. Byte order is r,g,b,a. 291 */ 292 kSRGBA_8888_GrPixelConfig, 293 /** 294 * Premultiplied and sRGB. Byte order is b,g,r,a. 295 */ 296 kSBGRA_8888_GrPixelConfig, 297 /** 298 * 8 bit signed integers per-channel. Byte order is b,g,r,a. 299 */ 300 kRGBA_8888_sint_GrPixelConfig, 301 /** 302 * ETC1 Compressed Data 303 */ 304 kETC1_GrPixelConfig, 305 /** 306 * Byte order is r, g, b, a. This color format is 32 bits per channel 307 */ 308 kRGBA_float_GrPixelConfig, 309 /** 310 * Byte order is r, g. This color format is 32 bits per channel 311 */ 312 kRG_float_GrPixelConfig, 313 314 /** 315 * This color format is a single 16 bit float channel 316 */ 317 kAlpha_half_GrPixelConfig, 318 319 /** 320 * Byte order is r, g, b, a. This color format is 16 bits per channel 321 */ 322 kRGBA_half_GrPixelConfig, 323 324 kLast_GrPixelConfig = kRGBA_half_GrPixelConfig 325 }; 326 static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1; 327 328 // Aliases for pixel configs that match skia's byte order. 329 #ifndef SK_CPU_LENDIAN 330 #error "Skia gpu currently assumes little endian" 331 #endif 332 #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) 333 static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig; 334 #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A) 335 static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig; 336 #else 337 #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format." 338 #endif 339 340 // Returns true if the pixel config is a GPU-specific compressed format 341 // representation. 342 static inline bool GrPixelConfigIsCompressed(GrPixelConfig config) { 343 switch (config) { 344 case kETC1_GrPixelConfig: 345 return true; 346 case kUnknown_GrPixelConfig: 347 case kAlpha_8_GrPixelConfig: 348 case kGray_8_GrPixelConfig: 349 case kRGB_565_GrPixelConfig: 350 case kRGBA_4444_GrPixelConfig: 351 case kRGBA_8888_GrPixelConfig: 352 case kBGRA_8888_GrPixelConfig: 353 case kSRGBA_8888_GrPixelConfig: 354 case kSBGRA_8888_GrPixelConfig: 355 case kRGBA_8888_sint_GrPixelConfig: 356 case kRGBA_float_GrPixelConfig: 357 case kRG_float_GrPixelConfig: 358 case kAlpha_half_GrPixelConfig: 359 case kRGBA_half_GrPixelConfig: 360 return false; 361 } 362 SkFAIL("Invalid pixel config"); 363 return false; 364 } 365 366 /** If the pixel config is compressed, return an equivalent uncompressed format. */ 367 static inline GrPixelConfig GrMakePixelConfigUncompressed(GrPixelConfig config) { 368 switch (config) { 369 case kETC1_GrPixelConfig: 370 return kRGBA_8888_GrPixelConfig; 371 case kUnknown_GrPixelConfig: 372 case kAlpha_8_GrPixelConfig: 373 case kGray_8_GrPixelConfig: 374 case kRGB_565_GrPixelConfig: 375 case kRGBA_4444_GrPixelConfig: 376 case kRGBA_8888_GrPixelConfig: 377 case kBGRA_8888_GrPixelConfig: 378 case kSRGBA_8888_GrPixelConfig: 379 case kSBGRA_8888_GrPixelConfig: 380 case kRGBA_8888_sint_GrPixelConfig: 381 case kRGBA_float_GrPixelConfig: 382 case kRG_float_GrPixelConfig: 383 case kAlpha_half_GrPixelConfig: 384 case kRGBA_half_GrPixelConfig: 385 SkASSERT(!GrPixelConfigIsCompressed(config)); 386 return config; 387 } 388 SkFAIL("Invalid pixel config"); 389 return config; 390 } 391 392 // Returns true if the pixel config is 32 bits per pixel 393 static inline bool GrPixelConfigIs8888Unorm(GrPixelConfig config) { 394 switch (config) { 395 case kRGBA_8888_GrPixelConfig: 396 case kBGRA_8888_GrPixelConfig: 397 case kSRGBA_8888_GrPixelConfig: 398 case kSBGRA_8888_GrPixelConfig: 399 return true; 400 case kUnknown_GrPixelConfig: 401 case kAlpha_8_GrPixelConfig: 402 case kGray_8_GrPixelConfig: 403 case kRGB_565_GrPixelConfig: 404 case kRGBA_4444_GrPixelConfig: 405 case kRGBA_8888_sint_GrPixelConfig: 406 case kETC1_GrPixelConfig: 407 case kRGBA_float_GrPixelConfig: 408 case kRG_float_GrPixelConfig: 409 case kAlpha_half_GrPixelConfig: 410 case kRGBA_half_GrPixelConfig: 411 return false; 412 } 413 SkFAIL("Invalid pixel config"); 414 return false; 415 } 416 417 // Returns true if the color (non-alpha) components represent sRGB values. It does NOT indicate that 418 // all three color components are present in the config or anything about their order. 419 static inline bool GrPixelConfigIsSRGB(GrPixelConfig config) { 420 switch (config) { 421 case kSRGBA_8888_GrPixelConfig: 422 case kSBGRA_8888_GrPixelConfig: 423 return true; 424 case kUnknown_GrPixelConfig: 425 case kAlpha_8_GrPixelConfig: 426 case kGray_8_GrPixelConfig: 427 case kRGB_565_GrPixelConfig: 428 case kRGBA_4444_GrPixelConfig: 429 case kRGBA_8888_GrPixelConfig: 430 case kBGRA_8888_GrPixelConfig: 431 case kRGBA_8888_sint_GrPixelConfig: 432 case kETC1_GrPixelConfig: 433 case kRGBA_float_GrPixelConfig: 434 case kRG_float_GrPixelConfig: 435 case kAlpha_half_GrPixelConfig: 436 case kRGBA_half_GrPixelConfig: 437 return false; 438 } 439 SkFAIL("Invalid pixel config"); 440 return false; 441 } 442 443 // Takes a config and returns the equivalent config with the R and B order 444 // swapped if such a config exists. Otherwise, kUnknown_GrPixelConfig 445 static inline GrPixelConfig GrPixelConfigSwapRAndB(GrPixelConfig config) { 446 switch (config) { 447 case kBGRA_8888_GrPixelConfig: 448 return kRGBA_8888_GrPixelConfig; 449 case kRGBA_8888_GrPixelConfig: 450 return kBGRA_8888_GrPixelConfig; 451 case kSBGRA_8888_GrPixelConfig: 452 return kSRGBA_8888_GrPixelConfig; 453 case kSRGBA_8888_GrPixelConfig: 454 return kSBGRA_8888_GrPixelConfig; 455 case kUnknown_GrPixelConfig: 456 case kAlpha_8_GrPixelConfig: 457 case kGray_8_GrPixelConfig: 458 case kRGB_565_GrPixelConfig: 459 case kRGBA_4444_GrPixelConfig: 460 case kRGBA_8888_sint_GrPixelConfig: 461 case kETC1_GrPixelConfig: 462 case kRGBA_float_GrPixelConfig: 463 case kRG_float_GrPixelConfig: 464 case kAlpha_half_GrPixelConfig: 465 case kRGBA_half_GrPixelConfig: 466 return kUnknown_GrPixelConfig; 467 } 468 SkFAIL("Invalid pixel config"); 469 return kUnknown_GrPixelConfig; 470 } 471 472 static inline size_t GrBytesPerPixel(GrPixelConfig config) { 473 SkASSERT(!GrPixelConfigIsCompressed(config)); 474 switch (config) { 475 case kAlpha_8_GrPixelConfig: 476 case kGray_8_GrPixelConfig: 477 return 1; 478 case kRGB_565_GrPixelConfig: 479 case kRGBA_4444_GrPixelConfig: 480 case kAlpha_half_GrPixelConfig: 481 return 2; 482 case kRGBA_8888_GrPixelConfig: 483 case kBGRA_8888_GrPixelConfig: 484 case kSRGBA_8888_GrPixelConfig: 485 case kSBGRA_8888_GrPixelConfig: 486 case kRGBA_8888_sint_GrPixelConfig: 487 return 4; 488 case kRGBA_half_GrPixelConfig: 489 return 8; 490 case kRGBA_float_GrPixelConfig: 491 return 16; 492 case kRG_float_GrPixelConfig: 493 return 8; 494 case kUnknown_GrPixelConfig: 495 case kETC1_GrPixelConfig: 496 return 0; 497 } 498 SkFAIL("Invalid pixel config"); 499 return 0; 500 } 501 502 static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) { 503 switch (config) { 504 case kETC1_GrPixelConfig: 505 case kRGB_565_GrPixelConfig: 506 case kGray_8_GrPixelConfig: 507 return true; 508 case kAlpha_8_GrPixelConfig: 509 case kRGBA_4444_GrPixelConfig: 510 case kAlpha_half_GrPixelConfig: 511 case kRGBA_8888_GrPixelConfig: 512 case kBGRA_8888_GrPixelConfig: 513 case kSRGBA_8888_GrPixelConfig: 514 case kSBGRA_8888_GrPixelConfig: 515 case kRGBA_8888_sint_GrPixelConfig: 516 case kRGBA_half_GrPixelConfig: 517 case kRGBA_float_GrPixelConfig: 518 case kRG_float_GrPixelConfig: 519 case kUnknown_GrPixelConfig: 520 return false; 521 } 522 SkFAIL("Invalid pixel config"); 523 return false; 524 } 525 526 static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) { 527 switch (config) { 528 case kAlpha_8_GrPixelConfig: 529 case kAlpha_half_GrPixelConfig: 530 return true; 531 case kUnknown_GrPixelConfig: 532 case kGray_8_GrPixelConfig: 533 case kRGB_565_GrPixelConfig: 534 case kRGBA_4444_GrPixelConfig: 535 case kRGBA_8888_GrPixelConfig: 536 case kBGRA_8888_GrPixelConfig: 537 case kSRGBA_8888_GrPixelConfig: 538 case kSBGRA_8888_GrPixelConfig: 539 case kRGBA_8888_sint_GrPixelConfig: 540 case kETC1_GrPixelConfig: 541 case kRGBA_float_GrPixelConfig: 542 case kRG_float_GrPixelConfig: 543 case kRGBA_half_GrPixelConfig: 544 return false; 545 } 546 SkFAIL("Invalid pixel config."); 547 return false; 548 } 549 550 static inline bool GrPixelConfigIsFloatingPoint(GrPixelConfig config) { 551 switch (config) { 552 case kRGBA_float_GrPixelConfig: 553 case kRG_float_GrPixelConfig: 554 case kAlpha_half_GrPixelConfig: 555 case kRGBA_half_GrPixelConfig: 556 return true; 557 case kUnknown_GrPixelConfig: 558 case kAlpha_8_GrPixelConfig: 559 case kGray_8_GrPixelConfig: 560 case kRGB_565_GrPixelConfig: 561 case kRGBA_4444_GrPixelConfig: 562 case kRGBA_8888_GrPixelConfig: 563 case kBGRA_8888_GrPixelConfig: 564 case kSRGBA_8888_GrPixelConfig: 565 case kSBGRA_8888_GrPixelConfig: 566 case kRGBA_8888_sint_GrPixelConfig: 567 case kETC1_GrPixelConfig: 568 return false; 569 } 570 SkFAIL("Invalid pixel config"); 571 return false; 572 } 573 574 static inline bool GrPixelConfigIsSint(GrPixelConfig config) { 575 return config == kRGBA_8888_sint_GrPixelConfig; 576 } 577 578 /** 579 * Optional bitfield flags that can be set on GrSurfaceDesc (below). 580 */ 581 enum GrSurfaceFlags { 582 kNone_GrSurfaceFlags = 0x0, 583 /** 584 * Creates a texture that can be rendered to as a GrRenderTarget. Use 585 * GrTexture::asRenderTarget() to access. 586 */ 587 kRenderTarget_GrSurfaceFlag = 0x1, 588 /** 589 * Placeholder for managing zero-copy textures 590 */ 591 kZeroCopy_GrSurfaceFlag = 0x2, 592 /** 593 * Indicates that all allocations (color buffer, FBO completeness, etc) 594 * should be verified. 595 */ 596 kCheckAllocation_GrSurfaceFlag = 0x4, 597 }; 598 599 GR_MAKE_BITFIELD_OPS(GrSurfaceFlags) 600 601 // opaque type for 3D API object handles 602 typedef intptr_t GrBackendObject; 603 604 /** 605 * Some textures will be stored such that the upper and left edges of the content meet at the 606 * the origin (in texture coord space) and for other textures the lower and left edges meet at 607 * the origin. kDefault_GrSurfaceOrigin sets textures to TopLeft, and render targets 608 * to BottomLeft. 609 */ 610 611 enum GrSurfaceOrigin { 612 kDefault_GrSurfaceOrigin, // DEPRECATED; to be removed 613 kTopLeft_GrSurfaceOrigin, 614 kBottomLeft_GrSurfaceOrigin, 615 }; 616 617 struct GrMipLevel { 618 const void* fPixels; 619 size_t fRowBytes; 620 }; 621 622 /** 623 * Describes a surface to be created. 624 */ 625 struct GrSurfaceDesc { 626 GrSurfaceDesc() 627 : fFlags(kNone_GrSurfaceFlags) 628 , fOrigin(kDefault_GrSurfaceOrigin) 629 , fWidth(0) 630 , fHeight(0) 631 , fConfig(kUnknown_GrPixelConfig) 632 , fSampleCnt(0) 633 , fIsMipMapped(false) { 634 } 635 636 GrSurfaceFlags fFlags; //!< bitfield of TextureFlags 637 GrSurfaceOrigin fOrigin; //!< origin of the texture 638 int fWidth; //!< Width of the texture 639 int fHeight; //!< Height of the texture 640 641 /** 642 * Format of source data of the texture. Not guaranteed to be the same as 643 * internal format used by 3D API. 644 */ 645 GrPixelConfig fConfig; 646 647 /** 648 * The number of samples per pixel or 0 to disable full scene AA. This only 649 * applies if the kRenderTarget_GrSurfaceFlag is set. The actual number 650 * of samples may not exactly match the request. The request will be rounded 651 * up to the next supported sample count, or down if it is larger than the 652 * max supported count. 653 */ 654 int fSampleCnt; 655 bool fIsMipMapped; //!< Indicates if the texture has mipmaps 656 }; 657 658 // Legacy alias 659 typedef GrSurfaceDesc GrTextureDesc; 660 661 /** 662 * Clips are composed from these objects. 663 */ 664 enum GrClipType { 665 kRect_ClipType, 666 kPath_ClipType 667 }; 668 669 /////////////////////////////////////////////////////////////////////////////// 670 671 672 /** Ownership rules for external GPU resources imported into Skia. */ 673 enum GrWrapOwnership { 674 /** Skia will assume the client will keep the resource alive and Skia will not free it. */ 675 kBorrow_GrWrapOwnership, 676 677 /** Skia will assume ownership of the resource and free it. */ 678 kAdopt_GrWrapOwnership, 679 680 /** Skia will assume ownership of the resource, free it, and reuse it within the cache. */ 681 kAdoptAndCache_GrWrapOwnership, 682 }; 683 684 /** 685 * Gr can wrap an existing texture created by the client with a GrTexture 686 * object. The client is responsible for ensuring that the texture lives at 687 * least as long as the GrTexture object wrapping it. We require the client to 688 * explicitly provide information about the texture, such as width, height, 689 * and pixel config, rather than querying the 3D APIfor these values. We expect 690 * these to be immutable even if the 3D API doesn't require this (OpenGL). 691 * 692 * Textures that are also render targets are supported as well. Gr will manage 693 * any ancillary 3D API (stencil buffer, FBO id, etc) objects necessary for 694 * Gr to draw into the render target. To access the render target object 695 * call GrTexture::asRenderTarget(). 696 * 697 * If in addition to the render target flag, the caller also specifies a sample 698 * count Gr will create an MSAA buffer that resolves into the texture. Gr auto- 699 * resolves when it reads from the texture. The client can explictly resolve 700 * using the GrRenderTarget interface. 701 * 702 * Note: These flags currently form a subset of GrTexture's flags. 703 */ 704 705 enum GrBackendTextureFlags { 706 /** 707 * No flags enabled 708 */ 709 kNone_GrBackendTextureFlag = 0, 710 /** 711 * Indicates that the texture is also a render target, and thus should have 712 * a GrRenderTarget object. 713 */ 714 kRenderTarget_GrBackendTextureFlag = kRenderTarget_GrSurfaceFlag, 715 }; 716 GR_MAKE_BITFIELD_OPS(GrBackendTextureFlags) 717 718 struct GrBackendTextureDesc { 719 GrBackendTextureDesc() { memset(this, 0, sizeof(*this)); } 720 GrBackendTextureFlags fFlags; 721 GrSurfaceOrigin fOrigin; 722 int fWidth; //<! width in pixels 723 int fHeight; //<! height in pixels 724 GrPixelConfig fConfig; //<! color format 725 /** 726 * If the render target flag is set and sample count is greater than 0 727 * then Gr will create an MSAA buffer that resolves to the texture. 728 */ 729 int fSampleCnt; 730 /** 731 * Handle to the 3D API object. 732 * OpenGL: Texture ID. 733 * Vulkan: GrVkImageInfo* 734 */ 735 GrBackendObject fTextureHandle; 736 }; 737 738 /////////////////////////////////////////////////////////////////////////////// 739 740 /** 741 * Gr can wrap an existing render target created by the client in the 3D API 742 * with a GrRenderTarget object. The client is responsible for ensuring that the 743 * underlying 3D API object lives at least as long as the GrRenderTarget object 744 * wrapping it. We require the client to explicitly provide information about 745 * the target, such as width, height, and pixel config rather than querying the 746 * 3D API for these values. We expect these properties to be immutable even if 747 * the 3D API doesn't require this (OpenGL). 748 */ 749 750 struct GrBackendRenderTargetDesc { 751 GrBackendRenderTargetDesc() { memset(this, 0, sizeof(*this)); } 752 int fWidth; //<! width in pixels 753 int fHeight; //<! height in pixels 754 GrPixelConfig fConfig; //<! color format 755 GrSurfaceOrigin fOrigin; //<! pixel origin 756 /** 757 * The number of samples per pixel. Gr uses this to influence decisions 758 * about applying other forms of anti-aliasing. 759 */ 760 int fSampleCnt; 761 /** 762 * Number of bits of stencil per-pixel. 763 */ 764 int fStencilBits; 765 /** 766 * Handle to the 3D API object. 767 * OpenGL: FBO ID 768 * Vulkan: GrVkImageInfo* 769 */ 770 GrBackendObject fRenderTargetHandle; 771 }; 772 773 /** 774 * The GrContext's cache of backend context state can be partially invalidated. 775 * These enums are specific to the GL backend and we'd add a new set for an alternative backend. 776 */ 777 enum GrGLBackendState { 778 kRenderTarget_GrGLBackendState = 1 << 0, 779 kTextureBinding_GrGLBackendState = 1 << 1, 780 // View state stands for scissor and viewport 781 kView_GrGLBackendState = 1 << 2, 782 kBlend_GrGLBackendState = 1 << 3, 783 kMSAAEnable_GrGLBackendState = 1 << 4, 784 kVertex_GrGLBackendState = 1 << 5, 785 kStencil_GrGLBackendState = 1 << 6, 786 kPixelStore_GrGLBackendState = 1 << 7, 787 kProgram_GrGLBackendState = 1 << 8, 788 kFixedFunction_GrGLBackendState = 1 << 9, 789 kMisc_GrGLBackendState = 1 << 10, 790 kPathRendering_GrGLBackendState = 1 << 11, 791 kALL_GrGLBackendState = 0xffff 792 }; 793 794 /** 795 * Returns the data size for the given compressed pixel config 796 */ 797 static inline size_t GrCompressedFormatDataSize(GrPixelConfig config, 798 int width, int height) { 799 SkASSERT(GrPixelConfigIsCompressed(config)); 800 801 switch (config) { 802 case kETC1_GrPixelConfig: 803 SkASSERT((width & 3) == 0); 804 SkASSERT((height & 3) == 0); 805 return (width >> 2) * (height >> 2) * 8; 806 807 case kUnknown_GrPixelConfig: 808 case kAlpha_8_GrPixelConfig: 809 case kGray_8_GrPixelConfig: 810 case kRGB_565_GrPixelConfig: 811 case kRGBA_4444_GrPixelConfig: 812 case kRGBA_8888_GrPixelConfig: 813 case kBGRA_8888_GrPixelConfig: 814 case kSRGBA_8888_GrPixelConfig: 815 case kSBGRA_8888_GrPixelConfig: 816 case kRGBA_8888_sint_GrPixelConfig: 817 case kRGBA_float_GrPixelConfig: 818 case kRG_float_GrPixelConfig: 819 case kAlpha_half_GrPixelConfig: 820 case kRGBA_half_GrPixelConfig: 821 SkFAIL("Unknown compressed pixel config"); 822 return 4 * width * height; 823 } 824 825 SkFAIL("Invalid pixel config"); 826 return 4 * width * height; 827 } 828 829 /** 830 * This value translates to reseting all the context state for any backend. 831 */ 832 static const uint32_t kAll_GrBackendState = 0xffffffff; 833 834 #endif 835