1
2/*
3 * Copyright 2010 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9
10
11#ifndef GrTypes_DEFINED
12#define GrTypes_DEFINED
13
14#include "SkTypes.h"
15#include "GrConfig.h"
16#include "SkMath.h"
17
18//#define SK_SUPPORT_LEGACY_GRTYPES
19
20////////////////////////////////////////////////////////////////////////////////
21
22/**
23 * Defines overloaded bitwise operators to make it easier to use an enum as a
24 * bitfield.
25 */
26#define GR_MAKE_BITFIELD_OPS(X) \
27    inline X operator | (X a, X b) { \
28        return (X) (+a | +b); \
29    } \
30    \
31    inline X operator & (X a, X b) { \
32        return (X) (+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    \
46    friend X operator & (X a, X b); \
47    \
48    template <typename T> \
49    friend X operator & (T a, X b); \
50    \
51    template <typename T> \
52    friend X operator & (X a, T b); \
53////////////////////////////////////////////////////////////////////////////////
54
55#ifdef SK_SUPPORT_LEGACY_GRTYPES
56
57/**
58 *  Macro to round n up to the next multiple of 4, or return it unchanged if
59 *  n is already a multiple of 4
60 */
61#define GrALIGN4(n)     SkAlign4(n)
62#define GrIsALIGN4(n)   SkIsAlign4(n)
63
64template <typename T> const T& GrMin(const T& a, const T& b) {
65    return (a < b) ? a : b;
66}
67
68template <typename T> const T& GrMax(const T& a, const T& b) {
69    return (b < a) ? a : b;
70}
71
72/**
73 *  Count elements in an array
74 */
75#define GR_ARRAY_COUNT(array)  SK_ARRAY_COUNT(array)
76
77/**
78 *  16.16 fixed point type
79 */
80typedef int32_t GrFixed;
81
82#ifdef SK_DEBUG
83
84static inline int16_t GrToS16(intptr_t x) {
85    SkASSERT((int16_t)x == x);
86    return (int16_t)x;
87}
88
89#else
90
91#define GrToS16(x)  x
92
93#endif
94
95#endif
96
97// compile time versions of min/max
98#define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b))
99#define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a))
100
101/**
102 *  divide, rounding up
103 */
104static inline int32_t GrIDivRoundUp(int x, int y) {
105    SkASSERT(y > 0);
106    return (x + (y-1)) / y;
107}
108static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) {
109    return (x + (y-1)) / y;
110}
111static inline size_t GrSizeDivRoundUp(size_t x, size_t y) {
112    return (x + (y-1)) / y;
113}
114
115// compile time, evaluates Y multiple times
116#define GR_CT_DIV_ROUND_UP(X, Y) (((X) + ((Y)-1)) / (Y))
117
118/**
119 *  align up
120 */
121static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) {
122    return GrUIDivRoundUp(x, alignment) * alignment;
123}
124static inline size_t GrSizeAlignUp(size_t x, size_t alignment) {
125    return GrSizeDivRoundUp(x, alignment) * alignment;
126}
127
128// compile time, evaluates A multiple times
129#define GR_CT_ALIGN_UP(X, A) (GR_CT_DIV_ROUND_UP((X),(A)) * (A))
130
131/**
132 * amount of pad needed to align up
133 */
134static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) {
135    return (alignment - x % alignment) % alignment;
136}
137static inline size_t GrSizeAlignUpPad(size_t x, size_t alignment) {
138    return (alignment - x % alignment) % alignment;
139}
140
141/**
142 *  align down
143 */
144static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) {
145    return (x / alignment) * alignment;
146}
147static inline size_t GrSizeAlignDown(size_t x, uint32_t alignment) {
148    return (x / alignment) * alignment;
149}
150
151///////////////////////////////////////////////////////////////////////////////
152
153/**
154 *  Return the next power of 2 >= n.
155 */
156static inline uint32_t GrNextPow2(uint32_t n) {
157    return n ? (1 << (32 - SkCLZ(n - 1))) : 1;
158}
159
160static inline int GrNextPow2(int n) {
161    SkASSERT(n >= 0); // this impl only works for non-neg.
162    return n ? (1 << (32 - SkCLZ(n - 1))) : 1;
163}
164
165///////////////////////////////////////////////////////////////////////////////
166
167/**
168 * Possible 3D APIs that may be used by Ganesh.
169 */
170enum GrBackend {
171    kOpenGL_GrBackend,
172};
173
174/**
175 * Backend-specific 3D context handle
176 *      GrGLInterface* for OpenGL. If NULL will use the default GL interface.
177 */
178typedef intptr_t GrBackendContext;
179
180///////////////////////////////////////////////////////////////////////////////
181
182/**
183* Geometric primitives used for drawing.
184*/
185enum GrPrimitiveType {
186    kTriangles_GrPrimitiveType,
187    kTriangleStrip_GrPrimitiveType,
188    kTriangleFan_GrPrimitiveType,
189    kPoints_GrPrimitiveType,
190    kLines_GrPrimitiveType,     // 1 pix wide only
191    kLineStrip_GrPrimitiveType  // 1 pix wide only
192};
193
194static inline bool GrIsPrimTypeLines(GrPrimitiveType type) {
195    return kLines_GrPrimitiveType == type || kLineStrip_GrPrimitiveType == type;
196}
197
198static inline bool GrIsPrimTypeTris(GrPrimitiveType type) {
199    return kTriangles_GrPrimitiveType == type     ||
200           kTriangleStrip_GrPrimitiveType == type ||
201           kTriangleFan_GrPrimitiveType == type;
202}
203
204/**
205 * Coeffecients for alpha-blending.
206 */
207enum GrBlendCoeff {
208    kInvalid_GrBlendCoeff = -1,
209
210    kZero_GrBlendCoeff,    //<! 0
211    kOne_GrBlendCoeff,     //<! 1
212    kSC_GrBlendCoeff,      //<! src color
213    kISC_GrBlendCoeff,     //<! one minus src color
214    kDC_GrBlendCoeff,      //<! dst color
215    kIDC_GrBlendCoeff,     //<! one minus dst color
216    kSA_GrBlendCoeff,      //<! src alpha
217    kISA_GrBlendCoeff,     //<! one minus src alpha
218    kDA_GrBlendCoeff,      //<! dst alpha
219    kIDA_GrBlendCoeff,     //<! one minus dst alpha
220    kConstC_GrBlendCoeff,  //<! constant color
221    kIConstC_GrBlendCoeff, //<! one minus constant color
222    kConstA_GrBlendCoeff,  //<! constant color alpha
223    kIConstA_GrBlendCoeff, //<! one minus constant color alpha
224
225    kPublicGrBlendCoeffCount
226};
227
228/**
229 *  Formats for masks, used by the font cache.
230 *  Important that these are 0-based.
231 */
232enum GrMaskFormat {
233    kA8_GrMaskFormat,    //!< 1-byte per pixel
234    kA565_GrMaskFormat,  //!< 2-bytes per pixel
235    kA888_GrMaskFormat,  //!< 4-bytes per pixel
236    kARGB_GrMaskFormat,  //!< 4-bytes per pixel, color format
237
238    kLast_GrMaskFormat = kARGB_GrMaskFormat
239};
240static const int kMaskFormatCount = kLast_GrMaskFormat + 1;
241
242/**
243 *  Return the number of bytes-per-pixel for the specified mask format.
244 */
245static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) {
246    SkASSERT((unsigned)format <= 3);
247    // kA8   (0) -> 1
248    // kA565 (1) -> 2
249    // kA888 (2) -> 4
250    // kARGB (3) -> 4
251    static const int sBytesPerPixel[] = { 1, 2, 4, 4 };
252    SK_COMPILE_ASSERT(SK_ARRAY_COUNT(sBytesPerPixel) == kMaskFormatCount, array_size_mismatch);
253
254    return sBytesPerPixel[(int) format];
255}
256
257/**
258 * Pixel configurations.
259 */
260enum GrPixelConfig {
261    kUnknown_GrPixelConfig,
262    kAlpha_8_GrPixelConfig,
263    kIndex_8_GrPixelConfig,
264    kRGB_565_GrPixelConfig,
265    /**
266     * Premultiplied
267     */
268    kRGBA_4444_GrPixelConfig,
269    /**
270     * Premultiplied. Byte order is r,g,b,a.
271     */
272    kRGBA_8888_GrPixelConfig,
273    /**
274     * Premultiplied. Byte order is b,g,r,a.
275     */
276    kBGRA_8888_GrPixelConfig,
277    /**
278     * ETC1 Compressed Data
279     */
280    kETC1_GrPixelConfig,
281    /**
282     * LATC/RGTC/3Dc/BC4 Compressed Data
283     */
284    kLATC_GrPixelConfig,
285
286    kLast_GrPixelConfig = kLATC_GrPixelConfig
287};
288static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1;
289
290// Aliases for pixel configs that match skia's byte order.
291#ifndef SK_CPU_LENDIAN
292    #error "Skia gpu currently assumes little endian"
293#endif
294#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A)
295    static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig;
296#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A)
297    static const GrPixelConfig kSkia8888_GrPixelConfig = kRGBA_8888_GrPixelConfig;
298#else
299    #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format."
300#endif
301
302// Returns true if the pixel config is a GPU-specific compressed format
303// representation.
304static inline bool GrPixelConfigIsCompressed(GrPixelConfig config) {
305    switch (config) {
306        case kETC1_GrPixelConfig:
307        case kLATC_GrPixelConfig:
308            return true;
309        default:
310            return false;
311    }
312}
313
314// Returns true if the pixel config is 32 bits per pixel
315static inline bool GrPixelConfigIs8888(GrPixelConfig config) {
316    switch (config) {
317        case kRGBA_8888_GrPixelConfig:
318        case kBGRA_8888_GrPixelConfig:
319            return true;
320        default:
321            return false;
322    }
323}
324
325// Takes a config and returns the equivalent config with the R and B order
326// swapped if such a config exists. Otherwise, kUnknown_GrPixelConfig
327static inline GrPixelConfig GrPixelConfigSwapRAndB(GrPixelConfig config) {
328    switch (config) {
329        case kBGRA_8888_GrPixelConfig:
330            return kRGBA_8888_GrPixelConfig;
331        case kRGBA_8888_GrPixelConfig:
332            return kBGRA_8888_GrPixelConfig;
333        default:
334            return kUnknown_GrPixelConfig;
335    }
336}
337
338static inline size_t GrBytesPerPixel(GrPixelConfig config) {
339    switch (config) {
340        case kAlpha_8_GrPixelConfig:
341        case kIndex_8_GrPixelConfig:
342            return 1;
343        case kRGB_565_GrPixelConfig:
344        case kRGBA_4444_GrPixelConfig:
345            return 2;
346        case kRGBA_8888_GrPixelConfig:
347        case kBGRA_8888_GrPixelConfig:
348            return 4;
349        default:
350            return 0;
351    }
352}
353
354static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) {
355    switch (config) {
356        case kETC1_GrPixelConfig:
357        case kRGB_565_GrPixelConfig:
358            return true;
359        default:
360            return false;
361    }
362}
363
364static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) {
365    switch (config) {
366        case kLATC_GrPixelConfig:
367        case kAlpha_8_GrPixelConfig:
368            return true;
369        default:
370            return false;
371    }
372}
373
374/**
375 * Optional bitfield flags that can be passed to createTexture.
376 */
377enum GrTextureFlags {
378    kNone_GrTextureFlags            = 0x0,
379    /**
380     * Creates a texture that can be rendered to as a GrRenderTarget. Use
381     * GrTexture::asRenderTarget() to access.
382     */
383    kRenderTarget_GrTextureFlagBit  = 0x1,
384    /**
385     * By default all render targets have an associated stencil buffer that
386     * may be required for path filling. This flag overrides stencil buffer
387     * creation.
388     * MAKE THIS PRIVATE?
389     */
390    kNoStencil_GrTextureFlagBit     = 0x2,
391    /**
392     * Hint that the CPU may modify this texture after creation.
393     */
394    kDynamicUpdate_GrTextureFlagBit = 0x4,
395    /**
396     * Indicates that all allocations (color buffer, FBO completeness, etc)
397     * should be verified.
398     */
399    kCheckAllocation_GrTextureFlagBit  = 0x8,
400
401    kDummy_GrTextureFlagBit,
402    kLastPublic_GrTextureFlagBit = kDummy_GrTextureFlagBit-1,
403};
404
405GR_MAKE_BITFIELD_OPS(GrTextureFlags)
406
407enum {
408   /**
409    *  For Index8 pixel config, the colortable must be 256 entries
410    */
411    kGrColorTableSize = 256 * 4 //sizeof(GrColor)
412};
413
414/**
415 * Some textures will be stored such that the upper and left edges of the content meet at the
416 * the origin (in texture coord space) and for other textures the lower and left edges meet at
417 * the origin. kDefault_GrSurfaceOrigin sets textures to TopLeft, and render targets
418 * to BottomLeft.
419 */
420
421enum GrSurfaceOrigin {
422    kDefault_GrSurfaceOrigin,         // DEPRECATED; to be removed
423    kTopLeft_GrSurfaceOrigin,
424    kBottomLeft_GrSurfaceOrigin,
425};
426
427/**
428 * Describes a texture to be created.
429 */
430struct GrTextureDesc {
431    GrTextureDesc()
432    : fFlags(kNone_GrTextureFlags)
433    , fOrigin(kDefault_GrSurfaceOrigin)
434    , fWidth(0)
435    , fHeight(0)
436    , fConfig(kUnknown_GrPixelConfig)
437    , fSampleCnt(0) {
438    }
439
440    GrTextureFlags         fFlags;  //!< bitfield of TextureFlags
441    GrSurfaceOrigin        fOrigin; //!< origin of the texture
442    int                    fWidth;  //!< Width of the texture
443    int                    fHeight; //!< Height of the texture
444
445    /**
446     * Format of source data of the texture. Not guaranteed to be the same as
447     * internal format used by 3D API.
448     */
449    GrPixelConfig          fConfig;
450
451    /**
452     * The number of samples per pixel or 0 to disable full scene AA. This only
453     * applies if the kRenderTarget_GrTextureFlagBit is set. The actual number
454     * of samples may not exactly match the request. The request will be rounded
455     * up to the next supported sample count, or down if it is larger than the
456     * max supported count.
457     */
458    int                    fSampleCnt;
459};
460
461/**
462 * GrCacheID is used create and find cached GrResources (e.g. GrTextures). The ID has two parts:
463 * the domain and the key. Domains simply allow multiple clients to use 0-based indices as their
464 * cache key without colliding. The key uniquely identifies a GrResource within the domain.
465 * Users of the cache must obtain a domain via GenerateDomain().
466 */
467struct GrCacheID {
468public:
469    typedef uint8_t  Domain;
470
471    struct Key {
472        union {
473            uint8_t  fData8[16];
474            uint32_t fData32[4];
475            uint64_t fData64[2];
476        };
477    };
478
479    /**
480     * A default cache ID is invalid; a set method must be called before the object is used.
481     */
482    GrCacheID() { fDomain = kInvalid_Domain; }
483
484    /**
485     * Initialize the cache ID to a domain and key.
486     */
487    GrCacheID(Domain domain, const Key& key) {
488        SkASSERT(kInvalid_Domain != domain);
489        this->reset(domain, key);
490    }
491
492    void reset(Domain domain, const Key& key) {
493        fDomain = domain;
494        memcpy(&fKey, &key, sizeof(Key));
495    }
496
497    /** Has this been initialized to a valid domain */
498    bool isValid() const { return kInvalid_Domain != fDomain; }
499
500    const Key& getKey() const { SkASSERT(this->isValid()); return fKey; }
501    Domain getDomain() const { SkASSERT(this->isValid()); return fDomain; }
502
503    /** Creates a new unique ID domain. */
504    static Domain GenerateDomain();
505
506private:
507    Key             fKey;
508    Domain          fDomain;
509
510    static const Domain kInvalid_Domain = 0;
511};
512
513/**
514 * Clips are composed from these objects.
515 */
516enum GrClipType {
517    kRect_ClipType,
518    kPath_ClipType
519};
520
521///////////////////////////////////////////////////////////////////////////////
522
523// opaque type for 3D API object handles
524typedef intptr_t GrBackendObject;
525
526/**
527 * Gr can wrap an existing texture created by the client with a GrTexture
528 * object. The client is responsible for ensuring that the texture lives at
529 * least as long as the GrTexture object wrapping it. We require the client to
530 * explicitly provide information about the texture, such as width, height,
531 * and pixel config, rather than querying the 3D APIfor these values. We expect
532 * these to be immutable even if the 3D API doesn't require this (OpenGL).
533 *
534 * Textures that are also render targets are supported as well. Gr will manage
535 * any ancillary 3D API (stencil buffer, FBO id, etc) objects necessary for
536 * Gr to draw into the render target. To access the render target object
537 * call GrTexture::asRenderTarget().
538 *
539 * If in addition to the render target flag, the caller also specifies a sample
540 * count Gr will create an MSAA buffer that resolves into the texture. Gr auto-
541 * resolves when it reads from the texture. The client can explictly resolve
542 * using the GrRenderTarget interface.
543 *
544 * Note: These flags currently form a subset of GrTexture's flags.
545 */
546
547enum GrBackendTextureFlags {
548    /**
549     * No flags enabled
550     */
551    kNone_GrBackendTextureFlag             = kNone_GrTextureFlags,
552    /**
553     * Indicates that the texture is also a render target, and thus should have
554     * a GrRenderTarget object.
555     *
556     * D3D (future): client must have created the texture with flags that allow
557     * it to be used as a render target.
558     */
559    kRenderTarget_GrBackendTextureFlag     = kRenderTarget_GrTextureFlagBit,
560};
561GR_MAKE_BITFIELD_OPS(GrBackendTextureFlags)
562
563struct GrBackendTextureDesc {
564    GrBackendTextureDesc() { memset(this, 0, sizeof(*this)); }
565    GrBackendTextureFlags           fFlags;
566    GrSurfaceOrigin                 fOrigin;
567    int                             fWidth;         //<! width in pixels
568    int                             fHeight;        //<! height in pixels
569    GrPixelConfig                   fConfig;        //<! color format
570    /**
571     * If the render target flag is set and sample count is greater than 0
572     * then Gr will create an MSAA buffer that resolves to the texture.
573     */
574    int                             fSampleCnt;
575    /**
576     * Handle to the 3D API object.
577     * OpenGL: Texture ID.
578     */
579    GrBackendObject                 fTextureHandle;
580};
581
582///////////////////////////////////////////////////////////////////////////////
583
584/**
585 * Gr can wrap an existing render target created by the client in the 3D API
586 * with a GrRenderTarget object. The client is responsible for ensuring that the
587 * underlying 3D API object lives at least as long as the GrRenderTarget object
588 * wrapping it. We require the client to explicitly provide information about
589 * the target, such as width, height, and pixel config rather than querying the
590 * 3D API for these values. We expect these properties to be immutable even if
591 * the 3D API doesn't require this (OpenGL).
592 */
593
594struct GrBackendRenderTargetDesc {
595    GrBackendRenderTargetDesc() { memset(this, 0, sizeof(*this)); }
596    int                             fWidth;         //<! width in pixels
597    int                             fHeight;        //<! height in pixels
598    GrPixelConfig                   fConfig;        //<! color format
599    GrSurfaceOrigin                 fOrigin;        //<! pixel origin
600    /**
601     * The number of samples per pixel. Gr uses this to influence decisions
602     * about applying other forms of anti-aliasing.
603     */
604    int                             fSampleCnt;
605    /**
606     * Number of bits of stencil per-pixel.
607     */
608    int                             fStencilBits;
609    /**
610     * Handle to the 3D API object.
611     * OpenGL: FBO ID
612     */
613    GrBackendObject                 fRenderTargetHandle;
614};
615
616/**
617 * The GrContext's cache of backend context state can be partially invalidated.
618 * These enums are specific to the GL backend and we'd add a new set for an alternative backend.
619 */
620enum GrGLBackendState {
621    kRenderTarget_GrGLBackendState     = 1 << 0,
622    kTextureBinding_GrGLBackendState   = 1 << 1,
623    // View state stands for scissor and viewport
624    kView_GrGLBackendState             = 1 << 2,
625    kBlend_GrGLBackendState            = 1 << 3,
626    kAA_GrGLBackendState               = 1 << 4,
627    kVertex_GrGLBackendState           = 1 << 5,
628    kStencil_GrGLBackendState          = 1 << 6,
629    kPixelStore_GrGLBackendState       = 1 << 7,
630    kProgram_GrGLBackendState          = 1 << 8,
631    kFixedFunction_GrGLBackendState    = 1 << 9,
632    kMisc_GrGLBackendState             = 1 << 10,
633    kPathRendering_GrGLBackendState    = 1 << 11,
634    kALL_GrGLBackendState              = 0xffff
635};
636
637/**
638 * Returns the data size for the given compressed pixel config
639 */
640static inline size_t GrCompressedFormatDataSize(GrPixelConfig config,
641                                                int width, int height) {
642    SkASSERT(GrPixelConfigIsCompressed(config));
643
644    switch (config) {
645        case kLATC_GrPixelConfig:
646        case kETC1_GrPixelConfig:
647            SkASSERT((width & 3) == 0);
648            SkASSERT((height & 3) == 0);
649            return (width >> 2) * (height >> 2) * 8;
650
651        default:
652            SkFAIL("Unknown compressed pixel config");
653            return 4 * width * height;
654    }
655}
656
657/**
658 * This value translates to reseting all the context state for any backend.
659 */
660static const uint32_t kAll_GrBackendState = 0xffffffff;
661
662///////////////////////////////////////////////////////////////////////////////
663
664#endif
665