diff options
Diffstat (limited to 'include/gpu/GrTypes.h')
| -rw-r--r-- | include/gpu/GrTypes.h | 838 |
1 files changed, 838 insertions, 0 deletions
diff --git a/include/gpu/GrTypes.h b/include/gpu/GrTypes.h new file mode 100644 index 0000000..0bcab7d --- /dev/null +++ b/include/gpu/GrTypes.h @@ -0,0 +1,838 @@ + +/* + * Copyright 2010 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + + +#ifndef GrTypes_DEFINED +#define GrTypes_DEFINED + +#include "SkTypes.h" +#include "GrConfig.h" + +//////////////////////////////////////////////////////////////////////////////// + +/** + * Defines overloaded bitwise operators to make it easier to use an enum as a + * bitfield. + */ +#define GR_MAKE_BITFIELD_OPS(X) \ + inline X operator | (X a, X b) { \ + return (X) (+a | +b); \ + } \ + \ + inline X operator & (X a, X b) { \ + return (X) (+a & +b); \ + } \ + template <typename T> \ + inline X operator & (T a, X b) { \ + return (X) (+a & +b); \ + } \ + template <typename T> \ + inline X operator & (X a, T b) { \ + return (X) (+a & +b); \ + } \ + +#define GR_DECL_BITFIELD_OPS_FRIENDS(X) \ + friend X operator | (X a, X b); \ + \ + friend X operator & (X a, X b); \ + \ + template <typename T> \ + friend X operator & (T a, X b); \ + \ + template <typename T> \ + friend X operator & (X a, T b); \ +//////////////////////////////////////////////////////////////////////////////// + + +/** + * Macro to round n up to the next multiple of 4, or return it unchanged if + * n is already a multiple of 4 + */ +#define GrALIGN4(n) SkAlign4(n) +#define GrIsALIGN4(n) SkIsAlign4(n) + +template <typename T> const T& GrMin(const T& a, const T& b) { + return (a < b) ? a : b; +} + +template <typename T> const T& GrMax(const T& a, const T& b) { + return (b < a) ? a : b; +} + +// compile time versions of min/max +#define GR_CT_MAX(a, b) (((b) < (a)) ? (a) : (b)) +#define GR_CT_MIN(a, b) (((b) < (a)) ? (b) : (a)) + +/** + * divide, rounding up + */ +static inline int32_t GrIDivRoundUp(int x, int y) { + GrAssert(y > 0); + return (x + (y-1)) / y; +} +static inline uint32_t GrUIDivRoundUp(uint32_t x, uint32_t y) { + return (x + (y-1)) / y; +} +static inline size_t GrSizeDivRoundUp(size_t x, uint32_t y) { + return (x + (y-1)) / y; +} + +/** + * align up + */ +static inline uint32_t GrUIAlignUp(uint32_t x, uint32_t alignment) { + return GrUIDivRoundUp(x, alignment) * alignment; +} +static inline uint32_t GrSizeAlignUp(size_t x, uint32_t alignment) { + return GrSizeDivRoundUp(x, alignment) * alignment; +} + +/** + * amount of pad needed to align up + */ +static inline uint32_t GrUIAlignUpPad(uint32_t x, uint32_t alignment) { + return (alignment - x % alignment) % alignment; +} +static inline size_t GrSizeAlignUpPad(size_t x, uint32_t alignment) { + return (alignment - x % alignment) % alignment; +} + +/** + * align down + */ +static inline uint32_t GrUIAlignDown(uint32_t x, uint32_t alignment) { + return (x / alignment) * alignment; +} +static inline uint32_t GrSizeAlignDown(size_t x, uint32_t alignment) { + return (x / alignment) * alignment; +} + +/** + * Count elements in an array + */ +#define GR_ARRAY_COUNT(array) SK_ARRAY_COUNT(array) + +//!< allocate a block of memory, will never return NULL +extern void* GrMalloc(size_t bytes); + +//!< free block allocated by GrMalloc. ptr may be NULL +extern void GrFree(void* ptr); + +static inline void Gr_bzero(void* dst, size_t size) { + memset(dst, 0, size); +} + +/////////////////////////////////////////////////////////////////////////////// + +/** + * Return the number of leading zeros in n + */ +extern int Gr_clz(uint32_t n); + +/** + * Return true if n is a power of 2 + */ +static inline bool GrIsPow2(unsigned n) { + return n && 0 == (n & (n - 1)); +} + +/** + * Return the next power of 2 >= n. + */ +static inline uint32_t GrNextPow2(uint32_t n) { + return n ? (1 << (32 - Gr_clz(n - 1))) : 1; +} + +static inline int GrNextPow2(int n) { + GrAssert(n >= 0); // this impl only works for non-neg. + return n ? (1 << (32 - Gr_clz(n - 1))) : 1; +} + +/////////////////////////////////////////////////////////////////////////////// + +/** + * 16.16 fixed point type + */ +typedef int32_t GrFixed; + +#if GR_DEBUG + +static inline int16_t GrToS16(intptr_t x) { + GrAssert((int16_t)x == x); + return (int16_t)x; +} + +#else + +#define GrToS16(x) x + +#endif + + +/////////////////////////////////////////////////////////////////////////////// + +/** + * Possible 3D APIs that may be used by Ganesh. + */ +enum GrEngine { + kOpenGL_Shaders_GrEngine, + kOpenGL_Fixed_GrEngine, +}; + +/** + * Engine-specific 3D context handle + * GrGLInterface* for OpenGL. If NULL will use the default GL interface. + */ +typedef intptr_t GrPlatform3DContext; + +/////////////////////////////////////////////////////////////////////////////// + +/** + * Type used to describe format of vertices in arrays + * Values are defined in GrDrawTarget + */ +typedef int GrVertexLayout; + +/** +* Geometric primitives used for drawing. +*/ +enum GrPrimitiveType { + kTriangles_PrimitiveType, + kTriangleStrip_PrimitiveType, + kTriangleFan_PrimitiveType, + kPoints_PrimitiveType, + kLines_PrimitiveType, // 1 pix wide only + kLineStrip_PrimitiveType // 1 pix wide only +}; + +static inline bool GrIsPrimTypeLines(GrPrimitiveType type) { + return kLines_PrimitiveType == type || kLineStrip_PrimitiveType == type; +} + +static inline bool GrIsPrimTypeTris(GrPrimitiveType type) { + return kTriangles_PrimitiveType == type || + kTriangleStrip_PrimitiveType == type || + kTriangleFan_PrimitiveType == type; +} + +/** + * Coeffecients for alpha-blending. + */ +enum GrBlendCoeff { + kZero_BlendCoeff, //<! 0 + kOne_BlendCoeff, //<! 1 + kSC_BlendCoeff, //<! src color + kISC_BlendCoeff, //<! one minus src color + kDC_BlendCoeff, //<! dst color + kIDC_BlendCoeff, //<! one minus dst color + kSA_BlendCoeff, //<! src alpha + kISA_BlendCoeff, //<! one minus src alpha + kDA_BlendCoeff, //<! dst alpha + kIDA_BlendCoeff, //<! one minus dst alpha + kConstC_BlendCoeff, //<! constant color + kIConstC_BlendCoeff, //<! one minus constant color + kConstA_BlendCoeff, //<! constant color alpha + kIConstA_BlendCoeff, //<! one minus constant color alpha + + kPublicBlendCoeffCount +}; + +/** + * Formats for masks, used by the font cache. + * Important that these are 0-based. + */ +enum GrMaskFormat { + kA8_GrMaskFormat, //!< 1-byte per pixel + kA565_GrMaskFormat, //!< 2-bytes per pixel + kA888_GrMaskFormat, //!< 4-bytes per pixel + + kCount_GrMaskFormats //!< used to allocate arrays sized for mask formats +}; + +/** + * Return the number of bytes-per-pixel for the specified mask format. + */ +static inline int GrMaskFormatBytesPerPixel(GrMaskFormat format) { + GrAssert((unsigned)format <= 2); + // kA8 (0) -> 1 + // kA565 (1) -> 2 + // kA888 (2) -> 4 + return 1 << (int)format; +} + +/** + * Pixel configurations. + * + * Unpremultiplied configs are intended for converting pixel data in and out + * from skia. Surfaces with these configs have limited support. As an input + * (GrPaint texture) the corresponding GrSamplerState must have its filter set + * to kNearest_Filter. Otherwise, the draw will fail. When the render target + * has an unpremultiplied config draws must use blend coeffs 1,0 (AKA src-mode). + * Other coeffs will cause the draw to fail. + */ +enum GrPixelConfig { + kUnknown_GrPixelConfig, + kAlpha_8_GrPixelConfig, + kIndex_8_GrPixelConfig, + kRGB_565_GrPixelConfig, + /** + * Premultiplied + */ + kRGBA_4444_GrPixelConfig, + /** + * Premultiplied. Byte order is r,g,b,a + */ + kRGBA_8888_PM_GrPixelConfig, + /** + * Unpremultiplied. Byte order is r,g,b,a + */ + kRGBA_8888_UPM_GrPixelConfig, + /** + * Premultiplied. Byte order is b,g,r,a + */ + kBGRA_8888_PM_GrPixelConfig, + /** + * Unpremultiplied. Byte order is b,g,r,a + */ + kBGRA_8888_UPM_GrPixelConfig, +}; + +// Aliases for pixel configs that match skia's byte order +#ifndef SK_CPU_LENDIAN + #error "Skia gpu currently assumes little endian" +#endif +#if 24 == SK_A32_SHIFT && 16 == SK_R32_SHIFT && \ + 8 == SK_G32_SHIFT && 0 == SK_B32_SHIFT + static const GrPixelConfig kSkia8888_PM_GrPixelConfig = kBGRA_8888_PM_GrPixelConfig; + static const GrPixelConfig kSkia8888_UPM_GrPixelConfig = kBGRA_8888_UPM_GrPixelConfig; +#elif 24 == SK_A32_SHIFT && 16 == SK_B32_SHIFT && \ + 8 == SK_G32_SHIFT && 0 == SK_R32_SHIFT + static const GrPixelConfig kSkia8888_PM_GrPixelConfig = kRGBA_8888_PM_GrPixelConfig; + static const GrPixelConfig kSkia8888_UPM_GrPixelConfig = kRGBA_8888_UPM_GrPixelConfig; +#else + #error "SK_*32_SHIFT values must correspond to GL_BGRA or GL_RGBA format." +#endif + +// WebKit is relying on this old name for the native skia PM config. This will +// be deleted ASAP because it is so similar to kRGBA_PM_8888_GrPixelConfig but +// has a different interpretation when skia is compiled BGRA. +static const GrPixelConfig kRGBA_8888_GrPixelConfig = kSkia8888_PM_GrPixelConfig; + +// Returns true if the pixel config has 8bit r,g,b,a components in that byte +// order +static inline bool GrPixelConfigIsRGBA8888(GrPixelConfig config) { + switch (config) { + case kRGBA_8888_PM_GrPixelConfig: + case kRGBA_8888_UPM_GrPixelConfig: + return true; + default: + return false; + } +} + +// Returns true if the pixel config has 8bit b,g,r,a components in that byte +// order +static inline bool GrPixelConfigIsBGRA8888(GrPixelConfig config) { + switch (config) { + case kBGRA_8888_PM_GrPixelConfig: + case kBGRA_8888_UPM_GrPixelConfig: + return true; + default: + return false; + } +} + +// Returns true if the pixel config is 32 bits per pixel +static inline bool GrPixelConfigIs32Bit(GrPixelConfig config) { + switch (config) { + case kRGBA_8888_PM_GrPixelConfig: + case kRGBA_8888_UPM_GrPixelConfig: + case kBGRA_8888_PM_GrPixelConfig: + case kBGRA_8888_UPM_GrPixelConfig: + return true; + default: + return false; + } +} + +// Takes a config and returns the equivalent config with the R and B order +// swapped if such a config exists. Otherwise, kUnknown_GrPixelConfig +static inline GrPixelConfig GrPixelConfigSwapRAndB(GrPixelConfig config) { + switch (config) { + case kBGRA_8888_PM_GrPixelConfig: + return kRGBA_8888_PM_GrPixelConfig; + case kBGRA_8888_UPM_GrPixelConfig: + return kRGBA_8888_UPM_GrPixelConfig; + case kRGBA_8888_PM_GrPixelConfig: + return kBGRA_8888_PM_GrPixelConfig; + case kRGBA_8888_UPM_GrPixelConfig: + return kBGRA_8888_UPM_GrPixelConfig; + default: + return kUnknown_GrPixelConfig; + } +} + +static inline size_t GrBytesPerPixel(GrPixelConfig config) { + switch (config) { + case kAlpha_8_GrPixelConfig: + case kIndex_8_GrPixelConfig: + return 1; + case kRGB_565_GrPixelConfig: + case kRGBA_4444_GrPixelConfig: + return 2; + case kRGBA_8888_PM_GrPixelConfig: + case kRGBA_8888_UPM_GrPixelConfig: + case kBGRA_8888_PM_GrPixelConfig: + case kBGRA_8888_UPM_GrPixelConfig: + return 4; + default: + return 0; + } +} + +static inline bool GrPixelConfigIsOpaque(GrPixelConfig config) { + switch (config) { + case kRGB_565_GrPixelConfig: + return true; + default: + return false; + } +} + +/** + * Premultiplied alpha is the usual for skia. Therefore, configs that are + * ambiguous (alpha-only or color-only) are considered premultiplied. + */ +static inline bool GrPixelConfigIsUnpremultiplied(GrPixelConfig config) { + switch (config) { + case kRGBA_8888_UPM_GrPixelConfig: + case kBGRA_8888_UPM_GrPixelConfig: + return true; + default: + return false; + } +} + +static inline bool GrPixelConfigIsAlphaOnly(GrPixelConfig config) { + switch (config) { + case kAlpha_8_GrPixelConfig: + return true; + default: + return false; + } +} + +/** + * Used to control the level of antialiasing available for a rendertarget. + * Anti-alias quality levels depend on the underlying API/GPU capabilities. + */ +enum GrAALevels { + kNone_GrAALevel, //<! No antialiasing available. + kLow_GrAALevel, //<! Low quality antialiased rendering. Actual + // interpretation is platform-dependent. + kMed_GrAALevel, //<! Medium quality antialiased rendering. Actual + // interpretation is platform-dependent. + kHigh_GrAALevel, //<! High quality antialiased rendering. Actual + // interpretation is platform-dependent. +}; + +/** + * Optional bitfield flags that can be passed to createTexture. + */ +enum GrTextureFlags { + kNone_GrTextureFlags = 0x0, + /** + * Creates a texture that can be rendered to as a GrRenderTarget. Use + * GrTexture::asRenderTarget() to access. + */ + kRenderTarget_GrTextureFlagBit = 0x1, + /** + * By default all render targets have an associated stencil buffer that + * may be required for path filling. This flag overrides stencil buffer + * creation. + * MAKE THIS PRIVATE? + */ + kNoStencil_GrTextureFlagBit = 0x2, + /** + * Hint that the CPU may modify this texture after creation. + */ + kDynamicUpdate_GrTextureFlagBit = 0x4, +}; + +GR_MAKE_BITFIELD_OPS(GrTextureFlags) + +enum { + /** + * For Index8 pixel config, the colortable must be 256 entries + */ + kGrColorTableSize = 256 * 4 //sizeof(GrColor) +}; + +/** + * Describes a texture to be created. + */ +struct GrTextureDesc { + GrTextureFlags fFlags; //!< bitfield of TextureFlags + /** + * The level of antialiasing available for a rendertarget texture. Only used + * fFlags contains kRenderTarget_GrTextureFlag. + */ + GrAALevels fAALevel; + int fWidth; //!< Width of the texture + int fHeight; //!< Height of the texture + /** + * Format of source data of the texture. Not guaraunteed to be the same as + * internal format used by 3D API. + */ + GrPixelConfig fConfig; +}; + +/** + * Set Operations used to construct clips. + */ +enum GrSetOp { + kReplace_SetOp, + kIntersect_SetOp, + kUnion_SetOp, + kXor_SetOp, + kDifference_SetOp, + kReverseDifference_SetOp, +}; + +/** + * Clips are composed from these objects. + */ +enum GrClipType { + kRect_ClipType, + kPath_ClipType +}; + +/** + * Commands used to describe a path. Each command + * is accompanied by some number of points. + */ +enum GrPathCmd { + kMove_PathCmd, //!< Starts a new subpath at + // at the returned point + // 1 point + kLine_PathCmd, //!< Adds a line segment + // 2 points + kQuadratic_PathCmd, //!< Adds a quadratic segment + // 3 points + kCubic_PathCmd, //!< Adds a cubic segment + // 4 points + kClose_PathCmd, //!< Closes the current subpath + // by connecting a line to the + // starting point. + // 0 points + kEnd_PathCmd //!< Indicates the end of the last subpath + // when iterating + // 0 points. +}; + +/** + * Gets the number of points associated with a path command. + */ +static int inline NumPathCmdPoints(GrPathCmd cmd) { + static const int gNumPoints[] = { + 1, 2, 3, 4, 0, 0 + }; + return gNumPoints[cmd]; +} + +/** + * Path filling rules + */ +enum GrPathFill { + kWinding_PathFill, + kEvenOdd_PathFill, + kInverseWinding_PathFill, + kInverseEvenOdd_PathFill, + kHairLine_PathFill, + + kPathFillCount +}; + +static inline GrPathFill GrNonInvertedFill(GrPathFill fill) { + static const GrPathFill gNonInvertedFills[] = { + kWinding_PathFill, // kWinding_PathFill + kEvenOdd_PathFill, // kEvenOdd_PathFill + kWinding_PathFill, // kInverseWinding_PathFill + kEvenOdd_PathFill, // kInverseEvenOdd_PathFill + kHairLine_PathFill,// kHairLine_PathFill + }; + GR_STATIC_ASSERT(0 == kWinding_PathFill); + GR_STATIC_ASSERT(1 == kEvenOdd_PathFill); + GR_STATIC_ASSERT(2 == kInverseWinding_PathFill); + GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill); + GR_STATIC_ASSERT(4 == kHairLine_PathFill); + GR_STATIC_ASSERT(5 == kPathFillCount); + return gNonInvertedFills[fill]; +} + +static inline bool GrIsFillInverted(GrPathFill fill) { + static const bool gIsFillInverted[] = { + false, // kWinding_PathFill + false, // kEvenOdd_PathFill + true, // kInverseWinding_PathFill + true, // kInverseEvenOdd_PathFill + false, // kHairLine_PathFill + }; + GR_STATIC_ASSERT(0 == kWinding_PathFill); + GR_STATIC_ASSERT(1 == kEvenOdd_PathFill); + GR_STATIC_ASSERT(2 == kInverseWinding_PathFill); + GR_STATIC_ASSERT(3 == kInverseEvenOdd_PathFill); + GR_STATIC_ASSERT(4 == kHairLine_PathFill); + GR_STATIC_ASSERT(5 == kPathFillCount); + return gIsFillInverted[fill]; +} + +/** + * Hints provided about a path's convexity (or lack thereof). + */ +enum GrConvexHint { + kNone_ConvexHint, //<! No hint about convexity + // of the path + kConvex_ConvexHint, //<! Path is one convex piece + kNonOverlappingConvexPieces_ConvexHint, //<! Multiple convex pieces, + // pieces are known to be + // disjoint + kSameWindingConvexPieces_ConvexHint, //<! Multiple convex pieces, + // may or may not intersect, + // either all wind cw or all + // wind ccw. + kConcave_ConvexHint //<! Path is known to be + // concave +}; + +/////////////////////////////////////////////////////////////////////////////// + +// opaque type for 3D API object handles +typedef intptr_t GrPlatform3DObject; + +/** + * Gr can wrap an existing texture created by the client with a GrTexture + * object. The client is responsible for ensuring that the texture lives at + * least as long as the GrTexture object wrapping it. We require the client to + * explicitly provide information about the texture, such as width, height, + * and pixel config, rather than querying the 3D APIfor these values. We expect + * these to be immutable even if the 3D API doesn't require this (OpenGL). + * + * Textures that are also render targets are supported as well. Gr will manage + * any ancillary 3D API (stencil buffer, FBO id, etc) objects necessary for + * Gr to draw into the render target. To access the render target object + * call GrTexture::asRenderTarget(). + * + * If in addition to the render target flag, the caller also specifies a sample + * count Gr will create an MSAA buffer that resolves into the texture. Gr auto- + * resolves when it reads from the texture. The client can explictly resolve + * using the GrRenderTarget interface. + */ + +enum GrPlatformTextureFlags { + /** + * No flags enabled + */ + kNone_GrPlatformTextureFlag = 0x0, + /** + * Indicates that the texture is also a render target, and thus should have + * a GrRenderTarget object. + * + * D3D (future): client must have created the texture with flags that allow + * it to be used as a render target. + */ + kRenderTarget_GrPlatformTextureFlag = 0x1, +}; +GR_MAKE_BITFIELD_OPS(GrPlatformTextureFlags) + +struct GrPlatformTextureDesc { + GrPlatformTextureDesc() { memset(this, 0, sizeof(*this)); } + GrPlatformTextureFlags fFlags; + int fWidth; //<! width in pixels + int fHeight; //<! height in pixels + GrPixelConfig fConfig; //<! color format + /** + * If the render target flag is set and sample count is greater than 0 + * then Gr will create an MSAA buffer that resolves to the texture. + */ + int fSampleCnt; + /** + * Handle to the 3D API object. + * OpenGL: Texture ID. + */ + GrPlatform3DObject fTextureHandle; +}; + +/////////////////////////////////////////////////////////////////////////////// + +/** + * Gr can wrap an existing render target created by the client in the 3D API + * with a GrRenderTarget object. The client is responsible for ensuring that the + * underlying 3D API object lives at least as long as the GrRenderTarget object + * wrapping it. We require the client to explicitly provide information about + * the target, such as width, height, and pixel config rather than querying the + * 3D API for these values. We expect these properties to be immutable even if + * the 3D API doesn't require this (OpenGL). + */ + +struct GrPlatformRenderTargetDesc { + GrPlatformRenderTargetDesc() { memset(this, 0, sizeof(*this)); } + int fWidth; //<! width in pixels + int fHeight; //<! height in pixels + GrPixelConfig fConfig; //<! color format + /** + * The number of samples per pixel. Gr uses this to influence decisions + * about applying other forms of antialiasing. + */ + int fSampleCnt; + /** + * Number of bits of stencil per-pixel. + */ + int fStencilBits; + /** + * Handle to the 3D API object. + * OpenGL: FBO ID + */ + GrPlatform3DObject fRenderTargetHandle; +}; + +/////////////////////////////////////////////////////////////////////////////// +// DEPRECATED. createPlatformSurface is replaced by createPlatformTexture +// and createPlatformRenderTarget. These enums and structs will be removed. + +enum GrPlatformSurfaceType { + /** + * Specifies that the object being created is a render target. + */ + kRenderTarget_GrPlatformSurfaceType, + /** + * Specifies that the object being created is a texture. + */ + kTexture_GrPlatformSurfaceType, + /** + * Specifies that the object being created is a texture and a render + * target. + */ + kTextureRenderTarget_GrPlatformSurfaceType, +}; + +enum GrPlatformRenderTargetFlags { + kNone_GrPlatformRenderTargetFlagBit = 0x0, + + /** + * Gives permission to Gr to perform the downsample-resolve of a + * multisampled render target. If this is not set then read pixel + * operations may fail. If the object is both a texture and render target + * then this *must* be set. Otherwise, if the client wants do its own + * resolves it must create separate GrRenderTarget and GrTexture objects + * and insert appropriate flushes and resolves betweeen data hazards. + * GrRenderTarget has a flagForResolve() + */ + kGrCanResolve_GrPlatformRenderTargetFlagBit = 0x2, +}; + +GR_MAKE_BITFIELD_OPS(GrPlatformRenderTargetFlags) + +struct GrPlatformSurfaceDesc { + GrPlatformSurfaceType fSurfaceType; // type of surface to create + /** + * Flags for kRenderTarget and kTextureRenderTarget surface types + */ + GrPlatformRenderTargetFlags fRenderTargetFlags; + + int fWidth; // width in pixels + int fHeight; // height in pixels + GrPixelConfig fConfig; // color format + /** + * Number of per sample stencil buffer. Only relevant if kIsRenderTarget is + * set in fFlags. + */ + int fStencilBits; + + /** + * Number of samples per-pixel. Only relevant if kIsRenderTarget is set in + * fFlags. + */ + int fSampleCnt; + + /** + * Texture object in 3D API. Only relevant if fSurfaceType is kTexture or + * kTextureRenderTarget. + * GL: this is a texture object (glGenTextures) + */ + GrPlatform3DObject fPlatformTexture; + /** + * Render target object in 3D API. Only relevant if fSurfaceType is + * kRenderTarget or kTextureRenderTarget + * GL: this is a FBO object (glGenFramebuffers) + */ + GrPlatform3DObject fPlatformRenderTarget; + /** + * 3D API object used as destination of resolve. Only relevant if + * fSurfaceType is kRenderTarget or kTextureRenderTarget and + * kGrCanResolve is set in fRenderTargetFlags. + * fFlags. + * GL: this is a FBO object (glGenFramebuffers) + */ + GrPlatform3DObject fPlatformResolveDestination; + + void reset() { memset(this, 0, sizeof(GrPlatformSurfaceDesc)); } +}; + +/** + * Example of how to wrap render-to-texture-with-MSAA GL objects with a GrPlatformSurace + * + * GLint colorBufferID; + * glGenRenderbuffers(1, &colorID); + * glBindRenderbuffer(GL_RENDERBUFFER, colorBufferID); + * glRenderbufferStorageMultisample(GL_RENDERBUFFER, S, GL_RGBA, W, H); + * + * GLint stencilBufferID; + * glGenRenderBuffers(1, &stencilBufferID); + * glBindRenderbuffer(GL_RENDERBUFFER, stencilBufferID); + * glRenderbufferStorageMultisample(GL_RENDERBUFFER, S, GL_STENCIL_INDEX8, W, H); + * + * GLint drawFBOID; + * glGenFramebuffers(1, &drawFBOID); + * glBindFramebuffer(GL_FRAMEBUFFER, drawFBOID); + * glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, colorBufferID); + * glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, stencilBufferID); + * + * GLint textureID; + * glGenTextures(1, &textureID); + * glBindTexture(GL_TEXTURE_2D, textureID); + * glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, W, H, ...); + * + * GLint readFBOID; + * glGenFramebuffers(1, &readFBOID); + * glBindFramebuffer(GL_FRAMEBUFFER, readFBOID); + * glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, textureID, 0); + * + * GrPlatformSurfaceDesc renderTargetTextureDesc; + * renderTargetTextureDesc.fSurfaceType = kTextureRenderTarget_GrPlatformSurfaceType; + * renderTargetTextureDesc.fRenderTargetFlags = kGrCanResolve_GrPlatformRenderTargetFlagBit; + * renderTargetTextureDesc.fWidth = W; + * renderTargetTextureDesc.fHeight = H; + * renderTargetTextureDesc.fConfig = kSkia8888_PM_GrPixelConfig + * renderTargetTextureDesc.fStencilBits = 8; + * renderTargetTextureDesc.fSampleCnt = S; + * renderTargetTextureDesc.fPlatformTexture = textureID; + * renderTargetTextureDesc.fPlatformRenderTarget = drawFBOID; + * renderTargetTextureDesc.fPlatformResolveDestination = readFBOID; + * + * GrTexture* texture = static_cast<GrTexture*>(grContext->createPlatrformSurface(renderTargetTextureDesc)); + */ + + +/////////////////////////////////////////////////////////////////////////////// + +// this is included only to make it easy to use this debugging facility +#include "GrInstanceCounter.h" + +#endif |