reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 1 | /* |
epoger@google.com | ec3ed6a | 2011-07-28 14:26:00 +0000 | [diff] [blame] | 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. |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 8 | #ifndef GrTypes_DEFINED |
| 9 | #define GrTypes_DEFINED |
| 10 | |
cblume | 55f2d2d | 2016-02-26 13:20:48 -0800 | [diff] [blame] | 11 | #include "SkMath.h" |
reed@google.com | 9b24d25 | 2011-06-01 20:27:53 +0000 | [diff] [blame] | 12 | #include "SkTypes.h" |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 13 | #include "GrConfig.h" |
| 14 | |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 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) \ |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 22 | inline X operator |(X a, X b) { \ |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 23 | return (X) (+a | +b); \ |
| 24 | } \ |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 25 | inline X& operator |=(X& a, X b) { \ |
cdalton | 3211770 | 2015-05-11 11:21:23 -0700 | [diff] [blame] | 26 | return (a = a | b); \ |
| 27 | } \ |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 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) { \ |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 36 | return (X) (+a & +b); \ |
| 37 | } \ |
| 38 | template <typename T> \ |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 39 | inline X operator &(X a, T b) { \ |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 40 | return (X) (+a & +b); \ |
| 41 | } \ |
| 42 | |
bsalomon@google.com | 86c1f71 | 2011-10-12 14:54:26 +0000 | [diff] [blame] | 43 | #define GR_DECL_BITFIELD_OPS_FRIENDS(X) \ |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 44 | friend X operator |(X a, X b); \ |
| 45 | friend X& operator |=(X& a, X b); \ |
bsalomon@google.com | 86c1f71 | 2011-10-12 14:54:26 +0000 | [diff] [blame] | 46 | \ |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 47 | friend X operator &(X a, X b); \ |
| 48 | friend X& operator &=(X& a, X b); \ |
bsalomon@google.com | 86c1f71 | 2011-10-12 14:54:26 +0000 | [diff] [blame] | 49 | \ |
| 50 | template <typename T> \ |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 51 | friend X operator &(T a, X b); \ |
bsalomon@google.com | 86c1f71 | 2011-10-12 14:54:26 +0000 | [diff] [blame] | 52 | \ |
| 53 | template <typename T> \ |
Brian Salomon | 587e08f | 2017-01-27 10:59:27 -0500 | [diff] [blame] | 54 | friend X operator &(X a, T b); \ |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 55 | |
| 56 | /** |
csmartdalton | ad2a2be | 2017-02-19 23:51:45 -0700 | [diff] [blame] | 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 | /** |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 103 | * Defines bitwise operators that make it possible to use an enum class as a |
csmartdalton | ad2a2be | 2017-02-19 23:51:45 -0700 | [diff] [blame] | 104 | * basic bitfield. |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 105 | */ |
| 106 | #define GR_MAKE_BITFIELD_CLASS_OPS(X) \ |
csmartdalton | ad2a2be | 2017-02-19 23:51:45 -0700 | [diff] [blame] | 107 | constexpr GrTFlagsMask<X> operator~(X a) { \ |
| 108 | return GrTFlagsMask<X>(~static_cast<int>(a)); \ |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 109 | } \ |
csmartdalton | ad2a2be | 2017-02-19 23:51:45 -0700 | [diff] [blame] | 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) { \ |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 114 | return (a = a | b); \ |
| 115 | } \ |
csmartdalton | ad2a2be | 2017-02-19 23:51:45 -0700 | [diff] [blame] | 116 | constexpr bool operator&(X a, X b) { \ |
| 117 | return SkToBool(static_cast<int>(a) & static_cast<int>(b)); \ |
| 118 | } \ |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 119 | |
| 120 | #define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \ |
csmartdalton | ad2a2be | 2017-02-19 23:51:45 -0700 | [diff] [blame] | 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); |
csmartdalton | f963599 | 2016-08-10 11:09:07 -0700 | [diff] [blame] | 125 | |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 126 | //////////////////////////////////////////////////////////////////////////////// |
| 127 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 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 | */ |
bsalomon@google.com | 9195836 | 2011-06-13 17:58:13 +0000 | [diff] [blame] | 135 | static inline int32_t GrIDivRoundUp(int x, int y) { |
tfarina@chromium.org | f6de475 | 2013-08-17 00:02:59 +0000 | [diff] [blame] | 136 | SkASSERT(y > 0); |
bsalomon@google.com | 9195836 | 2011-06-13 17:58:13 +0000 | [diff] [blame] | 137 | return (x + (y-1)) / y; |
| 138 | } |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 139 | static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) { |
| 140 | return (x + (y-1)) / y; |
| 141 | } |
bsalomon@google.com | 4da34e3 | 2012-06-19 15:40:27 +0000 | [diff] [blame] | 142 | static inline size_t GrSizeDivRoundUp(size_t x, size_t y) { |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 143 | return (x + (y-1)) / y; |
| 144 | } |
| 145 | |
bsalomon@google.com | 4da34e3 | 2012-06-19 15:40:27 +0000 | [diff] [blame] | 146 | // compile time, evaluates Y multiple times |
| 147 | #define GR_CT_DIV_ROUND_UP(X, Y) (((X) + ((Y)-1)) / (Y)) |
| 148 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 149 | /** |
| 150 | * align up |
| 151 | */ |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 152 | static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) { |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 153 | return GrUIDivRoundUp(x, alignment) * alignment; |
| 154 | } |
bsalomon@google.com | 4da34e3 | 2012-06-19 15:40:27 +0000 | [diff] [blame] | 155 | static inline size_t GrSizeAlignUp(size_t x, size_t alignment) { |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 156 | return GrSizeDivRoundUp(x, alignment) * alignment; |
| 157 | } |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 158 | |
bsalomon@google.com | 4da34e3 | 2012-06-19 15:40:27 +0000 | [diff] [blame] | 159 | // compile time, evaluates A multiple times |
| 160 | #define GR_CT_ALIGN_UP(X, A) (GR_CT_DIV_ROUND_UP((X),(A)) * (A)) |
| 161 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 162 | /** |
| 163 | * amount of pad needed to align up |
| 164 | */ |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 165 | static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) { |
| 166 | return (alignment - x % alignment) % alignment; |
| 167 | } |
bsalomon@google.com | 4da34e3 | 2012-06-19 15:40:27 +0000 | [diff] [blame] | 168 | static inline size_t GrSizeAlignUpPad(size_t x, size_t alignment) { |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 169 | return (alignment - x % alignment) % alignment; |
| 170 | } |
| 171 | |
| 172 | /** |
| 173 | * align down |
| 174 | */ |
bsalomon@google.com | 1c13c96 | 2011-02-14 16:51:21 +0000 | [diff] [blame] | 175 | static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) { |
| 176 | return (x / alignment) * alignment; |
| 177 | } |
bsalomon@google.com | 5e49732 | 2012-08-28 21:45:26 +0000 | [diff] [blame] | 178 | static inline size_t GrSizeAlignDown(size_t x, uint32_t alignment) { |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 179 | return (x / alignment) * alignment; |
| 180 | } |
| 181 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 182 | /////////////////////////////////////////////////////////////////////////////// |
| 183 | |
| 184 | /** |
bsalomon@google.com | 05ef510 | 2011-05-02 21:14:59 +0000 | [diff] [blame] | 185 | * Possible 3D APIs that may be used by Ganesh. |
| 186 | */ |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 187 | enum GrBackend { |
Greg Daniel | e5ddff5 | 2017-07-05 16:49:36 -0400 | [diff] [blame] | 188 | kMetal_GrBackend, |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 189 | kOpenGL_GrBackend, |
jvanverth | a50e17a | 2015-08-12 12:19:36 -0700 | [diff] [blame] | 190 | kVulkan_GrBackend, |
Brian Salomon | 8fe2427 | 2017-07-07 12:56:11 -0400 | [diff] [blame] | 191 | /** |
| 192 | * Mock is a backend that does not draw anything. It is used for unit tests |
| 193 | * and to measure CPU overhead. |
| 194 | */ |
Brian Salomon | 91a3e52 | 2017-06-23 10:58:19 -0400 | [diff] [blame] | 195 | kMock_GrBackend, |
bsalomon@google.com | 05ef510 | 2011-05-02 21:14:59 +0000 | [diff] [blame] | 196 | }; |
| 197 | |
| 198 | /** |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 199 | * Backend-specific 3D context handle |
Brian Salomon | cfe910d | 2017-07-06 16:40:18 -0400 | [diff] [blame] | 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. |
bsalomon@google.com | 05ef510 | 2011-05-02 21:14:59 +0000 | [diff] [blame] | 203 | */ |
bsalomon@google.com | 16e3dde | 2012-10-25 18:43:28 +0000 | [diff] [blame] | 204 | typedef intptr_t GrBackendContext; |
bsalomon@google.com | 05ef510 | 2011-05-02 21:14:59 +0000 | [diff] [blame] | 205 | |
| 206 | /////////////////////////////////////////////////////////////////////////////// |
| 207 | |
| 208 | /** |
Brian Salomon | 0e8fc8b | 2016-12-09 15:10:07 -0500 | [diff] [blame] | 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 | /** |
bsalomon@google.com | ffca400 | 2011-02-22 20:34:01 +0000 | [diff] [blame] | 221 | * Geometric primitives used for drawing. |
| 222 | */ |
Chris Dalton | 3809bab | 2017-06-13 10:55:06 -0600 | [diff] [blame] | 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. |
bsalomon@google.com | ffca400 | 2011-02-22 20:34:01 +0000 | [diff] [blame] | 231 | }; |
Chris Dalton | 3809bab | 2017-06-13 10:55:06 -0600 | [diff] [blame] | 232 | static constexpr int kNumGrPrimitiveTypes = (int) GrPrimitiveType::kLinesAdjacency + 1; |
bsalomon@google.com | ffca400 | 2011-02-22 20:34:01 +0000 | [diff] [blame] | 233 | |
Chris Dalton | b894c2b | 2017-06-14 12:39:19 -0600 | [diff] [blame] | 234 | static constexpr bool GrIsPrimTypeLines(GrPrimitiveType type) { |
Chris Dalton | 3809bab | 2017-06-13 10:55:06 -0600 | [diff] [blame] | 235 | return GrPrimitiveType::kLines == type || |
| 236 | GrPrimitiveType::kLineStrip == type || |
| 237 | GrPrimitiveType::kLinesAdjacency == type; |
bsalomon@google.com | 0650e81 | 2011-04-08 18:07:53 +0000 | [diff] [blame] | 238 | } |
| 239 | |
Chris Dalton | b894c2b | 2017-06-14 12:39:19 -0600 | [diff] [blame] | 240 | static constexpr bool GrIsPrimTypeTris(GrPrimitiveType type) { |
Chris Dalton | 3809bab | 2017-06-13 10:55:06 -0600 | [diff] [blame] | 241 | return GrPrimitiveType::kTriangles == type || |
| 242 | GrPrimitiveType::kTriangleStrip == type || |
| 243 | GrPrimitiveType::kTriangleFan == type; |
bsalomon@google.com | 0650e81 | 2011-04-08 18:07:53 +0000 | [diff] [blame] | 244 | } |
| 245 | |
Chris Dalton | b894c2b | 2017-06-14 12:39:19 -0600 | [diff] [blame] | 246 | static constexpr bool GrPrimTypeRequiresGeometryShaderSupport(GrPrimitiveType type) { |
| 247 | return GrPrimitiveType::kLinesAdjacency == type; |
| 248 | } |
| 249 | |
bsalomon@google.com | ffca400 | 2011-02-22 20:34:01 +0000 | [diff] [blame] | 250 | /** |
reed@google.com | 759c16e | 2011-03-15 19:15:15 +0000 | [diff] [blame] | 251 | * Formats for masks, used by the font cache. |
| 252 | * Important that these are 0-based. |
reed@google.com | 98539c6 | 2011-03-15 15:40:16 +0000 | [diff] [blame] | 253 | */ |
| 254 | enum GrMaskFormat { |
caryclark@google.com | 1eeaf0b | 2011-06-22 13:19:43 +0000 | [diff] [blame] | 255 | kA8_GrMaskFormat, //!< 1-byte per pixel |
jvanverth | 5eefe42 | 2014-11-26 12:07:33 -0800 | [diff] [blame] | 256 | kA565_GrMaskFormat, //!< 2-bytes per pixel, RGB represent 3-channel LCD coverage |
commit-bot@chromium.org | f8cb184 | 2013-12-03 19:45:22 +0000 | [diff] [blame] | 257 | kARGB_GrMaskFormat, //!< 4-bytes per pixel, color format |
skia.committer@gmail.com | 65caeaf | 2013-09-27 07:01:29 +0000 | [diff] [blame] | 258 | |
commit-bot@chromium.org | f8cb184 | 2013-12-03 19:45:22 +0000 | [diff] [blame] | 259 | kLast_GrMaskFormat = kARGB_GrMaskFormat |
reed@google.com | 98539c6 | 2011-03-15 15:40:16 +0000 | [diff] [blame] | 260 | }; |
commit-bot@chromium.org | 3fddf0e | 2013-09-26 12:57:19 +0000 | [diff] [blame] | 261 | static const int kMaskFormatCount = kLast_GrMaskFormat + 1; |
reed@google.com | 98539c6 | 2011-03-15 15:40:16 +0000 | [diff] [blame] | 262 | |
| 263 | /** |
| 264 | * Return the number of bytes-per-pixel for the specified mask format. |
| 265 | */ |
| 266 | static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) { |
mtklein | 1d02a60 | 2015-11-19 09:53:21 -0800 | [diff] [blame] | 267 | SkASSERT(format < kMaskFormatCount); |
reed@google.com | bbf1226 | 2011-10-04 20:14:57 +0000 | [diff] [blame] | 268 | // kA8 (0) -> 1 |
| 269 | // kA565 (1) -> 2 |
jvanverth | 5eefe42 | 2014-11-26 12:07:33 -0800 | [diff] [blame] | 270 | // kARGB (2) -> 4 |
reed | d54d3fc | 2014-11-13 14:39:58 -0800 | [diff] [blame] | 271 | static const int sBytesPerPixel[] = { 1, 2, 4 }; |
bungeman | 99fe822 | 2015-08-20 07:57:51 -0700 | [diff] [blame] | 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"); |
commit-bot@chromium.org | f8cb184 | 2013-12-03 19:45:22 +0000 | [diff] [blame] | 276 | |
| 277 | return sBytesPerPixel[(int) format]; |
reed@google.com | 98539c6 | 2011-03-15 15:40:16 +0000 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | /** |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 281 | * Pixel configurations. |
| 282 | */ |
| 283 | enum GrPixelConfig { |
| 284 | kUnknown_GrPixelConfig, |
| 285 | kAlpha_8_GrPixelConfig, |
Brian Osman | 986563b | 2017-01-10 14:20:02 -0500 | [diff] [blame] | 286 | kGray_8_GrPixelConfig, |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 287 | kRGB_565_GrPixelConfig, |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 288 | /** |
| 289 | * Premultiplied |
| 290 | */ |
| 291 | kRGBA_4444_GrPixelConfig, |
| 292 | /** |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 293 | * Premultiplied. Byte order is r,g,b,a. |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 294 | */ |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 295 | kRGBA_8888_GrPixelConfig, |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 296 | /** |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 297 | * Premultiplied. Byte order is b,g,r,a. |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 298 | */ |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 299 | kBGRA_8888_GrPixelConfig, |
joshualitt | ee5da55 | 2014-07-16 13:32:56 -0700 | [diff] [blame] | 300 | /** |
jvanverth | fa1e8a7 | 2014-12-22 08:31:49 -0800 | [diff] [blame] | 301 | * Premultiplied and sRGB. Byte order is r,g,b,a. |
| 302 | */ |
| 303 | kSRGBA_8888_GrPixelConfig, |
| 304 | /** |
brianosman | a635936 | 2016-03-21 06:55:37 -0700 | [diff] [blame] | 305 | * Premultiplied and sRGB. Byte order is b,g,r,a. |
| 306 | */ |
| 307 | kSBGRA_8888_GrPixelConfig, |
| 308 | /** |
Brian Salomon | bf7b620 | 2016-11-11 16:08:03 -0500 | [diff] [blame] | 309 | * 8 bit signed integers per-channel. Byte order is b,g,r,a. |
| 310 | */ |
| 311 | kRGBA_8888_sint_GrPixelConfig, |
Robert Phillips | 92de631 | 2017-05-23 07:43:48 -0400 | [diff] [blame] | 312 | |
commit-bot@chromium.org | 6e7ddaa | 2014-05-30 13:55:58 +0000 | [diff] [blame] | 313 | /** |
joshualitt | ee5da55 | 2014-07-16 13:32:56 -0700 | [diff] [blame] | 314 | * Byte order is r, g, b, a. This color format is 32 bits per channel |
| 315 | */ |
| 316 | kRGBA_float_GrPixelConfig, |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 317 | /** |
| 318 | * Byte order is r, g. This color format is 32 bits per channel |
| 319 | */ |
| 320 | kRG_float_GrPixelConfig, |
jvanverth | 28f9c60 | 2014-12-05 13:06:35 -0800 | [diff] [blame] | 321 | |
| 322 | /** |
| 323 | * This color format is a single 16 bit float channel |
| 324 | */ |
| 325 | kAlpha_half_GrPixelConfig, |
| 326 | |
jvanverth | fb5df43 | 2015-05-21 08:12:27 -0700 | [diff] [blame] | 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 |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 333 | }; |
bsalomon@google.com | b8eb2e8 | 2013-03-28 13:46:42 +0000 | [diff] [blame] | 334 | static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1; |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 335 | |
rmistry@google.com | fbfcd56 | 2012-08-23 18:09:54 +0000 | [diff] [blame] | 336 | // Aliases for pixel configs that match skia's byte order. |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 337 | #ifndef SK_CPU_LENDIAN |
| 338 | #error "Skia gpu currently assumes little endian" |
| 339 | #endif |
commit-bot@chromium.org | e4657ed | 2013-03-19 14:16:31 +0000 | [diff] [blame] | 340 | #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 341 | static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig; |
commit-bot@chromium.org | e4657ed | 2013-03-19 14:16:31 +0000 | [diff] [blame] | 342 | #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A) |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 343 | static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig; |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 344 | #else |
| 345 | #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format." |
| 346 | #endif |
| 347 | |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 348 | // Returns true if the pixel config is 32 bits per pixel |
Brian Salomon | bf7b620 | 2016-11-11 16:08:03 -0500 | [diff] [blame] | 349 | static inline bool GrPixelConfigIs8888Unorm(GrPixelConfig config) { |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 350 | switch (config) { |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 351 | case kRGBA_8888_GrPixelConfig: |
| 352 | case kBGRA_8888_GrPixelConfig: |
jvanverth | fa1e8a7 | 2014-12-22 08:31:49 -0800 | [diff] [blame] | 353 | case kSRGBA_8888_GrPixelConfig: |
brianosman | a635936 | 2016-03-21 06:55:37 -0700 | [diff] [blame] | 354 | case kSBGRA_8888_GrPixelConfig: |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 355 | return true; |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 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: |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 362 | case kRGBA_float_GrPixelConfig: |
| 363 | case kRG_float_GrPixelConfig: |
| 364 | case kAlpha_half_GrPixelConfig: |
| 365 | case kRGBA_half_GrPixelConfig: |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 366 | return false; |
| 367 | } |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 368 | SkFAIL("Invalid pixel config"); |
| 369 | return false; |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 370 | } |
| 371 | |
bsalomon | 16921ec | 2015-07-30 15:34:56 -0700 | [diff] [blame] | 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: |
brianosman | a635936 | 2016-03-21 06:55:37 -0700 | [diff] [blame] | 377 | case kSBGRA_8888_GrPixelConfig: |
bsalomon | 16921ec | 2015-07-30 15:34:56 -0700 | [diff] [blame] | 378 | return true; |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 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: |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 387 | case kRGBA_float_GrPixelConfig: |
| 388 | case kRG_float_GrPixelConfig: |
| 389 | case kAlpha_half_GrPixelConfig: |
| 390 | case kRGBA_half_GrPixelConfig: |
bsalomon | 16921ec | 2015-07-30 15:34:56 -0700 | [diff] [blame] | 391 | return false; |
| 392 | } |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 393 | SkFAIL("Invalid pixel config"); |
| 394 | return false; |
bsalomon | 16921ec | 2015-07-30 15:34:56 -0700 | [diff] [blame] | 395 | } |
| 396 | |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 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) { |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 401 | case kBGRA_8888_GrPixelConfig: |
| 402 | return kRGBA_8888_GrPixelConfig; |
| 403 | case kRGBA_8888_GrPixelConfig: |
| 404 | return kBGRA_8888_GrPixelConfig; |
brianosman | a635936 | 2016-03-21 06:55:37 -0700 | [diff] [blame] | 405 | case kSBGRA_8888_GrPixelConfig: |
| 406 | return kSRGBA_8888_GrPixelConfig; |
| 407 | case kSRGBA_8888_GrPixelConfig: |
| 408 | return kSBGRA_8888_GrPixelConfig; |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 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: |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 415 | case kRGBA_float_GrPixelConfig: |
| 416 | case kRG_float_GrPixelConfig: |
| 417 | case kAlpha_half_GrPixelConfig: |
| 418 | case kRGBA_half_GrPixelConfig: |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 419 | return kUnknown_GrPixelConfig; |
| 420 | } |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 421 | SkFAIL("Invalid pixel config"); |
| 422 | return kUnknown_GrPixelConfig; |
bsalomon@google.com | 0a97be2 | 2011-11-08 19:20:57 +0000 | [diff] [blame] | 423 | } |
| 424 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 425 | static inline size_t GrBytesPerPixel(GrPixelConfig config) { |
| 426 | switch (config) { |
| 427 | case kAlpha_8_GrPixelConfig: |
Brian Osman | 986563b | 2017-01-10 14:20:02 -0500 | [diff] [blame] | 428 | case kGray_8_GrPixelConfig: |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 429 | return 1; |
| 430 | case kRGB_565_GrPixelConfig: |
| 431 | case kRGBA_4444_GrPixelConfig: |
jvanverth | 28f9c60 | 2014-12-05 13:06:35 -0800 | [diff] [blame] | 432 | case kAlpha_half_GrPixelConfig: |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 433 | return 2; |
bsalomon@google.com | 0342a85 | 2012-08-20 19:22:38 +0000 | [diff] [blame] | 434 | case kRGBA_8888_GrPixelConfig: |
| 435 | case kBGRA_8888_GrPixelConfig: |
jvanverth | fa1e8a7 | 2014-12-22 08:31:49 -0800 | [diff] [blame] | 436 | case kSRGBA_8888_GrPixelConfig: |
brianosman | a635936 | 2016-03-21 06:55:37 -0700 | [diff] [blame] | 437 | case kSBGRA_8888_GrPixelConfig: |
Brian Salomon | bf7b620 | 2016-11-11 16:08:03 -0500 | [diff] [blame] | 438 | case kRGBA_8888_sint_GrPixelConfig: |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 439 | return 4; |
jvanverth | fb5df43 | 2015-05-21 08:12:27 -0700 | [diff] [blame] | 440 | case kRGBA_half_GrPixelConfig: |
| 441 | return 8; |
joshualitt | ee5da55 | 2014-07-16 13:32:56 -0700 | [diff] [blame] | 442 | case kRGBA_float_GrPixelConfig: |
| 443 | return 16; |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 444 | case kRG_float_GrPixelConfig: |
| 445 | return 8; |
| 446 | case kUnknown_GrPixelConfig: |
joshualitt | ee5da55 | 2014-07-16 13:32:56 -0700 | [diff] [blame] | 447 | return 0; |
| 448 | } |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 449 | SkFAIL("Invalid pixel config"); |
| 450 | return 0; |
joshualitt | ee5da55 | 2014-07-16 13:32:56 -0700 | [diff] [blame] | 451 | } |
| 452 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 453 | static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) { |
| 454 | switch (config) { |
| 455 | case kRGB_565_GrPixelConfig: |
Brian Osman | 986563b | 2017-01-10 14:20:02 -0500 | [diff] [blame] | 456 | case kGray_8_GrPixelConfig: |
Brian Salomon | d17b4a6 | 2017-05-23 16:53:47 -0400 | [diff] [blame] | 457 | case kRG_float_GrPixelConfig: |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 458 | return true; |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 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: |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 469 | case kUnknown_GrPixelConfig: |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 470 | return false; |
| 471 | } |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 472 | SkFAIL("Invalid pixel config"); |
| 473 | return false; |
bsalomon@google.com | c436499 | 2011-11-07 15:54:49 +0000 | [diff] [blame] | 474 | } |
| 475 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 476 | static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) { |
| 477 | switch (config) { |
| 478 | case kAlpha_8_GrPixelConfig: |
jvanverth | 28f9c60 | 2014-12-05 13:06:35 -0800 | [diff] [blame] | 479 | case kAlpha_half_GrPixelConfig: |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 480 | return true; |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 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: |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 490 | case kRGBA_float_GrPixelConfig: |
| 491 | case kRG_float_GrPixelConfig: |
| 492 | case kRGBA_half_GrPixelConfig: |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 493 | return false; |
| 494 | } |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 495 | SkFAIL("Invalid pixel config."); |
| 496 | return false; |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 497 | } |
| 498 | |
csmartdalton | c411f2d | 2016-06-27 09:29:07 -0700 | [diff] [blame] | 499 | static inline bool GrPixelConfigIsFloatingPoint(GrPixelConfig config) { |
| 500 | switch (config) { |
| 501 | case kRGBA_float_GrPixelConfig: |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 502 | case kRG_float_GrPixelConfig: |
csmartdalton | c411f2d | 2016-06-27 09:29:07 -0700 | [diff] [blame] | 503 | case kAlpha_half_GrPixelConfig: |
| 504 | case kRGBA_half_GrPixelConfig: |
| 505 | return true; |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 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: |
csmartdalton | c411f2d | 2016-06-27 09:29:07 -0700 | [diff] [blame] | 516 | return false; |
| 517 | } |
csmartdalton | 6aa0e11 | 2017-02-08 16:14:11 -0500 | [diff] [blame] | 518 | SkFAIL("Invalid pixel config"); |
| 519 | return false; |
csmartdalton | c411f2d | 2016-06-27 09:29:07 -0700 | [diff] [blame] | 520 | } |
| 521 | |
Brian Salomon | bf7b620 | 2016-11-11 16:08:03 -0500 | [diff] [blame] | 522 | static inline bool GrPixelConfigIsSint(GrPixelConfig config) { |
| 523 | return config == kRGBA_8888_sint_GrPixelConfig; |
| 524 | } |
| 525 | |
Brian Salomon | 9bada54 | 2017-06-12 12:09:30 -0400 | [diff] [blame] | 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 | |
bsalomon@google.com | 669fdc4 | 2011-04-05 17:08:27 +0000 | [diff] [blame] | 549 | /** |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 550 | * Optional bitfield flags that can be set on GrSurfaceDesc (below). |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 551 | */ |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 552 | enum GrSurfaceFlags { |
Brian Salomon | d17b4a6 | 2017-05-23 16:53:47 -0400 | [diff] [blame] | 553 | kNone_GrSurfaceFlags = 0x0, |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 554 | /** |
| 555 | * Creates a texture that can be rendered to as a GrRenderTarget. Use |
| 556 | * GrTexture::asRenderTarget() to access. |
| 557 | */ |
Brian Salomon | d17b4a6 | 2017-05-23 16:53:47 -0400 | [diff] [blame] | 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 |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 564 | }; |
| 565 | |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 566 | GR_MAKE_BITFIELD_OPS(GrSurfaceFlags) |
| 567 | |
erikchen | 9a1ed5d | 2016-02-10 16:32:34 -0800 | [diff] [blame] | 568 | // opaque type for 3D API object handles |
| 569 | typedef intptr_t GrBackendObject; |
| 570 | |
senorblanco@chromium.org | ef5dbe1 | 2013-01-28 16:42:38 +0000 | [diff] [blame] | 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 |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 574 | * the origin. kDefault_GrSurfaceOrigin sets textures to TopLeft, and render targets |
| 575 | * to BottomLeft. |
senorblanco@chromium.org | ef5dbe1 | 2013-01-28 16:42:38 +0000 | [diff] [blame] | 576 | */ |
| 577 | |
| 578 | enum GrSurfaceOrigin { |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 579 | kDefault_GrSurfaceOrigin, // DEPRECATED; to be removed |
robertphillips@google.com | cf9faf6 | 2013-02-05 14:05:06 +0000 | [diff] [blame] | 580 | kTopLeft_GrSurfaceOrigin, |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 581 | kBottomLeft_GrSurfaceOrigin, |
senorblanco@chromium.org | ef5dbe1 | 2013-01-28 16:42:38 +0000 | [diff] [blame] | 582 | }; |
robertphillips@google.com | 5091b70 | 2012-08-09 10:49:39 +0000 | [diff] [blame] | 583 | |
cblume | 55f2d2d | 2016-02-26 13:20:48 -0800 | [diff] [blame] | 584 | struct GrMipLevel { |
| 585 | const void* fPixels; |
| 586 | size_t fRowBytes; |
| 587 | }; |
| 588 | |
robertphillips@google.com | 5091b70 | 2012-08-09 10:49:39 +0000 | [diff] [blame] | 589 | /** |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 590 | * Describes a surface to be created. |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 591 | */ |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 592 | struct GrSurfaceDesc { |
| 593 | GrSurfaceDesc() |
| 594 | : fFlags(kNone_GrSurfaceFlags) |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 595 | , fOrigin(kDefault_GrSurfaceOrigin) |
robertphillips@google.com | 75b3c96 | 2012-06-07 12:08:45 +0000 | [diff] [blame] | 596 | , fWidth(0) |
| 597 | , fHeight(0) |
| 598 | , fConfig(kUnknown_GrPixelConfig) |
cblume | 55f2d2d | 2016-02-26 13:20:48 -0800 | [diff] [blame] | 599 | , fSampleCnt(0) |
| 600 | , fIsMipMapped(false) { |
robertphillips@google.com | 75b3c96 | 2012-06-07 12:08:45 +0000 | [diff] [blame] | 601 | } |
| 602 | |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 603 | GrSurfaceFlags fFlags; //!< bitfield of TextureFlags |
senorblanco@chromium.org | 3cb406b | 2013-02-05 19:50:46 +0000 | [diff] [blame] | 604 | GrSurfaceOrigin fOrigin; //!< origin of the texture |
bsalomon@google.com | 79d2dbe | 2011-06-13 19:28:02 +0000 | [diff] [blame] | 605 | int fWidth; //!< Width of the texture |
| 606 | int fHeight; //!< Height of the texture |
bsalomon@google.com | 78d6cf9 | 2012-01-30 18:09:31 +0000 | [diff] [blame] | 607 | |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 608 | /** |
robertphillips@google.com | 07ef911 | 2012-06-04 13:22:14 +0000 | [diff] [blame] | 609 | * Format of source data of the texture. Not guaranteed to be the same as |
bsalomon@google.com | fea37b5 | 2011-04-25 15:51:06 +0000 | [diff] [blame] | 610 | * internal format used by 3D API. |
| 611 | */ |
bsalomon@google.com | 5bc34f0 | 2011-12-06 14:46:34 +0000 | [diff] [blame] | 612 | GrPixelConfig fConfig; |
bsalomon@google.com | b9014f4 | 2012-03-30 14:22:41 +0000 | [diff] [blame] | 613 | |
bsalomon@google.com | 78d6cf9 | 2012-01-30 18:09:31 +0000 | [diff] [blame] | 614 | /** |
| 615 | * The number of samples per pixel or 0 to disable full scene AA. This only |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 616 | * applies if the kRenderTarget_GrSurfaceFlag is set. The actual number |
bsalomon@google.com | 78d6cf9 | 2012-01-30 18:09:31 +0000 | [diff] [blame] | 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 |
bsalomon@google.com | 2d0bade | 2012-10-26 19:01:17 +0000 | [diff] [blame] | 619 | * max supported count. |
bsalomon@google.com | 78d6cf9 | 2012-01-30 18:09:31 +0000 | [diff] [blame] | 620 | */ |
robertphillips@google.com | 75b3c96 | 2012-06-07 12:08:45 +0000 | [diff] [blame] | 621 | int fSampleCnt; |
cblume | 55f2d2d | 2016-02-26 13:20:48 -0800 | [diff] [blame] | 622 | bool fIsMipMapped; //!< Indicates if the texture has mipmaps |
robertphillips@google.com | 9c2ea84 | 2012-08-13 17:47:59 +0000 | [diff] [blame] | 623 | }; |
| 624 | |
bsalomon | f2703d8 | 2014-10-28 14:33:06 -0700 | [diff] [blame] | 625 | // Legacy alias |
| 626 | typedef GrSurfaceDesc GrTextureDesc; |
| 627 | |
robertphillips@google.com | 9c2ea84 | 2012-08-13 17:47:59 +0000 | [diff] [blame] | 628 | /** |
bsalomon@google.com | d302f14 | 2011-03-03 13:54:13 +0000 | [diff] [blame] | 629 | * Clips are composed from these objects. |
| 630 | */ |
| 631 | enum GrClipType { |
| 632 | kRect_ClipType, |
| 633 | kPath_ClipType |
| 634 | }; |
| 635 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 636 | /////////////////////////////////////////////////////////////////////////////// |
| 637 | |
bsalomon | 6dc6f5f | 2015-06-18 09:12:16 -0700 | [diff] [blame] | 638 | /** Ownership rules for external GPU resources imported into Skia. */ |
| 639 | enum GrWrapOwnership { |
| 640 | /** Skia will assume the client will keep the resource alive and Skia will not free it. */ |
| 641 | kBorrow_GrWrapOwnership, |
| 642 | |
| 643 | /** Skia will assume ownership of the resource and free it. */ |
| 644 | kAdopt_GrWrapOwnership, |
| 645 | }; |
| 646 | |
bsalomon@google.com | e269f21 | 2011-11-07 13:29:52 +0000 | [diff] [blame] | 647 | /////////////////////////////////////////////////////////////////////////////// |
| 648 | |
| 649 | /** |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 650 | * The GrContext's cache of backend context state can be partially invalidated. |
| 651 | * These enums are specific to the GL backend and we'd add a new set for an alternative backend. |
| 652 | */ |
| 653 | enum GrGLBackendState { |
| 654 | kRenderTarget_GrGLBackendState = 1 << 0, |
| 655 | kTextureBinding_GrGLBackendState = 1 << 1, |
| 656 | // View state stands for scissor and viewport |
| 657 | kView_GrGLBackendState = 1 << 2, |
| 658 | kBlend_GrGLBackendState = 1 << 3, |
egdaniel | b414f25 | 2014-07-29 13:15:47 -0700 | [diff] [blame] | 659 | kMSAAEnable_GrGLBackendState = 1 << 4, |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 660 | kVertex_GrGLBackendState = 1 << 5, |
| 661 | kStencil_GrGLBackendState = 1 << 6, |
| 662 | kPixelStore_GrGLBackendState = 1 << 7, |
| 663 | kProgram_GrGLBackendState = 1 << 8, |
commit-bot@chromium.org | 46fbfe0 | 2013-08-30 15:52:12 +0000 | [diff] [blame] | 664 | kFixedFunction_GrGLBackendState = 1 << 9, |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 665 | kMisc_GrGLBackendState = 1 << 10, |
commit-bot@chromium.org | c4dc0ad | 2013-10-09 14:11:33 +0000 | [diff] [blame] | 666 | kPathRendering_GrGLBackendState = 1 << 11, |
bsalomon@google.com | 0a208a1 | 2013-06-28 18:57:35 +0000 | [diff] [blame] | 667 | kALL_GrGLBackendState = 0xffff |
| 668 | }; |
| 669 | |
| 670 | /** |
| 671 | * This value translates to reseting all the context state for any backend. |
| 672 | */ |
| 673 | static const uint32_t kAll_GrBackendState = 0xffffffff; |
| 674 | |
reed@google.com | ac10a2d | 2010-12-22 21:39:39 +0000 | [diff] [blame] | 675 | #endif |