Line data Source code
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 0 : static inline size_t GrSizeDivRoundUp(size_t x, size_t y) {
143 0 : 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 0 : static inline size_t GrSizeAlignUp(size_t x, size_t alignment) {
156 0 : 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 0 : static inline size_t GrSizeAlignUpPad(size_t x, size_t alignment) {
169 0 : 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 0 : 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 0 : static inline bool GrIsPrimTypeLines(GrPrimitiveType type) {
230 0 : 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 0 : static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
256 0 : 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 0 : 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 0 : static inline bool GrPixelConfigIsCompressed(GrPixelConfig config) {
343 0 : switch (config) {
344 : case kETC1_GrPixelConfig:
345 0 : 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 0 : return false;
361 : }
362 0 : SkFAIL("Invalid pixel config");
363 0 : return false;
364 : }
365 :
366 : /** If the pixel config is compressed, return an equivalent uncompressed format. */
367 0 : static inline GrPixelConfig GrMakePixelConfigUncompressed(GrPixelConfig config) {
368 0 : switch (config) {
369 : case kETC1_GrPixelConfig:
370 0 : 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 0 : SkASSERT(!GrPixelConfigIsCompressed(config));
386 0 : return config;
387 : }
388 0 : SkFAIL("Invalid pixel config");
389 0 : return config;
390 : }
391 :
392 : // Returns true if the pixel config is 32 bits per pixel
393 0 : static inline bool GrPixelConfigIs8888Unorm(GrPixelConfig config) {
394 0 : switch (config) {
395 : case kRGBA_8888_GrPixelConfig:
396 : case kBGRA_8888_GrPixelConfig:
397 : case kSRGBA_8888_GrPixelConfig:
398 : case kSBGRA_8888_GrPixelConfig:
399 0 : 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 0 : return false;
412 : }
413 0 : SkFAIL("Invalid pixel config");
414 0 : 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 0 : static inline bool GrPixelConfigIsSRGB(GrPixelConfig config) {
420 0 : switch (config) {
421 : case kSRGBA_8888_GrPixelConfig:
422 : case kSBGRA_8888_GrPixelConfig:
423 0 : 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 0 : return false;
438 : }
439 0 : SkFAIL("Invalid pixel config");
440 0 : 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 0 : static inline GrPixelConfig GrPixelConfigSwapRAndB(GrPixelConfig config) {
446 0 : switch (config) {
447 : case kBGRA_8888_GrPixelConfig:
448 0 : return kRGBA_8888_GrPixelConfig;
449 : case kRGBA_8888_GrPixelConfig:
450 0 : return kBGRA_8888_GrPixelConfig;
451 : case kSBGRA_8888_GrPixelConfig:
452 0 : return kSRGBA_8888_GrPixelConfig;
453 : case kSRGBA_8888_GrPixelConfig:
454 0 : 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 0 : return kUnknown_GrPixelConfig;
467 : }
468 0 : SkFAIL("Invalid pixel config");
469 0 : return kUnknown_GrPixelConfig;
470 : }
471 :
472 0 : static inline size_t GrBytesPerPixel(GrPixelConfig config) {
473 0 : SkASSERT(!GrPixelConfigIsCompressed(config));
474 0 : switch (config) {
475 : case kAlpha_8_GrPixelConfig:
476 : case kGray_8_GrPixelConfig:
477 0 : return 1;
478 : case kRGB_565_GrPixelConfig:
479 : case kRGBA_4444_GrPixelConfig:
480 : case kAlpha_half_GrPixelConfig:
481 0 : 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 0 : return 4;
488 : case kRGBA_half_GrPixelConfig:
489 0 : return 8;
490 : case kRGBA_float_GrPixelConfig:
491 0 : return 16;
492 : case kRG_float_GrPixelConfig:
493 0 : return 8;
494 : case kUnknown_GrPixelConfig:
495 : case kETC1_GrPixelConfig:
496 0 : return 0;
497 : }
498 0 : SkFAIL("Invalid pixel config");
499 0 : return 0;
500 : }
501 :
502 0 : static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) {
503 0 : switch (config) {
504 : case kETC1_GrPixelConfig:
505 : case kRGB_565_GrPixelConfig:
506 : case kGray_8_GrPixelConfig:
507 0 : 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 0 : return false;
521 : }
522 0 : SkFAIL("Invalid pixel config");
523 0 : return false;
524 : }
525 :
526 0 : static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) {
527 0 : switch (config) {
528 : case kAlpha_8_GrPixelConfig:
529 : case kAlpha_half_GrPixelConfig:
530 0 : 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 0 : return false;
545 : }
546 0 : SkFAIL("Invalid pixel config.");
547 0 : return false;
548 : }
549 :
550 0 : static inline bool GrPixelConfigIsFloatingPoint(GrPixelConfig config) {
551 0 : switch (config) {
552 : case kRGBA_float_GrPixelConfig:
553 : case kRG_float_GrPixelConfig:
554 : case kAlpha_half_GrPixelConfig:
555 : case kRGBA_half_GrPixelConfig:
556 0 : 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 0 : return false;
569 : }
570 0 : SkFAIL("Invalid pixel config");
571 0 : return false;
572 : }
573 :
574 0 : static inline bool GrPixelConfigIsSint(GrPixelConfig config) {
575 0 : 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 0 : 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 0 : GrSurfaceDesc()
627 0 : : fFlags(kNone_GrSurfaceFlags)
628 : , fOrigin(kDefault_GrSurfaceOrigin)
629 : , fWidth(0)
630 : , fHeight(0)
631 : , fConfig(kUnknown_GrPixelConfig)
632 : , fSampleCnt(0)
633 0 : , fIsMipMapped(false) {
634 0 : }
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 0 : GR_MAKE_BITFIELD_OPS(GrBackendTextureFlags)
717 :
718 : struct GrBackendTextureDesc {
719 0 : 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 0 : static inline size_t GrCompressedFormatDataSize(GrPixelConfig config,
798 : int width, int height) {
799 0 : SkASSERT(GrPixelConfigIsCompressed(config));
800 :
801 0 : switch (config) {
802 : case kETC1_GrPixelConfig:
803 0 : SkASSERT((width & 3) == 0);
804 0 : SkASSERT((height & 3) == 0);
805 0 : 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 0 : SkFAIL("Unknown compressed pixel config");
822 0 : return 4 * width * height;
823 : }
824 :
825 0 : SkFAIL("Invalid pixel config");
826 0 : 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
|
