Home | History | Annotate | Download | only in gpu 
      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     kMetal_GrBackend,
    189     kOpenGL_GrBackend,
    190     kVulkan_GrBackend,
    191     /**
    192      * Mock is a backend that does not draw anything. It is used for unit tests
    193      * and to measure CPU overhead.
    194      */
    195     kMock_GrBackend,
    196 };
    197 
    198 /**
    199  * Backend-specific 3D context handle
    200  *      OpenGL: const GrGLInterface*. If null will use the result of GrGLCreateNativeInterface().
    201  *      Vulkan: GrVkBackendContext*.
    202  *      Mock: const GrMockOptions* or null for default constructed GrMockContextOptions.
    203  */
    204 typedef intptr_t GrBackendContext;
    205 
    206 ///////////////////////////////////////////////////////////////////////////////
    207 
    208 /**
    209  * Used to control antialiasing in draw calls.
    210  */
    211 enum class GrAA {
    212     kYes,
    213     kNo
    214 };
    215 
    216 static inline GrAA GrBoolToAA(bool aa) { return aa ? GrAA::kYes : GrAA::kNo; }
    217 
    218 ///////////////////////////////////////////////////////////////////////////////
    219 
    220 /**
    221 * Geometric primitives used for drawing.
    222 */
    223 enum class GrPrimitiveType {
    224     kTriangles,
    225     kTriangleStrip,
    226     kTriangleFan,
    227     kPoints,
    228     kLines,     // 1 pix wide only
    229     kLineStrip, // 1 pix wide only
    230     kLinesAdjacency // requires geometry shader support.
    231 };
    232 static constexpr int kNumGrPrimitiveTypes = (int) GrPrimitiveType::kLinesAdjacency + 1;
    233 
    234 static constexpr bool GrIsPrimTypeLines(GrPrimitiveType type) {
    235     return GrPrimitiveType::kLines == type ||
    236            GrPrimitiveType::kLineStrip == type ||
    237            GrPrimitiveType::kLinesAdjacency == type;
    238 }
    239 
    240 static constexpr bool GrIsPrimTypeTris(GrPrimitiveType type) {
    241     return GrPrimitiveType::kTriangles == type     ||
    242            GrPrimitiveType::kTriangleStrip == type ||
    243            GrPrimitiveType::kTriangleFan == type;
    244 }
    245 
    246 static constexpr bool GrPrimTypeRequiresGeometryShaderSupport(GrPrimitiveType type) {
    247     return GrPrimitiveType::kLinesAdjacency == type;
    248 }
    249 
    250 /**
    251  *  Formats for masks, used by the font cache.
    252  *  Important that these are 0-based.
    253  */
    254 enum GrMaskFormat {
    255     kA8_GrMaskFormat,    //!< 1-byte per pixel
    256     kA565_GrMaskFormat,  //!< 2-bytes per pixel, RGB represent 3-channel LCD coverage
    257     kARGB_GrMaskFormat,  //!< 4-bytes per pixel, color format
    258 
    259     kLast_GrMaskFormat = kARGB_GrMaskFormat
    260 };
    261 static const int kMaskFormatCount = kLast_GrMaskFormat + 1;
    262 
    263 /**
    264  *  Return the number of bytes-per-pixel for the specified mask format.
    265  */
    266 static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
    267     SkASSERT(format < kMaskFormatCount);
    268     // kA8   (0) -> 1
    269     // kA565 (1) -> 2
    270     // kARGB (2) -> 4
    271     static const int sBytesPerPixel[] = { 1, 2, 4 };
    272     static_assert(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount, "array_size_mismatch");
    273     static_assert(kA8_GrMaskFormat == 0, "enum_order_dependency");
    274     static_assert(kA565_GrMaskFormat == 1, "enum_order_dependency");
    275     static_assert(kARGB_GrMaskFormat == 2, "enum_order_dependency");
    276 
    277     return sBytesPerPixel[(int) format];
    278 }
    279 
    280 /**
    281  * Pixel configurations.
    282  */
    283 enum GrPixelConfig {
    284     kUnknown_GrPixelConfig,
    285     kAlpha_8_GrPixelConfig,
    286     kGray_8_GrPixelConfig,
    287     kRGB_565_GrPixelConfig,
    288     /**
    289      * Premultiplied
    290      */
    291     kRGBA_4444_GrPixelConfig,
    292     /**
    293      * Premultiplied. Byte order is r,g,b,a.
    294      */
    295     kRGBA_8888_GrPixelConfig,
    296     /**
    297      * Premultiplied. Byte order is b,g,r,a.
    298      */
    299     kBGRA_8888_GrPixelConfig,
    300     /**
    301      * Premultiplied and sRGB. Byte order is r,g,b,a.
    302      */
    303     kSRGBA_8888_GrPixelConfig,
    304     /**
    305      * Premultiplied and sRGB. Byte order is b,g,r,a.
    306      */
    307     kSBGRA_8888_GrPixelConfig,
    308     /**
    309      * 8 bit signed integers per-channel. Byte order is b,g,r,a.
    310      */
    311     kRGBA_8888_sint_GrPixelConfig,
    312 
    313     /**
    314      * Byte order is r, g, b, a.  This color format is 32 bits per channel
    315      */
    316     kRGBA_float_GrPixelConfig,
    317     /**
    318      * Byte order is r, g.  This color format is 32 bits per channel
    319      */
    320     kRG_float_GrPixelConfig,
    321 
    322     /**
    323      * This color format is a single 16 bit float channel
    324      */
    325     kAlpha_half_GrPixelConfig,
    326 
    327     /**
    328     * Byte order is r, g, b, a.  This color format is 16 bits per channel
    329     */
    330     kRGBA_half_GrPixelConfig,
    331 
    332     kLast_GrPixelConfig = kRGBA_half_GrPixelConfig
    333 };
    334 static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1;
    335 
    336 // Aliases for pixel configs that match skia's byte order.
    337 #ifndef SK_CPU_LENDIAN
    338     #error "Skia gpu currently assumes little endian"
    339 #endif
    340 #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
    341     static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig;
    342 #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
    343     static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig;
    344 #else
    345     #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format."
    346 #endif
    347 
    348 // Returns true if the pixel config is 32 bits per pixel
    349 static inline bool GrPixelConfigIs8888Unorm(GrPixelConfig config) {
    350     switch (config) {
    351         case kRGBA_8888_GrPixelConfig:
    352         case kBGRA_8888_GrPixelConfig:
    353         case kSRGBA_8888_GrPixelConfig:
    354         case kSBGRA_8888_GrPixelConfig:
    355             return true;
    356         case kUnknown_GrPixelConfig:
    357         case kAlpha_8_GrPixelConfig:
    358         case kGray_8_GrPixelConfig:
    359         case kRGB_565_GrPixelConfig:
    360         case kRGBA_4444_GrPixelConfig:
    361         case kRGBA_8888_sint_GrPixelConfig:
    362         case kRGBA_float_GrPixelConfig:
    363         case kRG_float_GrPixelConfig:
    364         case kAlpha_half_GrPixelConfig:
    365         case kRGBA_half_GrPixelConfig:
    366             return false;
    367     }
    368     SkFAIL("Invalid pixel config");
    369     return false;
    370 }
    371 
    372 // Returns true if the color (non-alpha) components represent sRGB values. It does NOT indicate that
    373 // all three color components are present in the config or anything about their order.
    374 static inline bool GrPixelConfigIsSRGB(GrPixelConfig config) {
    375     switch (config) {
    376         case kSRGBA_8888_GrPixelConfig:
    377         case kSBGRA_8888_GrPixelConfig:
    378             return true;
    379         case kUnknown_GrPixelConfig:
    380         case kAlpha_8_GrPixelConfig:
    381         case kGray_8_GrPixelConfig:
    382         case kRGB_565_GrPixelConfig:
    383         case kRGBA_4444_GrPixelConfig:
    384         case kRGBA_8888_GrPixelConfig:
    385         case kBGRA_8888_GrPixelConfig:
    386         case kRGBA_8888_sint_GrPixelConfig:
    387         case kRGBA_float_GrPixelConfig:
    388         case kRG_float_GrPixelConfig:
    389         case kAlpha_half_GrPixelConfig:
    390         case kRGBA_half_GrPixelConfig:
    391             return false;
    392     }
    393     SkFAIL("Invalid pixel config");
    394     return false;
    395 }
    396 
    397 // Takes a config and returns the equivalent config with the R and B order
    398 // swapped if such a config exists. Otherwise, kUnknown_GrPixelConfig
    399 static inline GrPixelConfig GrPixelConfigSwapRAndB(GrPixelConfig config) {
    400     switch (config) {
    401         case kBGRA_8888_GrPixelConfig:
    402             return kRGBA_8888_GrPixelConfig;
    403         case kRGBA_8888_GrPixelConfig:
    404             return kBGRA_8888_GrPixelConfig;
    405         case kSBGRA_8888_GrPixelConfig:
    406             return kSRGBA_8888_GrPixelConfig;
    407         case kSRGBA_8888_GrPixelConfig:
    408             return kSBGRA_8888_GrPixelConfig;
    409         case kUnknown_GrPixelConfig:
    410         case kAlpha_8_GrPixelConfig:
    411         case kGray_8_GrPixelConfig:
    412         case kRGB_565_GrPixelConfig:
    413         case kRGBA_4444_GrPixelConfig:
    414         case kRGBA_8888_sint_GrPixelConfig:
    415         case kRGBA_float_GrPixelConfig:
    416         case kRG_float_GrPixelConfig:
    417         case kAlpha_half_GrPixelConfig:
    418         case kRGBA_half_GrPixelConfig:
    419             return kUnknown_GrPixelConfig;
    420     }
    421     SkFAIL("Invalid pixel config");
    422     return kUnknown_GrPixelConfig;
    423 }
    424 
    425 static inline size_t GrBytesPerPixel(GrPixelConfig config) {
    426     switch (config) {
    427         case kAlpha_8_GrPixelConfig:
    428         case kGray_8_GrPixelConfig:
    429             return 1;
    430         case kRGB_565_GrPixelConfig:
    431         case kRGBA_4444_GrPixelConfig:
    432         case kAlpha_half_GrPixelConfig:
    433             return 2;
    434         case kRGBA_8888_GrPixelConfig:
    435         case kBGRA_8888_GrPixelConfig:
    436         case kSRGBA_8888_GrPixelConfig:
    437         case kSBGRA_8888_GrPixelConfig:
    438         case kRGBA_8888_sint_GrPixelConfig:
    439             return 4;
    440         case kRGBA_half_GrPixelConfig:
    441             return 8;
    442         case kRGBA_float_GrPixelConfig:
    443             return 16;
    444         case kRG_float_GrPixelConfig:
    445             return 8;
    446         case kUnknown_GrPixelConfig:
    447             return 0;
    448     }
    449     SkFAIL("Invalid pixel config");
    450     return 0;
    451 }
    452 
    453 static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) {
    454     switch (config) {
    455         case kRGB_565_GrPixelConfig:
    456         case kGray_8_GrPixelConfig:
    457         case kRG_float_GrPixelConfig:
    458             return true;
    459         case kAlpha_8_GrPixelConfig:
    460         case kRGBA_4444_GrPixelConfig:
    461         case kAlpha_half_GrPixelConfig:
    462         case kRGBA_8888_GrPixelConfig:
    463         case kBGRA_8888_GrPixelConfig:
    464         case kSRGBA_8888_GrPixelConfig:
    465         case kSBGRA_8888_GrPixelConfig:
    466         case kRGBA_8888_sint_GrPixelConfig:
    467         case kRGBA_half_GrPixelConfig:
    468         case kRGBA_float_GrPixelConfig:
    469         case kUnknown_GrPixelConfig:
    470             return false;
    471     }
    472     SkFAIL("Invalid pixel config");
    473     return false;
    474 }
    475 
    476 static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) {
    477     switch (config) {
    478         case kAlpha_8_GrPixelConfig:
    479         case kAlpha_half_GrPixelConfig:
    480             return true;
    481         case kUnknown_GrPixelConfig:
    482         case kGray_8_GrPixelConfig:
    483         case kRGB_565_GrPixelConfig:
    484         case kRGBA_4444_GrPixelConfig:
    485         case kRGBA_8888_GrPixelConfig:
    486         case kBGRA_8888_GrPixelConfig:
    487         case kSRGBA_8888_GrPixelConfig:
    488         case kSBGRA_8888_GrPixelConfig:
    489         case kRGBA_8888_sint_GrPixelConfig:
    490         case kRGBA_float_GrPixelConfig:
    491         case kRG_float_GrPixelConfig:
    492         case kRGBA_half_GrPixelConfig:
    493             return false;
    494     }
    495     SkFAIL("Invalid pixel config.");
    496     return false;
    497 }
    498 
    499 static inline bool GrPixelConfigIsFloatingPoint(GrPixelConfig config) {
    500     switch (config) {
    501         case kRGBA_float_GrPixelConfig:
    502         case kRG_float_GrPixelConfig:
    503         case kAlpha_half_GrPixelConfig:
    504         case kRGBA_half_GrPixelConfig:
    505             return true;
    506         case kUnknown_GrPixelConfig:
    507         case kAlpha_8_GrPixelConfig:
    508         case kGray_8_GrPixelConfig:
    509         case kRGB_565_GrPixelConfig:
    510         case kRGBA_4444_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             return false;
    517     }
    518     SkFAIL("Invalid pixel config");
    519     return false;
    520 }
    521 
    522 static inline bool GrPixelConfigIsSint(GrPixelConfig config) {
    523     return config == kRGBA_8888_sint_GrPixelConfig;
    524 }
    525 
    526 static inline bool GrPixelConfigIsUnorm(GrPixelConfig config) {
    527     switch (config) {
    528         case kAlpha_8_GrPixelConfig:
    529         case kGray_8_GrPixelConfig:
    530         case kRGB_565_GrPixelConfig:
    531         case kRGBA_4444_GrPixelConfig:
    532         case kRGBA_8888_GrPixelConfig:
    533         case kBGRA_8888_GrPixelConfig:
    534         case kSRGBA_8888_GrPixelConfig:
    535         case kSBGRA_8888_GrPixelConfig:
    536             return true;
    537         case kUnknown_GrPixelConfig:
    538         case kAlpha_half_GrPixelConfig:
    539         case kRGBA_8888_sint_GrPixelConfig:
    540         case kRGBA_float_GrPixelConfig:
    541         case kRG_float_GrPixelConfig:
    542         case kRGBA_half_GrPixelConfig:
    543             return false;
    544     }
    545     SkFAIL("Invalid pixel config.");
    546     return false;
    547 }
    548 
    549 /**
    550  * Optional bitfield flags that can be set on GrSurfaceDesc (below).
    551  */
    552 enum GrSurfaceFlags {
    553     kNone_GrSurfaceFlags = 0x0,
    554     /**
    555      * Creates a texture that can be rendered to as a GrRenderTarget. Use
    556      * GrTexture::asRenderTarget() to access.
    557      */
    558     kRenderTarget_GrSurfaceFlag = 0x1,
    559     /**
    560      * Clears to zero on creation. It will cause creation failure if initial data is supplied to the
    561      * texture. This only affects the base level if the texture is created with MIP levels.
    562      */
    563     kPerformInitialClear_GrSurfaceFlag = 0x2
    564 };
    565 
    566 GR_MAKE_BITFIELD_OPS(GrSurfaceFlags)
    567 
    568 // opaque type for 3D API object handles
    569 typedef intptr_t GrBackendObject;
    570 
    571 /**
    572  * Some textures will be stored such that the upper and left edges of the content meet at the
    573  * the origin (in texture coord space) and for other textures the lower and left edges meet at
    574  * the origin. kDefault_GrSurfaceOrigin sets textures to TopLeft, and render targets
    575  * to BottomLeft.
    576  */
    577 
    578 enum GrSurfaceOrigin {
    579     kDefault_GrSurfaceOrigin,         // DEPRECATED; to be removed
    580     kTopLeft_GrSurfaceOrigin,
    581     kBottomLeft_GrSurfaceOrigin,
    582 };
    583 
    584 struct GrMipLevel {
    585     const void* fPixels;
    586     size_t fRowBytes;
    587 };
    588 
    589 /**
    590  * Describes a surface to be created.
    591  */
    592 struct GrSurfaceDesc {
    593     GrSurfaceDesc()
    594     : fFlags(kNone_GrSurfaceFlags)
    595     , fOrigin(kDefault_GrSurfaceOrigin)
    596     , fWidth(0)
    597     , fHeight(0)
    598     , fConfig(kUnknown_GrPixelConfig)
    599     , fSampleCnt(0)
    600     , fIsMipMapped(false) {
    601     }
    602 
    603     GrSurfaceFlags         fFlags;  //!< bitfield of TextureFlags
    604     GrSurfaceOrigin        fOrigin; //!< origin of the texture
    605     int                    fWidth;  //!< Width of the texture
    606     int                    fHeight; //!< Height of the texture
    607 
    608     /**
    609      * Format of source data of the texture. Not guaranteed to be the same as
    610      * internal format used by 3D API.
    611      */
    612     GrPixelConfig          fConfig;
    613 
    614     /**
    615      * The number of samples per pixel or 0 to disable full scene AA. This only
    616      * applies if the kRenderTarget_GrSurfaceFlag is set. The actual number
    617      * of samples may not exactly match the request. The request will be rounded
    618      * up to the next supported sample count, or down if it is larger than the
    619      * max supported count.
    620      */
    621     int                    fSampleCnt;
    622     bool                   fIsMipMapped; //!< Indicates if the texture has mipmaps
    623 };
    624 
    625 // Legacy alias
    626 typedef GrSurfaceDesc GrTextureDesc;
    627 
    628 /**
    629  * Clips are composed from these objects.
    630  */
    631 enum GrClipType {
    632     kRect_ClipType,
    633     kPath_ClipType
    634 };
    635 
    636 ///////////////////////////////////////////////////////////////////////////////
    637 
    638 
    639 /** Ownership rules for external GPU resources imported into Skia. */
    640 enum GrWrapOwnership {
    641     /** Skia will assume the client will keep the resource alive and Skia will not free it. */
    642     kBorrow_GrWrapOwnership,
    643 
    644     /** Skia will assume ownership of the resource and free it. */
    645     kAdopt_GrWrapOwnership,
    646 };
    647 
    648 /**
    649  * Gr can wrap an existing texture created by the client with a GrTexture
    650  * object. The client is responsible for ensuring that the texture lives at
    651  * least as long as the GrTexture object wrapping it. We require the client to
    652  * explicitly provide information about the texture, such as width, height,
    653  * and pixel config, rather than querying the 3D APIfor these values. We expect
    654  * these to be immutable even if the 3D API doesn't require this (OpenGL).
    655  *
    656  * Textures that are also render targets are supported as well. Gr will manage
    657  * any ancillary 3D API (stencil buffer, FBO id, etc) objects necessary for
    658  * Gr to draw into the render target. To access the render target object
    659  * call GrTexture::asRenderTarget().
    660  *
    661  * If in addition to the render target flag, the caller also specifies a sample
    662  * count Gr will create an MSAA buffer that resolves into the texture. Gr auto-
    663  * resolves when it reads from the texture. The client can explictly resolve
    664  * using the GrRenderTarget interface.
    665  *
    666  * Note: These flags currently form a subset of GrTexture's flags.
    667  */
    668 
    669 enum GrBackendTextureFlags {
    670     /**
    671      * No flags enabled
    672      */
    673     kNone_GrBackendTextureFlag             = 0,
    674     /**
    675      * Indicates that the texture is also a render target, and thus should have
    676      * a GrRenderTarget object.
    677      */
    678     kRenderTarget_GrBackendTextureFlag     = kRenderTarget_GrSurfaceFlag,
    679 };
    680 GR_MAKE_BITFIELD_OPS(GrBackendTextureFlags)
    681 
    682 struct GrBackendTextureDesc {
    683     GrBackendTextureDesc() { memset(this, 0, sizeof(*this)); }
    684     GrBackendTextureFlags           fFlags;
    685     GrSurfaceOrigin                 fOrigin;
    686     int                             fWidth;         //<! width in pixels
    687     int                             fHeight;        //<! height in pixels
    688     GrPixelConfig                   fConfig;        //<! color format
    689     /**
    690      * If the render target flag is set and sample count is greater than 0
    691      * then Gr will create an MSAA buffer that resolves to the texture.
    692      */
    693     int                             fSampleCnt;
    694     /**
    695      * Handle to the 3D API object.
    696      * OpenGL: Texture ID.
    697      * Vulkan: GrVkImageInfo*
    698      */
    699     GrBackendObject                 fTextureHandle;
    700 };
    701 
    702 ///////////////////////////////////////////////////////////////////////////////
    703 
    704 /**
    705  * Gr can wrap an existing render target created by the client in the 3D API
    706  * with a GrRenderTarget object. The client is responsible for ensuring that the
    707  * underlying 3D API object lives at least as long as the GrRenderTarget object
    708  * wrapping it. We require the client to explicitly provide information about
    709  * the target, such as width, height, and pixel config rather than querying the
    710  * 3D API for these values. We expect these properties to be immutable even if
    711  * the 3D API doesn't require this (OpenGL).
    712  */
    713 
    714 struct GrBackendRenderTargetDesc {
    715     GrBackendRenderTargetDesc() { memset(this, 0, sizeof(*this)); }
    716     int                             fWidth;         //<! width in pixels
    717     int                             fHeight;        //<! height in pixels
    718     GrPixelConfig                   fConfig;        //<! color format
    719     GrSurfaceOrigin                 fOrigin;        //<! pixel origin
    720     /**
    721      * The number of samples per pixel. Gr uses this to influence decisions
    722      * about applying other forms of anti-aliasing.
    723      */
    724     int                             fSampleCnt;
    725     /**
    726      * Number of bits of stencil per-pixel.
    727      */
    728     int                             fStencilBits;
    729     /**
    730      * Handle to the 3D API object.
    731      * OpenGL: FBO ID
    732      * Vulkan: GrVkImageInfo*
    733      */
    734     GrBackendObject                 fRenderTargetHandle;
    735 };
    736 
    737 /**
    738  * The GrContext's cache of backend context state can be partially invalidated.
    739  * These enums are specific to the GL backend and we'd add a new set for an alternative backend.
    740  */
    741 enum GrGLBackendState {
    742     kRenderTarget_GrGLBackendState     = 1 << 0,
    743     kTextureBinding_GrGLBackendState   = 1 << 1,
    744     // View state stands for scissor and viewport
    745     kView_GrGLBackendState             = 1 << 2,
    746     kBlend_GrGLBackendState            = 1 << 3,
    747     kMSAAEnable_GrGLBackendState       = 1 << 4,
    748     kVertex_GrGLBackendState           = 1 << 5,
    749     kStencil_GrGLBackendState          = 1 << 6,
    750     kPixelStore_GrGLBackendState       = 1 << 7,
    751     kProgram_GrGLBackendState          = 1 << 8,
    752     kFixedFunction_GrGLBackendState    = 1 << 9,
    753     kMisc_GrGLBackendState             = 1 << 10,
    754     kPathRendering_GrGLBackendState    = 1 << 11,
    755     kALL_GrGLBackendState              = 0xffff
    756 };
    757 
    758 /**
    759  * This value translates to reseting all the context state for any backend.
    760  */
    761 static const uint32_t kAll_GrBackendState = 0xffffffff;
    762 
    763 #endif
    764