8 #ifndef GrTypes_DEFINED
9 #define GrTypes_DEFINED
21 #define GR_MAKE_BITFIELD_OPS(X) \
22 inline X operator | (X a, X b) { \
23 return (X) (+a | +b); \
25 inline X& operator |= (X& a, X b) { \
29 inline X operator & (X a, X b) { \
30 return (X) (+a & +b); \
32 template <typename T> \
33 inline X operator & (T a, X b) { \
34 return (X) (+a & +b); \
36 template <typename T> \
37 inline X operator & (X a, T b) { \
38 return (X) (+a & +b); \
41 #define GR_DECL_BITFIELD_OPS_FRIENDS(X) \
42 friend X operator | (X a, X b); \
43 friend X& operator |= (X& a, X b); \
45 friend X operator & (X a, X b); \
47 template <typename T> \
48 friend X operator & (T a, X b); \
50 template <typename T> \
51 friend X operator & (X a, T b); \
57 #define GR_MAKE_BITFIELD_CLASS_OPS(X) \
58 inline X operator | (X a, X b) { \
59 return (X) ((int)a | (int)b); \
61 inline X& operator |= (X& a, X b) { \
64 inline bool operator & (X a, X b) { \
65 return SkToBool((int)a & (int)b); \
68 #define GR_DECL_BITFIELD_CLASS_OPS_FRIENDS(X) \
69 friend X operator | (X a, X b); \
70 friend X& operator |= (X& a, X b); \
71 friend bool operator & (X a, X b);
76 #define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b))
77 #define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a))
82 static inline int32_t GrIDivRoundUp(
int x,
int y) {
84 return (x + (y-1)) / y;
86 static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) {
87 return (x + (y-1)) / y;
89 static inline size_t GrSizeDivRoundUp(
size_t x,
size_t y) {
90 return (x + (y-1)) / y;
94 #define GR_CT_DIV_ROUND_UP(X, Y) (((X) + ((Y)-1)) / (Y))
99 static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) {
100 return GrUIDivRoundUp(x, alignment) * alignment;
102 static inline size_t GrSizeAlignUp(
size_t x,
size_t alignment) {
103 return GrSizeDivRoundUp(x, alignment) * alignment;
107 #define GR_CT_ALIGN_UP(X, A) (GR_CT_DIV_ROUND_UP((X),(A)) * (A))
112 static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) {
113 return (alignment - x % alignment) % alignment;
115 static inline size_t GrSizeAlignUpPad(
size_t x,
size_t alignment) {
116 return (alignment - x % alignment) % alignment;
122 static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) {
123 return (x / alignment) * alignment;
125 static inline size_t GrSizeAlignDown(
size_t x, uint32_t alignment) {
126 return (x / alignment) * alignment;
138 kLast_GrBackend = kVulkan_GrBackend
140 const int kBackendCount = kLast_GrBackend + 1;
146 typedef intptr_t GrBackendContext;
153 enum GrPrimitiveType {
154 kTriangles_GrPrimitiveType,
155 kTriangleStrip_GrPrimitiveType,
156 kTriangleFan_GrPrimitiveType,
157 kPoints_GrPrimitiveType,
158 kLines_GrPrimitiveType,
159 kLineStrip_GrPrimitiveType,
160 kLast_GrPrimitiveType = kLineStrip_GrPrimitiveType
163 static inline bool GrIsPrimTypeLines(GrPrimitiveType type) {
164 return kLines_GrPrimitiveType == type || kLineStrip_GrPrimitiveType == type;
167 static inline bool GrIsPrimTypeTris(GrPrimitiveType type) {
168 return kTriangles_GrPrimitiveType == type ||
169 kTriangleStrip_GrPrimitiveType == type ||
170 kTriangleFan_GrPrimitiveType == type;
182 kLast_GrMaskFormat = kARGB_GrMaskFormat
184 static const int kMaskFormatCount = kLast_GrMaskFormat + 1;
189 static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
190 SkASSERT(format < kMaskFormatCount);
194 static const int sBytesPerPixel[] = { 1, 2, 4 };
195 static_assert(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount,
"array_size_mismatch");
196 static_assert(kA8_GrMaskFormat == 0,
"enum_order_dependency");
197 static_assert(kA565_GrMaskFormat == 1,
"enum_order_dependency");
198 static_assert(kARGB_GrMaskFormat == 2,
"enum_order_dependency");
200 return sBytesPerPixel[(int) format];
207 kUnknown_GrPixelConfig,
208 kAlpha_8_GrPixelConfig,
209 kIndex_8_GrPixelConfig,
210 kRGB_565_GrPixelConfig,
214 kRGBA_4444_GrPixelConfig,
218 kRGBA_8888_GrPixelConfig,
222 kBGRA_8888_GrPixelConfig,
226 kSRGBA_8888_GrPixelConfig,
230 kSBGRA_8888_GrPixelConfig,
243 kR11_EAC_GrPixelConfig,
255 kASTC_12x12_GrPixelConfig,
260 kRGBA_float_GrPixelConfig,
265 kAlpha_half_GrPixelConfig,
270 kRGBA_half_GrPixelConfig,
272 kLast_GrPixelConfig = kRGBA_half_GrPixelConfig
274 static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1;
277 #ifndef SK_CPU_LENDIAN
278 #error "Skia gpu currently assumes little endian"
280 #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
281 static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig;
282 static const GrPixelConfig kSkiaGamma8888_GrPixelConfig = kSBGRA_8888_GrPixelConfig;
283 #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
284 static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig;
285 static const GrPixelConfig kSkiaGamma8888_GrPixelConfig = kSRGBA_8888_GrPixelConfig;
287 #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format."
292 static inline bool GrPixelConfigIsCompressed(GrPixelConfig config) {
294 case kIndex_8_GrPixelConfig:
295 case kETC1_GrPixelConfig:
296 case kLATC_GrPixelConfig:
297 case kR11_EAC_GrPixelConfig:
298 case kASTC_12x12_GrPixelConfig:
306 static inline GrPixelConfig GrMakePixelConfigUncompressed(GrPixelConfig config) {
308 case kIndex_8_GrPixelConfig:
309 case kETC1_GrPixelConfig:
310 case kASTC_12x12_GrPixelConfig:
311 return kRGBA_8888_GrPixelConfig;
312 case kLATC_GrPixelConfig:
313 case kR11_EAC_GrPixelConfig:
314 return kAlpha_8_GrPixelConfig;
316 SkASSERT(!GrPixelConfigIsCompressed(config));
322 static inline bool GrPixelConfigIs8888(GrPixelConfig config) {
324 case kRGBA_8888_GrPixelConfig:
325 case kBGRA_8888_GrPixelConfig:
326 case kSRGBA_8888_GrPixelConfig:
327 case kSBGRA_8888_GrPixelConfig:
336 static inline bool GrPixelConfigIsSRGB(GrPixelConfig config) {
338 case kSRGBA_8888_GrPixelConfig:
339 case kSBGRA_8888_GrPixelConfig:
348 static inline GrPixelConfig GrPixelConfigSwapRAndB(GrPixelConfig config) {
350 case kBGRA_8888_GrPixelConfig:
351 return kRGBA_8888_GrPixelConfig;
352 case kRGBA_8888_GrPixelConfig:
353 return kBGRA_8888_GrPixelConfig;
354 case kSBGRA_8888_GrPixelConfig:
355 return kSRGBA_8888_GrPixelConfig;
356 case kSRGBA_8888_GrPixelConfig:
357 return kSBGRA_8888_GrPixelConfig;
359 return kUnknown_GrPixelConfig;
363 static inline size_t GrBytesPerPixel(GrPixelConfig config) {
364 SkASSERT(!GrPixelConfigIsCompressed(config));
366 case kAlpha_8_GrPixelConfig:
368 case kRGB_565_GrPixelConfig:
369 case kRGBA_4444_GrPixelConfig:
370 case kAlpha_half_GrPixelConfig:
372 case kRGBA_8888_GrPixelConfig:
373 case kBGRA_8888_GrPixelConfig:
374 case kSRGBA_8888_GrPixelConfig:
375 case kSBGRA_8888_GrPixelConfig:
377 case kRGBA_half_GrPixelConfig:
379 case kRGBA_float_GrPixelConfig:
386 static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) {
388 case kETC1_GrPixelConfig:
389 case kRGB_565_GrPixelConfig:
396 static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) {
398 case kR11_EAC_GrPixelConfig:
399 case kLATC_GrPixelConfig:
400 case kASTC_12x12_GrPixelConfig:
401 case kAlpha_8_GrPixelConfig:
402 case kAlpha_half_GrPixelConfig:
409 static inline bool GrPixelConfigIsFloatingPoint(GrPixelConfig config) {
411 case kRGBA_float_GrPixelConfig:
412 case kAlpha_half_GrPixelConfig:
413 case kRGBA_half_GrPixelConfig:
423 enum GrSurfaceFlags {
424 kNone_GrSurfaceFlags = 0x0,
429 kRenderTarget_GrSurfaceFlag = 0x1,
433 kZeroCopy_GrSurfaceFlag = 0x2,
438 kCheckAllocation_GrSurfaceFlag = 0x4,
441 GR_MAKE_BITFIELD_OPS(GrSurfaceFlags)
444 typedef intptr_t GrBackendObject;
453 enum GrSurfaceOrigin {
454 kDefault_GrSurfaceOrigin,
455 kTopLeft_GrSurfaceOrigin,
456 kBottomLeft_GrSurfaceOrigin,
469 :
fFlags(kNone_GrSurfaceFlags)
470 ,
fOrigin(kDefault_GrSurfaceOrigin)
473 ,
fConfig(kUnknown_GrPixelConfig)
515 enum GrWrapOwnership {
517 kBorrow_GrWrapOwnership,
520 kAdopt_GrWrapOwnership,
544 enum GrBackendTextureFlags {
548 kNone_GrBackendTextureFlag = 0,
553 kRenderTarget_GrBackendTextureFlag = kRenderTarget_GrSurfaceFlag,
555 GR_MAKE_BITFIELD_OPS(GrBackendTextureFlags)
558 GrBackendTextureDesc() { memset(
this, 0,
sizeof(*
this)); }
559 GrBackendTextureFlags fFlags;
560 GrSurfaceOrigin fOrigin;
563 GrPixelConfig fConfig;
592 GrPixelConfig fConfig;
593 GrSurfaceOrigin fOrigin;
614 enum GrGLBackendState {
615 kRenderTarget_GrGLBackendState = 1 << 0,
616 kTextureBinding_GrGLBackendState = 1 << 1,
618 kView_GrGLBackendState = 1 << 2,
619 kBlend_GrGLBackendState = 1 << 3,
620 kMSAAEnable_GrGLBackendState = 1 << 4,
621 kVertex_GrGLBackendState = 1 << 5,
622 kStencil_GrGLBackendState = 1 << 6,
623 kPixelStore_GrGLBackendState = 1 << 7,
624 kProgram_GrGLBackendState = 1 << 8,
625 kFixedFunction_GrGLBackendState = 1 << 9,
626 kMisc_GrGLBackendState = 1 << 10,
627 kPathRendering_GrGLBackendState = 1 << 11,
628 kALL_GrGLBackendState = 0xffff
634 static inline size_t GrCompressedFormatDataSize(GrPixelConfig config,
635 int width,
int height) {
636 SkASSERT(GrPixelConfigIsCompressed(config));
637 static const int kGrIndex8TableSize = 256 * 4;
640 case kIndex_8_GrPixelConfig:
641 return width * height + kGrIndex8TableSize;
642 case kR11_EAC_GrPixelConfig:
643 case kLATC_GrPixelConfig:
644 case kETC1_GrPixelConfig:
645 SkASSERT((width & 3) == 0);
646 SkASSERT((height & 3) == 0);
647 return (width >> 2) * (height >> 2) * 8;
649 case kASTC_12x12_GrPixelConfig:
650 SkASSERT((width % 12) == 0);
651 SkASSERT((height % 12) == 0);
652 return (width / 12) * (height / 12) * 16;
655 SkFAIL(
"Unknown compressed pixel config");
656 return 4 * width * height;
663 static const uint32_t kAll_GrBackendState = 0xffffffff;
int fWidth
Width of the texture.
Definition: GrTypes.h:480
Definition: GrTypes.h:557
int fSampleCnt
The number of samples per pixel.
Definition: GrTypes.h:598
GrBackendObject fTextureHandle
Handle to the 3D API object.
Definition: GrTypes.h:573
Describes a surface to be created.
Definition: GrTypes.h:467
int fHeight
Height of the texture.
Definition: GrTypes.h:481
Gr can wrap an existing render target created by the client in the 3D API with a GrRenderTarget objec...
Definition: GrTypes.h:588
int fStencilBits
Number of bits of stencil per-pixel.
Definition: GrTypes.h:602
GrPixelConfig fConfig
Format of source data of the texture.
Definition: GrTypes.h:487
Definition: GrTypes.h:459
bool fIsMipMapped
Indicates if the texture has mipmaps.
Definition: GrTypes.h:497
int fSampleCnt
The number of samples per pixel or 0 to disable full scene AA.
Definition: GrTypes.h:496
int fSampleCnt
If the render target flag is set and sample count is greater than 0 then Gr will create an MSAA buffe...
Definition: GrTypes.h:568
GrBackendObject fRenderTargetHandle
Handle to the 3D API object.
Definition: GrTypes.h:607
GrSurfaceOrigin fOrigin
origin of the texture
Definition: GrTypes.h:479
GrSurfaceFlags fFlags
bitfield of TextureFlags
Definition: GrTypes.h:478