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 "SkTypes.h"
12 #include "GrConfig.h"
13 #include "SkMath.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 \
29 inline X operator & (X a, X b) { \
30 return (X) (+a & +b); \
31 } \
32 template <typename T> \
33 inline X operator & (T a, X b) { \
34 return (X) (+a & +b); \
35 } \
36 template <typename T> \
37 inline X operator & (X a, T b) { \
38 return (X) (+a & +b); \
39 } \
40
41 #define GR_DECL_BITFIELD_OPS_FRIENDS(X) \
42 friend X operator | (X a, X b); \
43 friend X& operator |= (X& a, X b); \
44 \
45 friend X operator & (X a, X b); \
46 \
47 template <typename T> \
48 friend X operator & (T a, X b); \
49 \
50 template <typename T> \
51 friend X operator & (X a, T b); \
52 ////////////////////////////////////////////////////////////////////////////////
53
54 // compile time versions of min/max
55 #define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b))
56 #define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a))
57
58 /**
59 * divide, rounding up
60 */
GrIDivRoundUp(int x,int y)61 static inline int32_t GrIDivRoundUp(int x, int y) {
62 SkASSERT(y > 0);
63 return (x + (y-1)) / y;
64 }
GrUIDivRoundUp(uint32_t x,uint32_t y)65 static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) {
66 return (x + (y-1)) / y;
67 }
GrSizeDivRoundUp(size_t x,size_t y)68 static inline size_t GrSizeDivRoundUp(size_t x, size_t y) {
69 return (x + (y-1)) / y;
70 }
71
72 // compile time, evaluates Y multiple times
73 #define GR_CT_DIV_ROUND_UP(X, Y) (((X) + ((Y)-1)) / (Y))
74
75 /**
76 * align up
77 */
GrUIAlignUp(uint32_t x,uint32_t alignment)78 static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) {
79 return GrUIDivRoundUp(x, alignment) * alignment;
80 }
GrSizeAlignUp(size_t x,size_t alignment)81 static inline size_t GrSizeAlignUp(size_t x, size_t alignment) {
82 return GrSizeDivRoundUp(x, alignment) * alignment;
83 }
84
85 // compile time, evaluates A multiple times
86 #define GR_CT_ALIGN_UP(X, A) (GR_CT_DIV_ROUND_UP((X),(A)) * (A))
87
88 /**
89 * amount of pad needed to align up
90 */
GrUIAlignUpPad(uint32_t x,uint32_t alignment)91 static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) {
92 return (alignment - x % alignment) % alignment;
93 }
GrSizeAlignUpPad(size_t x,size_t alignment)94 static inline size_t GrSizeAlignUpPad(size_t x, size_t alignment) {
95 return (alignment - x % alignment) % alignment;
96 }
97
98 /**
99 * align down
100 */
GrUIAlignDown(uint32_t x,uint32_t alignment)101 static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) {
102 return (x / alignment) * alignment;
103 }
GrSizeAlignDown(size_t x,uint32_t alignment)104 static inline size_t GrSizeAlignDown(size_t x, uint32_t alignment) {
105 return (x / alignment) * alignment;
106 }
107
108 ///////////////////////////////////////////////////////////////////////////////
109
110 /**
111 * Return the next power of 2 >= n.
112 */
GrNextPow2(uint32_t n)113 static inline uint32_t GrNextPow2(uint32_t n) {
114 return n ? (1 << (32 - SkCLZ(n - 1))) : 1;
115 }
116
GrNextPow2(int n)117 static inline int GrNextPow2(int n) {
118 SkASSERT(n >= 0); // this impl only works for non-neg.
119 return n ? (1 << (32 - SkCLZ(n - 1))) : 1;
120 }
121
122 ///////////////////////////////////////////////////////////////////////////////
123
124 /**
125 * Possible 3D APIs that may be used by Ganesh.
126 */
127 enum GrBackend {
128 kOpenGL_GrBackend,
129 kVulkan_GrBackend,
130
131 kLast_GrBackend = kVulkan_GrBackend
132 };
133 const int kBackendCount = kLast_GrBackend + 1;
134
135 /**
136 * Backend-specific 3D context handle
137 * GrGLInterface* for OpenGL. If NULL will use the default GL interface.
138 */
139 typedef intptr_t GrBackendContext;
140
141 ///////////////////////////////////////////////////////////////////////////////
142
143 /**
144 * Geometric primitives used for drawing.
145 */
146 enum GrPrimitiveType {
147 kTriangles_GrPrimitiveType,
148 kTriangleStrip_GrPrimitiveType,
149 kTriangleFan_GrPrimitiveType,
150 kPoints_GrPrimitiveType,
151 kLines_GrPrimitiveType, // 1 pix wide only
152 kLineStrip_GrPrimitiveType, // 1 pix wide only
153 kLast_GrPrimitiveType = kLineStrip_GrPrimitiveType
154 };
155
GrIsPrimTypeLines(GrPrimitiveType type)156 static inline bool GrIsPrimTypeLines(GrPrimitiveType type) {
157 return kLines_GrPrimitiveType == type || kLineStrip_GrPrimitiveType == type;
158 }
159
GrIsPrimTypeTris(GrPrimitiveType type)160 static inline bool GrIsPrimTypeTris(GrPrimitiveType type) {
161 return kTriangles_GrPrimitiveType == type ||
162 kTriangleStrip_GrPrimitiveType == type ||
163 kTriangleFan_GrPrimitiveType == type;
164 }
165
166 /**
167 * Formats for masks, used by the font cache.
168 * Important that these are 0-based.
169 */
170 enum GrMaskFormat {
171 kA8_GrMaskFormat, //!< 1-byte per pixel
172 kA565_GrMaskFormat, //!< 2-bytes per pixel, RGB represent 3-channel LCD coverage
173 kARGB_GrMaskFormat, //!< 4-bytes per pixel, color format
174
175 kLast_GrMaskFormat = kARGB_GrMaskFormat
176 };
177 static const int kMaskFormatCount = kLast_GrMaskFormat + 1;
178
179 /**
180 * Return the number of bytes-per-pixel for the specified mask format.
181 */
GrMaskFormatBytesPerPixel(GrMaskFormat format)182 static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
183 SkASSERT(format < kMaskFormatCount);
184 // kA8 (0) -> 1
185 // kA565 (1) -> 2
186 // kARGB (2) -> 4
187 static const int sBytesPerPixel[] = { 1, 2, 4 };
188 static_assert(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount, "array_size_mismatch");
189 static_assert(kA8_GrMaskFormat == 0, "enum_order_dependency");
190 static_assert(kA565_GrMaskFormat == 1, "enum_order_dependency");
191 static_assert(kARGB_GrMaskFormat == 2, "enum_order_dependency");
192
193 return sBytesPerPixel[(int) format];
194 }
195
196 /**
197 * Pixel configurations.
198 */
199 enum GrPixelConfig {
200 kUnknown_GrPixelConfig,
201 kAlpha_8_GrPixelConfig,
202 kIndex_8_GrPixelConfig,
203 kRGB_565_GrPixelConfig,
204 /**
205 * Premultiplied
206 */
207 kRGBA_4444_GrPixelConfig,
208 /**
209 * Premultiplied. Byte order is r,g,b,a.
210 */
211 kRGBA_8888_GrPixelConfig,
212 /**
213 * Premultiplied. Byte order is b,g,r,a.
214 */
215 kBGRA_8888_GrPixelConfig,
216 /**
217 * Premultiplied and sRGB. Byte order is r,g,b,a.
218 */
219 kSRGBA_8888_GrPixelConfig,
220 /**
221 * ETC1 Compressed Data
222 */
223 kETC1_GrPixelConfig,
224 /**
225 * LATC/RGTC/3Dc/BC4 Compressed Data
226 */
227 kLATC_GrPixelConfig,
228 /**
229 * R11 EAC Compressed Data
230 * (Corresponds to section C.3.5 of the OpenGL 4.4 core profile spec)
231 */
232 kR11_EAC_GrPixelConfig,
233
234 /**
235 * 12x12 ASTC Compressed Data
236 * ASTC stands for Adaptive Scalable Texture Compression. It is a technique
237 * that allows for a lot of customization in the compressed representataion
238 * of a block. The only thing fixed in the representation is the block size,
239 * which means that a texture that contains ASTC data must be treated as
240 * having RGBA values. However, there are single-channel encodings which set
241 * the alpha to opaque and all three RGB channels equal effectively making the
242 * compression format a single channel such as R11 EAC and LATC.
243 */
244 kASTC_12x12_GrPixelConfig,
245
246 /**
247 * Byte order is r, g, b, a. This color format is 32 bits per channel
248 */
249 kRGBA_float_GrPixelConfig,
250
251 /**
252 * This color format is a single 16 bit float channel
253 */
254 kAlpha_half_GrPixelConfig,
255
256 /**
257 * Byte order is r, g, b, a. This color format is 16 bits per channel
258 */
259 kRGBA_half_GrPixelConfig,
260
261 kLast_GrPixelConfig = kRGBA_half_GrPixelConfig
262 };
263 static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1;
264
265 // Aliases for pixel configs that match skia's byte order.
266 #ifndef SK_CPU_LENDIAN
267 #error "Skia gpu currently assumes little endian"
268 #endif
269 #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
270 static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig;
271 #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
272 static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig;
273 #else
274 #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format."
275 #endif
276
277 // Returns true if the pixel config is a GPU-specific compressed format
278 // representation.
GrPixelConfigIsCompressed(GrPixelConfig config)279 static inline bool GrPixelConfigIsCompressed(GrPixelConfig config) {
280 switch (config) {
281 case kIndex_8_GrPixelConfig:
282 case kETC1_GrPixelConfig:
283 case kLATC_GrPixelConfig:
284 case kR11_EAC_GrPixelConfig:
285 case kASTC_12x12_GrPixelConfig:
286 return true;
287 default:
288 return false;
289 }
290 }
291
292 /** If the pixel config is compressed, return an equivalent uncompressed format. */
GrMakePixelConfigUncompressed(GrPixelConfig config)293 static inline GrPixelConfig GrMakePixelConfigUncompressed(GrPixelConfig config) {
294 switch (config) {
295 case kIndex_8_GrPixelConfig:
296 case kETC1_GrPixelConfig:
297 case kASTC_12x12_GrPixelConfig:
298 return kRGBA_8888_GrPixelConfig;
299 case kLATC_GrPixelConfig:
300 case kR11_EAC_GrPixelConfig:
301 return kAlpha_8_GrPixelConfig;
302 default:
303 SkASSERT(!GrPixelConfigIsCompressed(config));
304 return config;
305 }
306 }
307
308 // Returns true if the pixel config is 32 bits per pixel
GrPixelConfigIs8888(GrPixelConfig config)309 static inline bool GrPixelConfigIs8888(GrPixelConfig config) {
310 switch (config) {
311 case kRGBA_8888_GrPixelConfig:
312 case kBGRA_8888_GrPixelConfig:
313 case kSRGBA_8888_GrPixelConfig:
314 return true;
315 default:
316 return false;
317 }
318 }
319
320 // Returns true if the color (non-alpha) components represent sRGB values. It does NOT indicate that
321 // all three color components are present in the config or anything about their order.
GrPixelConfigIsSRGB(GrPixelConfig config)322 static inline bool GrPixelConfigIsSRGB(GrPixelConfig config) {
323 switch (config) {
324 case kSRGBA_8888_GrPixelConfig:
325 return true;
326 default:
327 return false;
328 }
329 }
330
331 // Takes a config and returns the equivalent config with the R and B order
332 // swapped if such a config exists. Otherwise, kUnknown_GrPixelConfig
GrPixelConfigSwapRAndB(GrPixelConfig config)333 static inline GrPixelConfig GrPixelConfigSwapRAndB(GrPixelConfig config) {
334 switch (config) {
335 case kBGRA_8888_GrPixelConfig:
336 return kRGBA_8888_GrPixelConfig;
337 case kRGBA_8888_GrPixelConfig:
338 return kBGRA_8888_GrPixelConfig;
339 default:
340 return kUnknown_GrPixelConfig;
341 }
342 }
343
GrBytesPerPixel(GrPixelConfig config)344 static inline size_t GrBytesPerPixel(GrPixelConfig config) {
345 SkASSERT(!GrPixelConfigIsCompressed(config));
346 switch (config) {
347 case kAlpha_8_GrPixelConfig:
348 return 1;
349 case kRGB_565_GrPixelConfig:
350 case kRGBA_4444_GrPixelConfig:
351 case kAlpha_half_GrPixelConfig:
352 return 2;
353 case kRGBA_8888_GrPixelConfig:
354 case kBGRA_8888_GrPixelConfig:
355 case kSRGBA_8888_GrPixelConfig:
356 return 4;
357 case kRGBA_half_GrPixelConfig:
358 return 8;
359 case kRGBA_float_GrPixelConfig:
360 return 16;
361 default:
362 return 0;
363 }
364 }
365
GrPixelConfigIsOpaque(GrPixelConfig config)366 static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) {
367 switch (config) {
368 case kETC1_GrPixelConfig:
369 case kRGB_565_GrPixelConfig:
370 return true;
371 default:
372 return false;
373 }
374 }
375
GrPixelConfigIsAlphaOnly(GrPixelConfig config)376 static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) {
377 switch (config) {
378 case kR11_EAC_GrPixelConfig:
379 case kLATC_GrPixelConfig:
380 case kASTC_12x12_GrPixelConfig:
381 case kAlpha_8_GrPixelConfig:
382 case kAlpha_half_GrPixelConfig:
383 return true;
384 default:
385 return false;
386 }
387 }
388
389 /**
390 * Optional bitfield flags that can be set on GrSurfaceDesc (below).
391 */
392 enum GrSurfaceFlags {
393 kNone_GrSurfaceFlags = 0x0,
394 /**
395 * Creates a texture that can be rendered to as a GrRenderTarget. Use
396 * GrTexture::asRenderTarget() to access.
397 */
398 kRenderTarget_GrSurfaceFlag = 0x1,
399 /**
400 * Placeholder for managing zero-copy textures
401 */
402 kZeroCopy_GrSurfaceFlag = 0x2,
403 /**
404 * Indicates that all allocations (color buffer, FBO completeness, etc)
405 * should be verified.
406 */
407 kCheckAllocation_GrSurfaceFlag = 0x4,
408 };
409
410 GR_MAKE_BITFIELD_OPS(GrSurfaceFlags)
411
412 // opaque type for 3D API object handles
413 typedef intptr_t GrBackendObject;
414
415 /**
416 * Some textures will be stored such that the upper and left edges of the content meet at the
417 * the origin (in texture coord space) and for other textures the lower and left edges meet at
418 * the origin. kDefault_GrSurfaceOrigin sets textures to TopLeft, and render targets
419 * to BottomLeft.
420 */
421
422 enum GrSurfaceOrigin {
423 kDefault_GrSurfaceOrigin, // DEPRECATED; to be removed
424 kTopLeft_GrSurfaceOrigin,
425 kBottomLeft_GrSurfaceOrigin,
426 };
427
428 /**
429 * An container of function pointers which consumers of Skia can fill in and
430 * pass to Skia. Skia will use these function pointers in place of its backend
431 * API texture creation function. Either all of the function pointers should be
432 * filled in, or they should all be nullptr.
433 */
434 struct GrTextureStorageAllocator {
GrTextureStorageAllocatorGrTextureStorageAllocator435 GrTextureStorageAllocator()
436 : fAllocateTextureStorage(nullptr)
437 , fDeallocateTextureStorage(nullptr) {
438 }
439
440 enum class Result {
441 kSucceededAndUploaded,
442 kSucceededWithoutUpload,
443 kFailed
444 };
445 typedef Result (*AllocateTextureStorageProc)(
446 void* ctx, GrBackendObject texture, unsigned width,
447 unsigned height, GrPixelConfig config, const void* srcData, GrSurfaceOrigin);
448 typedef void (*DeallocateTextureStorageProc)(void* ctx, GrBackendObject texture);
449
450 /*
451 * Generates and binds a texture to |textureStorageTarget()|. Allocates
452 * storage for the texture.
453 *
454 * In OpenGL, the MIN and MAX filters for the created texture must be
455 * GL_LINEAR. The WRAP_S and WRAP_T must be GL_CLAMP_TO_EDGE.
456 *
457 * If |srcData| is not nullptr, then the implementation of this function
458 * may attempt to upload the data into the texture. On successful upload,
459 * or if |srcData| is nullptr, returns kSucceededAndUploaded.
460 */
461 AllocateTextureStorageProc fAllocateTextureStorage;
462
463 /*
464 * Deallocate the storage for the given texture.
465 *
466 * Skia does not always destroy its outstanding textures. See
467 * GrContext::abandonContext() for more details. The consumer of Skia is
468 * responsible for making sure that all textures are destroyed, even if this
469 * callback is not invoked.
470 */
471 DeallocateTextureStorageProc fDeallocateTextureStorage;
472
473 /*
474 * The context to use when invoking fAllocateTextureStorage and
475 * fDeallocateTextureStorage.
476 */
477 void* fCtx;
478 };
479
480 /**
481 * Describes a surface to be created.
482 */
483 struct GrSurfaceDesc {
GrSurfaceDescGrSurfaceDesc484 GrSurfaceDesc()
485 : fFlags(kNone_GrSurfaceFlags)
486 , fOrigin(kDefault_GrSurfaceOrigin)
487 , fWidth(0)
488 , fHeight(0)
489 , fConfig(kUnknown_GrPixelConfig)
490 , fSampleCnt(0) {
491 }
492
493 GrSurfaceFlags fFlags; //!< bitfield of TextureFlags
494 GrSurfaceOrigin fOrigin; //!< origin of the texture
495 int fWidth; //!< Width of the texture
496 int fHeight; //!< Height of the texture
497
498 /**
499 * Format of source data of the texture. Not guaranteed to be the same as
500 * internal format used by 3D API.
501 */
502 GrPixelConfig fConfig;
503
504 /**
505 * The number of samples per pixel or 0 to disable full scene AA. This only
506 * applies if the kRenderTarget_GrSurfaceFlag is set. The actual number
507 * of samples may not exactly match the request. The request will be rounded
508 * up to the next supported sample count, or down if it is larger than the
509 * max supported count.
510 */
511 int fSampleCnt;
512
513 /**
514 * A custom platform-specific allocator to use in place of the backend APIs
515 * usual texture creation method (e.g. TexImage2D in OpenGL).
516 */
517 GrTextureStorageAllocator fTextureStorageAllocator;
518 };
519
520 // Legacy alias
521 typedef GrSurfaceDesc GrTextureDesc;
522
523 /**
524 * Clips are composed from these objects.
525 */
526 enum GrClipType {
527 kRect_ClipType,
528 kPath_ClipType
529 };
530
531 ///////////////////////////////////////////////////////////////////////////////
532
533
534 /** Ownership rules for external GPU resources imported into Skia. */
535 enum GrWrapOwnership {
536 /** Skia will assume the client will keep the resource alive and Skia will not free it. */
537 kBorrow_GrWrapOwnership,
538
539 /** Skia will assume ownership of the resource and free it. */
540 kAdopt_GrWrapOwnership,
541 };
542
543 /**
544 * Gr can wrap an existing texture created by the client with a GrTexture
545 * object. The client is responsible for ensuring that the texture lives at
546 * least as long as the GrTexture object wrapping it. We require the client to
547 * explicitly provide information about the texture, such as width, height,
548 * and pixel config, rather than querying the 3D APIfor these values. We expect
549 * these to be immutable even if the 3D API doesn't require this (OpenGL).
550 *
551 * Textures that are also render targets are supported as well. Gr will manage
552 * any ancillary 3D API (stencil buffer, FBO id, etc) objects necessary for
553 * Gr to draw into the render target. To access the render target object
554 * call GrTexture::asRenderTarget().
555 *
556 * If in addition to the render target flag, the caller also specifies a sample
557 * count Gr will create an MSAA buffer that resolves into the texture. Gr auto-
558 * resolves when it reads from the texture. The client can explictly resolve
559 * using the GrRenderTarget interface.
560 *
561 * Note: These flags currently form a subset of GrTexture's flags.
562 */
563
564 enum GrBackendTextureFlags {
565 /**
566 * No flags enabled
567 */
568 kNone_GrBackendTextureFlag = 0,
569 /**
570 * Indicates that the texture is also a render target, and thus should have
571 * a GrRenderTarget object.
572 */
573 kRenderTarget_GrBackendTextureFlag = kRenderTarget_GrSurfaceFlag,
574 };
575 GR_MAKE_BITFIELD_OPS(GrBackendTextureFlags)
576
577 struct GrBackendTextureDesc {
GrBackendTextureDescGrBackendTextureDesc578 GrBackendTextureDesc() { memset(this, 0, sizeof(*this)); }
579 GrBackendTextureFlags fFlags;
580 GrSurfaceOrigin fOrigin;
581 int fWidth; //<! width in pixels
582 int fHeight; //<! height in pixels
583 GrPixelConfig fConfig; //<! color format
584 /**
585 * If the render target flag is set and sample count is greater than 0
586 * then Gr will create an MSAA buffer that resolves to the texture.
587 */
588 int fSampleCnt;
589 /**
590 * Handle to the 3D API object.
591 * OpenGL: Texture ID.
592 */
593 GrBackendObject fTextureHandle;
594 };
595
596 ///////////////////////////////////////////////////////////////////////////////
597
598 /**
599 * Gr can wrap an existing render target created by the client in the 3D API
600 * with a GrRenderTarget object. The client is responsible for ensuring that the
601 * underlying 3D API object lives at least as long as the GrRenderTarget object
602 * wrapping it. We require the client to explicitly provide information about
603 * the target, such as width, height, and pixel config rather than querying the
604 * 3D API for these values. We expect these properties to be immutable even if
605 * the 3D API doesn't require this (OpenGL).
606 */
607
608 struct GrBackendRenderTargetDesc {
GrBackendRenderTargetDescGrBackendRenderTargetDesc609 GrBackendRenderTargetDesc() { memset(this, 0, sizeof(*this)); }
610 int fWidth; //<! width in pixels
611 int fHeight; //<! height in pixels
612 GrPixelConfig fConfig; //<! color format
613 GrSurfaceOrigin fOrigin; //<! pixel origin
614 /**
615 * The number of samples per pixel. Gr uses this to influence decisions
616 * about applying other forms of anti-aliasing.
617 */
618 int fSampleCnt;
619 /**
620 * Number of bits of stencil per-pixel.
621 */
622 int fStencilBits;
623 /**
624 * Handle to the 3D API object.
625 * OpenGL: FBO ID
626 */
627 GrBackendObject fRenderTargetHandle;
628 };
629
630 /**
631 * The GrContext's cache of backend context state can be partially invalidated.
632 * These enums are specific to the GL backend and we'd add a new set for an alternative backend.
633 */
634 enum GrGLBackendState {
635 kRenderTarget_GrGLBackendState = 1 << 0,
636 kTextureBinding_GrGLBackendState = 1 << 1,
637 // View state stands for scissor and viewport
638 kView_GrGLBackendState = 1 << 2,
639 kBlend_GrGLBackendState = 1 << 3,
640 kMSAAEnable_GrGLBackendState = 1 << 4,
641 kVertex_GrGLBackendState = 1 << 5,
642 kStencil_GrGLBackendState = 1 << 6,
643 kPixelStore_GrGLBackendState = 1 << 7,
644 kProgram_GrGLBackendState = 1 << 8,
645 kFixedFunction_GrGLBackendState = 1 << 9,
646 kMisc_GrGLBackendState = 1 << 10,
647 kPathRendering_GrGLBackendState = 1 << 11,
648 kALL_GrGLBackendState = 0xffff
649 };
650
651 /**
652 * Returns the data size for the given compressed pixel config
653 */
GrCompressedFormatDataSize(GrPixelConfig config,int width,int height)654 static inline size_t GrCompressedFormatDataSize(GrPixelConfig config,
655 int width, int height) {
656 SkASSERT(GrPixelConfigIsCompressed(config));
657 static const int kGrIndex8TableSize = 256 * 4; // 4 == sizeof(GrColor)
658
659 switch (config) {
660 case kIndex_8_GrPixelConfig:
661 return width * height + kGrIndex8TableSize;
662 case kR11_EAC_GrPixelConfig:
663 case kLATC_GrPixelConfig:
664 case kETC1_GrPixelConfig:
665 SkASSERT((width & 3) == 0);
666 SkASSERT((height & 3) == 0);
667 return (width >> 2) * (height >> 2) * 8;
668
669 case kASTC_12x12_GrPixelConfig:
670 SkASSERT((width % 12) == 0);
671 SkASSERT((height % 12) == 0);
672 return (width / 12) * (height / 12) * 16;
673
674 default:
675 SkFAIL("Unknown compressed pixel config");
676 return 4 * width * height;
677 }
678 }
679
680 /**
681 * This value translates to reseting all the context state for any backend.
682 */
683 static const uint32_t kAll_GrBackendState = 0xffffffff;
684
685 #endif
686