From b65e0cb8ad8a690498142d2b0097be250b0c7dfb Mon Sep 17 00:00:00 2001 From: "twiz@google.com" Date: Fri, 18 Mar 2011 20:41:44 +0000 Subject: Remove the compile-time selection of the GL implementation based on the GR_SUPPORT_GLDESKTOP family of macros. Support for the platform is configured dynamically, by querying the fBindingsExported member of active GrGLInterface instance. Review: http://codereview.appspot.com/4298048/ git-svn-id: http://skia.googlecode.com/svn/trunk@960 2bbb7eff-a529-9590-31e7-b0007b416f81 --- gpu/include/GrGLConfig.h | 23 ++- gpu/include/GrGLInterface.h | 10 + gpu/include/GrGLPlatformIncludes.h | 20 +- gpu/include/GrGLTexture.h | 2 +- gpu/src/GrGLInterface.cpp | 14 ++ gpu/src/GrGLTexture.cpp | 26 ++- gpu/src/GrGpuFactory.cpp | 17 +- gpu/src/GrGpuGL.cpp | 361 +++++++++++++++++++------------------ gpu/src/GrGpuGLFixed.cpp | 17 +- gpu/src/GrGpuGLShaders2.cpp | 50 +++-- 10 files changed, 294 insertions(+), 246 deletions(-) diff --git a/gpu/include/GrGLConfig.h b/gpu/include/GrGLConfig.h index 3c1c5971fa..8599b6301d 100644 --- a/gpu/include/GrGLConfig.h +++ b/gpu/include/GrGLConfig.h @@ -22,6 +22,16 @@ #include "GrGLInterface.h" #include "GrGLDefines.h" +/** + * The following macros are used to staticlly configure the default + * GrGLInterface, but should not be used outside of the GrGLInterface + * scaffolding. Undefine here to prevent accidental use. + */ +#undef GR_SUPPORT_GLDESKTOP +#undef GR_SUPPORT_GLES1 +#undef GR_SUPPORT_GLES2 +#undef GR_SUPPORT_GLES + /** * The following are optional defines that can be enabled at the compiler * command line, in a IDE project, in a GrUserConfig.h file, or in a GL custom @@ -158,19 +168,22 @@ static inline void GrGLClearErr() { #define GR_GL(X) GrGLGetGLInterface()->f##X;; GR_GL_LOG_CALLS_IMPL(X); GR_GL_CHECK_ERROR_IMPL(X); #define GR_GL_NO_ERR(X) GrGLGetGLInterface()->f##X;; GR_GL_LOG_CALLS_IMPL(X); GR_GL_CHECK_ERROR_IMPL(X); +#define GR_GL_SUPPORT_DESKTOP (kDesktop_GrGLBinding == GrGLGetGLInterface()->fBindingsExported) +#define GR_GL_SUPPORT_ES1 (kES1_GrGLBinding == GrGLGetGLInterface()->fBindingsExported) +#define GR_GL_SUPPORT_ES2 (kES2_GrGLBinding == GrGLGetGLInterface()->fBindingsExported) +#define GR_GL_SUPPORT_ES (GR_GL_SUPPORT_ES1 || GR_GL_SUPPORT_ES2) + //////////////////////////////////////////////////////////////////////////////// /** * GrGL_RestoreResetRowLength() will reset GL_UNPACK_ROW_LENGTH to 0. We write * this wrapper, since GL_UNPACK_ROW_LENGTH is not available on all GL versions */ -#if GR_SUPPORT_GLDESKTOP - static inline void GrGL_RestoreResetRowLength() { +static inline void GrGL_RestoreResetRowLength() { + if (GR_GL_SUPPORT_DESKTOP) { GR_GL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, 0)); } -#else - #define GrGL_RestoreResetRowLength() -#endif +} //////////////////////////////////////////////////////////////////////////////// diff --git a/gpu/include/GrGLInterface.h b/gpu/include/GrGLInterface.h index 7bee11191b..7a44f4f5e4 100644 --- a/gpu/include/GrGLInterface.h +++ b/gpu/include/GrGLInterface.h @@ -63,6 +63,12 @@ typedef double GrGLdouble; typedef double GrGLclampd; typedef void GrGLvoid; +enum GrGLBinding { + kDesktop_GrGLBinding = 0x01, + kES1_GrGLBinding = 0x02, + kES2_GrGLBinding = 0x04 +}; + extern "C" { /* * The following interface exports the OpenGL entry points used by the system. @@ -178,6 +184,10 @@ struct GrGLInterface { typedef GrGLvoid* (GR_GL_FUNCTION_TYPE *GrGLMapBufferProc)(GrGLenum target, GrGLenum access); typedef GrGLboolean (GR_GL_FUNCTION_TYPE *GrGLUnmapBufferProc)(GrGLenum target); + // Indicator variable specifying the type of GL implementation + // exported: GLES{1|2} or Desktop. + GrGLBinding fBindingsExported; + GrGLActiveTextureProc fActiveTexture; GrGLAttachShaderProc fAttachShader; GrGLBindAttribLocationProc fBindAttribLocation; diff --git a/gpu/include/GrGLPlatformIncludes.h b/gpu/include/GrGLPlatformIncludes.h index 54ae6bfeee..65e5281aef 100644 --- a/gpu/include/GrGLPlatformIncludes.h +++ b/gpu/include/GrGLPlatformIncludes.h @@ -63,7 +63,13 @@ * Alternatively, define GR_GL_CUSTOM_SETUP_HEADER (and not GR_GL_CUSTOM_SETUP) * to a header that can be included. This file should: * 1. Define the approprate GR_SUPPORT_GL* macro(s) to 1 - * 2. Includes all necessary GL headers. + * 2. Specify all of the necessary GL include headers in the following + * macros: + * GR_GL_PLATFORM_HEADER_SUPPORT: Header required before GL + * includes. + * GR_GL_PLATFORM_HEADER: GL header location. + * GR_GL_PLATFORM_HEADER_EXT: (Optional) Header for extension + * definitions. * 3. Optionally define GR_GL_FUNCTION_TYPE. * 4. Define GR_GL_PROC_ADDRESS. * 5. Optionally define GR_GL_PROC_ADDRESS_HEADER @@ -72,23 +78,23 @@ #if GR_GL_CUSTOM_SETUP #ifdef GR_SUPPORT_GLES1 - #include GR_INCLUDE_GLES1 + #define GR_GL_PLATFORM_HEADER GR_INCLUDE_GLES1 #if defined(GR_INCLUDE_GLES1ext) - #include GR_INCLUDE_GLES1ext + #define GR_GL_PLATFORM_HEADER_EXT GR_INCLUDE_GLES1ext #endif #endif #ifdef GR_SUPPORT_GLES2 - #include GR_INCLUDE_GLES2 + #define GR_GL_PLATFORM_HEADER GR_INCLUDE_GLES2 #if defined(GR_INCLUDE_GLES2ext) - #include GR_INCLUDE_GLES2ext + #define GR_GL_PLATFORM_HEADER_EXT GR_INCLUDE_GLES2ext #endif #endif #ifdef GR_SUPPORT_GLDESKTOP - #include GR_INCLUDE_GLDESKTOP + #define GR_GL_PLATFORM_HEADER GR_INCLUDE_GLDESKTOP #if defined(GR_INCLUDE_GLDESKTOPext) - #include GR_INCLUDE_GLDESKTOPext + #define GR_GL_PLATFORM_HEADER_EXT GR_INCLUDE_GLDESKTOPext #endif #endif diff --git a/gpu/include/GrGLTexture.h b/gpu/include/GrGLTexture.h index 0a1c107469..1747b6d674 100644 --- a/gpu/include/GrGLTexture.h +++ b/gpu/include/GrGLTexture.h @@ -210,7 +210,7 @@ private: GrGLRenderTarget* fRenderTarget; GrGpuGL* fGpuGL; - static const GrGLenum gWrapMode2GLWrap[]; + static const GrGLenum* WrapMode2GLWrap(); friend class GrGpuGL; diff --git a/gpu/src/GrGLInterface.cpp b/gpu/src/GrGLInterface.cpp index 4d726047bb..0bddd98a75 100644 --- a/gpu/src/GrGLInterface.cpp +++ b/gpu/src/GrGLInterface.cpp @@ -244,6 +244,20 @@ void InitializeGLInterfaceExtensions(GrGLInterface* glBindings) { void GrGLInitializeGLInterface(GrGLInterface* glBindings) { Gr_bzero(glBindings, sizeof(GrGLInterface)); + // Indicate the type of the exported GL functions based on macros + // pulled in from the platform includes. +#if GR_SUPPORT_GLDESKTOP + glBindings->fBindingsExported = kDesktop_GrGLBinding; +#endif + +#if GR_SUPPORT_GLES1 && !GR_SUPPORT_GLES2 + glBindings->fBindingsExported = kES1_GrGLBinding; +#endif + +#if GR_SUPPORT_GLES2 + glBindings->fBindingsExported = kES2_GrGLBinding; +#endif + #if GR_SUPPORT_GLDESKTOP || GR_SUPPORT_GLES1 // These entry points only exist on desktop GL implementations. GR_GL_GET_PROC_SYMBOL(Color4ub); diff --git a/gpu/src/GrGLTexture.cpp b/gpu/src/GrGLTexture.cpp index a57871b49b..3970e85331 100644 --- a/gpu/src/GrGLTexture.cpp +++ b/gpu/src/GrGLTexture.cpp @@ -71,14 +71,24 @@ void GrGLRenderTarget::abandon() { //////////////////////////////////////////////////////////////////////////////// -const GrGLenum GrGLTexture::gWrapMode2GLWrap[] = { - GR_GL_CLAMP_TO_EDGE, - GR_GL_REPEAT, -#if GR_SUPPORT_GLES1 && !GR_SUPPORT_GLES2 - GR_GL_REPEAT // GL_MIRRORED_REPEAT not supported :( -#else - GR_GL_MIRRORED_REPEAT -#endif +const GrGLenum* GrGLTexture::WrapMode2GLWrap() { + static const GrGLenum mirrorRepeatModes[] = { + GR_GL_CLAMP_TO_EDGE, + GR_GL_REPEAT, + GR_GL_MIRRORED_REPEAT + }; + + static const GrGLenum repeatModes[] = { + GR_GL_CLAMP_TO_EDGE, + GR_GL_REPEAT, + GR_GL_REPEAT + }; + + if (GR_GL_SUPPORT_ES1 && !GR_GL_SUPPORT_ES2) { + return repeatModes; // GL_MIRRORED_REPEAT not supported. + } else { + return mirrorRepeatModes; + } }; diff --git a/gpu/src/GrGpuFactory.cpp b/gpu/src/GrGpuFactory.cpp index 7c2db2b0b1..0030656a8a 100644 --- a/gpu/src/GrGpuFactory.cpp +++ b/gpu/src/GrGpuFactory.cpp @@ -24,14 +24,8 @@ #include "GrGLConfig.h" - -#if GR_SUPPORT_GLES1 || GR_SUPPORT_GLDESKTOP - #include "GrGpuGLFixed.h" -#endif - -#if GR_SUPPORT_GLES2 || GR_SUPPORT_GLDESKTOP - #include "GrGpuGLShaders2.h" -#endif +#include "GrGpuGLFixed.h" +#include "GrGpuGLShaders2.h" #include "GrGpu.h" @@ -46,15 +40,11 @@ GrGpu* GrGpu::Create(Engine engine, Platform3DContext context3D) { switch (engine) { case kOpenGL_Shaders_Engine: GrAssert(NULL == context3D); -#if GR_SUPPORT_GLES2 || GR_SUPPORT_GLDESKTOP gpu = new GrGpuGLShaders2; -#endif break; case kOpenGL_Fixed_Engine: GrAssert(NULL == context3D); -#if GR_SUPPORT_GLES1 || GR_SUPPORT_GLDESKTOP gpu = new GrGpuGLFixed; -#endif break; case kDirect3D9_Engine: GrAssert(NULL != context3D); @@ -69,6 +59,3 @@ GrGpu* GrGpu::Create(Engine engine, Platform3DContext context3D) { return gpu; } - - - diff --git a/gpu/src/GrGpuGL.cpp b/gpu/src/GrGpuGL.cpp index b7552d99c9..9604650208 100644 --- a/gpu/src/GrGpuGL.cpp +++ b/gpu/src/GrGpuGL.cpp @@ -16,14 +16,6 @@ #include "GrGpuGL.h" #include "GrMemory.h" -#if GR_WIN32_BUILD - // need to get wglGetProcAddress - #undef WIN32_LEAN_AND_MEAN - #define WIN32_LEAN_AND_MEAN 1 - #include - #undef WIN32_LEAN_AND_MEAN -#endif - static const GrGLuint GR_MAX_GLUINT = ~0; static const GrGLint GR_INVAL_GLINT = ~0; @@ -201,14 +193,14 @@ GrGpuGL::GrGpuGL() { // check FS and fixed-function texture unit limits // we only use textures in the fragment stage currently. // checks are > to make sure we have a spare unit. -#if GR_SUPPORT_GLDESKTOP || GR_SUPPORT_GLES2 - GR_GL_GetIntegerv(GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits); - GrAssert(maxTextureUnits > kNumStages); -#endif -#if GR_SUPPORT_GLDESKTOP || GR_SUPPORT_GLES1 - GR_GL_GetIntegerv(GR_GL_MAX_TEXTURE_UNITS, &maxTextureUnits); - GrAssert(maxTextureUnits > kNumStages); -#endif + if (GR_GL_SUPPORT_DESKTOP || GR_GL_SUPPORT_ES2) { + GR_GL_GetIntegerv(GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits); + GrAssert(maxTextureUnits > kNumStages); + } + if (GR_GL_SUPPORT_DESKTOP || GR_GL_SUPPORT_ES1) { + GR_GL_GetIntegerv(GR_GL_MAX_TEXTURE_UNITS, &maxTextureUnits); + GrAssert(maxTextureUnits > kNumStages); + } //////////////////////////////////////////////////////////////////////////// // Check for supported features. @@ -250,17 +242,16 @@ GrGpuGL::GrGpuGL() { GrPrintf("MSAA Support: APPLE ES EXT.\n"); } } -#if GR_SUPPORT_GLDESKTOP - else if ((major >= 3) || + else if (GR_GL_SUPPORT_DESKTOP && ( + (major >= 3) || has_gl_extension("GL_ARB_framebuffer_object") || (has_gl_extension("GL_EXT_framebuffer_multisample") && - has_gl_extension("GL_EXT_framebuffer_blit"))) { + has_gl_extension("GL_EXT_framebuffer_blit")))) { fMSFBOType = kDesktop_MSFBO; if (gPrintStartupSpew) { GrPrintf("MSAA Support: DESKTOP\n"); } } -#endif else { if (gPrintStartupSpew) { GrPrintf("MSAA Support: NONE\n"); @@ -288,83 +279,84 @@ GrGpuGL::GrGpuGL() { } } -#if GR_SUPPORT_GLDESKTOP - fHasStencilWrap = (major >= 2 || (major == 1 && minor >= 4)) || - has_gl_extension("GL_EXT_stencil_wrap"); -#else - fHasStencilWrap = (major >= 2) || has_gl_extension("GL_OES_stencil_wrap"); -#endif + if (GR_GL_SUPPORT_DESKTOP) { + fHasStencilWrap = (major >= 2 || (major == 1 && minor >= 4)) || + has_gl_extension("GL_EXT_stencil_wrap"); + } else { + fHasStencilWrap = (major >= 2) || has_gl_extension("GL_OES_stencil_wrap"); + } if (gPrintStartupSpew) { GrPrintf("Stencil Wrap: %s\n", (fHasStencilWrap ? "YES" : "NO")); } -#if GR_SUPPORT_GLDESKTOP - // we could also look for GL_ATI_separate_stencil extension or - // GL_EXT_stencil_two_side but they use different function signatures - // than GL2.0+ (and than each other). - fTwoSidedStencilSupport = (major >= 2); - // supported on GL 1.4 and higher or by extension - fStencilWrapOpsSupport = (major > 1) || - ((1 == major) && (minor >= 4)) || - has_gl_extension("GL_EXT_stencil_wrap"); -#else - // ES 2 has two sided stencil but 1.1 doesn't. There doesn't seem to be - // an ES1 extension. - fTwoSidedStencilSupport = (major >= 2); - // stencil wrap support is in ES2, ES1 requires extension. - fStencilWrapOpsSupport = (major > 1) || - has_gl_extension("GL_OES_stencil_wrap"); - -#endif + if (GR_GL_SUPPORT_DESKTOP) { + // we could also look for GL_ATI_separate_stencil extension or + // GL_EXT_stencil_two_side but they use different function signatures + // than GL2.0+ (and than each other). + fTwoSidedStencilSupport = (major >= 2); + // supported on GL 1.4 and higher or by extension + fStencilWrapOpsSupport = (major > 1) || + ((1 == major) && (minor >= 4)) || + has_gl_extension("GL_EXT_stencil_wrap"); + } else { + // ES 2 has two sided stencil but 1.1 doesn't. There doesn't seem to be + // an ES1 extension. + fTwoSidedStencilSupport = (major >= 2); + // stencil wrap support is in ES2, ES1 requires extension. + fStencilWrapOpsSupport = (major > 1) || + has_gl_extension("GL_OES_stencil_wrap"); + } if (gPrintStartupSpew) { GrPrintf("Stencil Caps: TwoSide: %s, Wrap: %s\n", (fTwoSidedStencilSupport ? "YES" : "NO"), (fStencilWrapOpsSupport ? "YES" : "NO")); } -#if GR_SUPPORT_GLDESKTOP - fRGBA8Renderbuffer = true; -#else - fRGBA8Renderbuffer = has_gl_extension("GL_OES_rgb8_rgba8"); -#endif + if (GR_GL_SUPPORT_DESKTOP) { + fRGBA8Renderbuffer = true; + } else { + fRGBA8Renderbuffer = has_gl_extension("GL_OES_rgb8_rgba8"); + } if (gPrintStartupSpew) { GrPrintf("RGBA Renderbuffer: %s\n", (fRGBA8Renderbuffer ? "YES" : "NO")); } -#if GR_SUPPORT_GLES - if (GR_GL_32BPP_COLOR_FORMAT == GR_BGRA) { - GrAssert(has_gl_extension("GL_EXT_texture_format_BGRA8888")); + + if (GR_GL_SUPPORT_ES) { + if (GR_GL_32BPP_COLOR_FORMAT == GR_BGRA) { + GrAssert(has_gl_extension("GL_EXT_texture_format_BGRA8888")); + } } -#endif -#if GR_SUPPORT_GLDESKTOP - fBufferLockSupport = true; // we require VBO support and the desktop VBO - // extension includes glMapBuffer. -#else - fBufferLockSupport = has_gl_extension("GL_OES_mapbuffer"); -#endif + if (GR_GL_SUPPORT_DESKTOP) { + fBufferLockSupport = true; // we require VBO support and the desktop VBO + // extension includes glMapBuffer. + } else { + fBufferLockSupport = has_gl_extension("GL_OES_mapbuffer"); + } if (gPrintStartupSpew) { GrPrintf("Map Buffer: %s\n", (fBufferLockSupport ? "YES" : "NO")); } -#if GR_SUPPORT_GLDESKTOP - if (major >= 2 || has_gl_extension("GL_ARB_texture_non_power_of_two")) { - fNPOTTextureTileSupport = true; - fNPOTTextureSupport = true; - } else { - fNPOTTextureTileSupport = false; - fNPOTTextureSupport = false; - } -#else - if (major >= 2) { - fNPOTTextureSupport = true; - fNPOTTextureTileSupport = has_gl_extension("GL_OES_texture_npot"); + if (GR_GL_SUPPORT_DESKTOP) { + if (major >= 2 || has_gl_extension("GL_ARB_texture_non_power_of_two")) { + fNPOTTextureTileSupport = true; + fNPOTTextureSupport = true; + } else { + fNPOTTextureTileSupport = false; + fNPOTTextureSupport = false; + } } else { - fNPOTTextureSupport = has_gl_extension("GL_APPLE_texture_2D_limited_npot"); - fNPOTTextureTileSupport = false; + if (major >= 2) { + fNPOTTextureSupport = true; + fNPOTTextureTileSupport = has_gl_extension("GL_OES_texture_npot"); + } else { + fNPOTTextureSupport = + has_gl_extension("GL_APPLE_texture_2D_limited_npot"); + fNPOTTextureTileSupport = false; + } } -#endif //////////////////////////////////////////////////////////////////////////// // Experiments to determine limitations that can't be queried. TODO: Make @@ -482,11 +474,11 @@ void GrGpuGL::resetContext() { fHWDrawState.fDrawFace = kBoth_DrawFace; GR_GL(Disable(GR_GL_DITHER)); -#if GR_SUPPORT_GLDESKTOP - GR_GL(Disable(GR_GL_LINE_SMOOTH)); - GR_GL(Disable(GR_GL_POINT_SMOOTH)); - GR_GL(Disable(GR_GL_MULTISAMPLE)); -#endif + if (GR_GL_SUPPORT_DESKTOP) { + GR_GL(Disable(GR_GL_LINE_SMOOTH)); + GR_GL(Disable(GR_GL_POINT_SMOOTH)); + GR_GL(Disable(GR_GL_MULTISAMPLE)); + } GR_GL(ColorMask(GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE, GR_GL_TRUE)); fHWDrawState.fFlagBits = 0; @@ -583,25 +575,36 @@ GrRenderTarget* GrGpuGL::createRenderTargetFrom3DApiStateHelper() { static const GrGLuint UNKNOWN_BITS = ~0; -// defines stencil formats from more to less preferred -static const struct { +struct StencilFormat { GrGLenum fEnum; GrGLuint fBits; -} gStencilFormats[] = { - {GR_STENCIL_INDEX8, 8}, +}; -#if GR_SUPPORT_GLDESKTOP - {GR_STENCIL_INDEX16, 16}, -#endif +const StencilFormat* GrGLStencilFormats() { + // defines stencil formats from more to less preferred + static const StencilFormat desktopStencilFormats[] = { + {GR_STENCIL_INDEX8, 8}, + {GR_STENCIL_INDEX16, 16}, + {GR_DEPTH24_STENCIL8, 8}, + {GR_STENCIL_INDEX4, 4}, + {GR_GL_STENCIL_INDEX, UNKNOWN_BITS}, + {GR_DEPTH_STENCIL, UNKNOWN_BITS}, + {0, 0} + }; - {GR_DEPTH24_STENCIL8, 8}, - {GR_STENCIL_INDEX4, 4}, + static const StencilFormat esStencilFormats[] = { + {GR_STENCIL_INDEX8, 8}, + {GR_DEPTH24_STENCIL8, 8}, + {GR_STENCIL_INDEX4, 4}, + {0, 0} + }; -#if GR_SUPPORT_GLDESKTOP - {GR_GL_STENCIL_INDEX, UNKNOWN_BITS}, - {GR_DEPTH_STENCIL, UNKNOWN_BITS} -#endif -}; + if (GR_GL_SUPPORT_DESKTOP) { + return desktopStencilFormats; + } else { + return esStencilFormats; + } +} // good to set a break-point here to know when createTexture fails static GrTexture* return_null_texture() { @@ -667,29 +670,29 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, * to trim those off here, since GL doesn't let us pass the rowBytes as * a parameter to glTexImage2D */ -#if GR_SUPPORT_GLDESKTOP - if (srcData) { - GR_GL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, - rowBytes / glDesc.fUploadByteCount)); - } -#else - GrAutoSMalloc<128 * 128> trimStorage; - size_t trimRowBytes = desc.fWidth * glDesc.fUploadByteCount; - if (srcData && (trimRowBytes < rowBytes)) { - size_t trimSize = desc.fHeight * trimRowBytes; - trimStorage.realloc(trimSize); - // now copy the data into our new storage, skipping the trailing bytes - const char* src = (const char*)srcData; - char* dst = (char*)trimStorage.get(); - for (uint32_t y = 0; y < desc.fHeight; y++) { - memcpy(dst, src, trimRowBytes); - src += rowBytes; - dst += trimRowBytes; + if (GR_GL_SUPPORT_DESKTOP) { + if (srcData) { + GR_GL(PixelStorei(GR_GL_UNPACK_ROW_LENGTH, + rowBytes / glDesc.fUploadByteCount)); + } + } else { + GrAutoSMalloc<128 * 128> trimStorage; + size_t trimRowBytes = desc.fWidth * glDesc.fUploadByteCount; + if (srcData && (trimRowBytes < rowBytes)) { + size_t trimSize = desc.fHeight * trimRowBytes; + trimStorage.realloc(trimSize); + // now copy the data into our new storage, skipping the trailing bytes + const char* src = (const char*)srcData; + char* dst = (char*)trimStorage.get(); + for (uint32_t y = 0; y < desc.fHeight; y++) { + memcpy(dst, src, trimRowBytes); + src += rowBytes; + dst += trimRowBytes; + } + // now point srcData to our trimmed version + srcData = trimStorage.get(); } - // now point srcData to our trimmed version - srcData = trimStorage.get(); } -#endif if (renderTarget) { if (!this->npotRenderTargetSupport()) { @@ -846,11 +849,9 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, } else { rtIDs.fRTFBOID = rtIDs.fTexFBOID; } - int attempts = 1; if (!(kNoPathRendering_TextureFlag & desc.fFlags)) { GR_GL(GenRenderbuffers(1, &rtIDs.fStencilRenderbufferID)); GrAssert(0 != rtIDs.fStencilRenderbufferID); - attempts = GR_ARRAY_COUNT(gStencilFormats); } // someone suggested that some systems might require @@ -859,7 +860,9 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, GR_GL(BindTexture(GR_GL_TEXTURE_2D, 0)); err = ~GR_GL_NO_ERROR; - for (int i = 0; i < attempts; ++i) { + + const StencilFormat* stencilFormats = GrGLStencilFormats(); + for (int i = 0; 0 != stencilFormats[i].fEnum; ++i) { if (rtIDs.fStencilRenderbufferID) { GR_GL(BindRenderbuffer(GR_RENDERBUFFER, rtIDs.fStencilRenderbufferID)); @@ -867,12 +870,12 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, GR_GL_NO_ERR(RenderbufferStorageMultisample( GR_RENDERBUFFER, samples, - gStencilFormats[i].fEnum, + stencilFormats[i].fEnum, glDesc.fAllocWidth, glDesc.fAllocHeight)); } else { GR_GL_NO_ERR(RenderbufferStorage(GR_RENDERBUFFER, - gStencilFormats[i].fEnum, + stencilFormats[i].fEnum, glDesc.fAllocWidth, glDesc.fAllocHeight)); } @@ -941,43 +944,43 @@ GrTexture* GrGpuGL::createTextureHelper(const TextureDesc& desc, } status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); -#if GR_SUPPORT_GLDESKTOP - // On some implementations you have to be bound as DEPTH_STENCIL. - // (Even binding to DEPTH and STENCIL separately with the same - // buffer doesn't work.) - if (rtIDs.fStencilRenderbufferID && - status != GR_FRAMEBUFFER_COMPLETE) { - GR_GL(FramebufferRenderbuffer(GR_FRAMEBUFFER, - GR_STENCIL_ATTACHMENT, - GR_RENDERBUFFER, - 0)); - GR_GL(FramebufferRenderbuffer(GR_FRAMEBUFFER, - GR_DEPTH_STENCIL_ATTACHMENT, - GR_RENDERBUFFER, - rtIDs.fStencilRenderbufferID)); - status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); + if (GR_GL_SUPPORT_DESKTOP) { + // On some implementations you have to be bound as DEPTH_STENCIL. + // (Even binding to DEPTH and STENCIL separately with the same + // buffer doesn't work.) + if (rtIDs.fStencilRenderbufferID && + status != GR_FRAMEBUFFER_COMPLETE) { + GR_GL(FramebufferRenderbuffer(GR_FRAMEBUFFER, + GR_STENCIL_ATTACHMENT, + GR_RENDERBUFFER, + 0)); + GR_GL(FramebufferRenderbuffer(GR_FRAMEBUFFER, + GR_DEPTH_STENCIL_ATTACHMENT, + GR_RENDERBUFFER, + rtIDs.fStencilRenderbufferID)); + status = GR_GL(CheckFramebufferStatus(GR_FRAMEBUFFER)); + } } -#endif if (status != GR_FRAMEBUFFER_COMPLETE) { GrPrintf("-- glCheckFramebufferStatus %x %d %d\n", status, desc.fWidth, desc.fHeight); -#if GR_SUPPORT_GLDESKTOP - if (rtIDs.fStencilRenderbufferID) { - GR_GL(FramebufferRenderbuffer(GR_FRAMEBUFFER, - GR_DEPTH_STENCIL_ATTACHMENT, - GR_RENDERBUFFER, - 0)); + if (GR_GL_SUPPORT_DESKTOP) { + if (rtIDs.fStencilRenderbufferID) { + GR_GL(FramebufferRenderbuffer(GR_FRAMEBUFFER, + GR_DEPTH_STENCIL_ATTACHMENT, + GR_RENDERBUFFER, + 0)); + } } -#endif continue; } // we're successful! failed = false; if (rtIDs.fStencilRenderbufferID) { - if (UNKNOWN_BITS == gStencilFormats[i].fBits) { + if (UNKNOWN_BITS == stencilFormats[i].fBits) { GR_GL_GetIntegerv(GR_GL_STENCIL_BITS, (GrGLint*)&glDesc.fStencilBits); } else { - glDesc.fStencilBits = gStencilFormats[i].fBits; + glDesc.fStencilBits = stencilFormats[i].fBits; } } break; @@ -1556,9 +1559,9 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { newTexParams.fFilter = sampler.isFilter() ? GR_GL_LINEAR : GR_GL_NEAREST; newTexParams.fWrapS = - GrGLTexture::gWrapMode2GLWrap[sampler.getWrapX()]; + GrGLTexture::WrapMode2GLWrap()[sampler.getWrapX()]; newTexParams.fWrapT = - GrGLTexture::gWrapMode2GLWrap[sampler.getWrapY()]; + GrGLTexture::WrapMode2GLWrap()[sampler.getWrapY()]; if (newTexParams.fFilter != oldTexParams.fFilter) { setTextureUnit(s); @@ -1615,33 +1618,33 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) { GR_GL(ColorMask(mask, mask, mask, mask)); } -#if GR_SUPPORT_GLDESKTOP - // ES doesn't support toggling GL_MULTISAMPLE and doesn't have - // smooth lines. - if (fDirtyFlags.fRenderTargetChanged || - (fCurrDrawState.fFlagBits & kAntialias_StateBit) != - (fHWDrawState.fFlagBits & kAntialias_StateBit)) { - GrGLint msaa = 0; - // only perform query if we know MSAA is supported. - // calling on non-MSAA target caused a crash in one environment, - // though I don't think it should. - if (fAASamples[kHigh_AALevel]) { - GR_GL_GetIntegerv(GR_GL_SAMPLE_BUFFERS, &msaa); - } - if (fCurrDrawState.fFlagBits & kAntialias_StateBit) { - if (msaa) { - GR_GL(Enable(GR_GL_MULTISAMPLE)); - } else { - GR_GL(Enable(GR_GL_LINE_SMOOTH)); + if (GR_GL_SUPPORT_DESKTOP) { + // ES doesn't support toggling GL_MULTISAMPLE and doesn't have + // smooth lines. + if (fDirtyFlags.fRenderTargetChanged || + (fCurrDrawState.fFlagBits & kAntialias_StateBit) != + (fHWDrawState.fFlagBits & kAntialias_StateBit)) { + GrGLint msaa = 0; + // only perform query if we know MSAA is supported. + // calling on non-MSAA target caused a crash in one environment, + // though I don't think it should. + if (fAASamples[kHigh_AALevel]) { + GR_GL_GetIntegerv(GR_GL_SAMPLE_BUFFERS, &msaa); } - } else { - if (msaa) { - GR_GL(Disable(GR_GL_MULTISAMPLE)); + if (fCurrDrawState.fFlagBits & kAntialias_StateBit) { + if (msaa) { + GR_GL(Enable(GR_GL_MULTISAMPLE)); + } else { + GR_GL(Enable(GR_GL_LINE_SMOOTH)); + } + } else { + if (msaa) { + GR_GL(Disable(GR_GL_MULTISAMPLE)); + } + GR_GL(Disable(GR_GL_LINE_SMOOTH)); } - GR_GL(Disable(GR_GL_LINE_SMOOTH)); } } -#endif bool blendOff = canDisableBlend(); if (fHWBlendDisabled != blendOff) { @@ -1775,13 +1778,13 @@ bool GrGpuGL::canBeTexture(GrTexture::PixelConfig config, case GrTexture::kRGBA_8888_PixelConfig: case GrTexture::kRGBX_8888_PixelConfig: // todo: can we tell it our X? *format = GR_GL_32BPP_COLOR_FORMAT; -#if GR_SUPPORT_GLES - // according to GL_EXT_texture_format_BGRA8888 the *internal* - // format for a BGRA is BGRA not RGBA (as on desktop) - *internalFormat = GR_GL_32BPP_COLOR_FORMAT; -#else - *internalFormat = GR_GL_RGBA; -#endif + if (GR_GL_SUPPORT_ES) { + // according to GL_EXT_texture_format_BGRA8888 the *internal* + // format for a BGRA is BGRA not RGBA (as on desktop) + *internalFormat = GR_GL_32BPP_COLOR_FORMAT; + } else { + *internalFormat = GR_GL_RGBA; + } *type = GR_GL_UNSIGNED_BYTE; break; case GrTexture::kRGB_565_PixelConfig: @@ -1845,12 +1848,12 @@ bool GrGpuGL::fboInternalFormat(GrTexture::PixelConfig config, GrGLenum* format) } else { return false; } -#if GR_SUPPORT_GLES // ES2 supports 565. ES1 supports it with FBO extension - // desktop GL has no such internal format case GrTexture::kRGB_565_PixelConfig: + GrAssert(GR_GL_SUPPORT_ES); // ES2 supports 565. ES1 supports it + // with FBO extension desktop GL has + // no such internal format *format = GR_RGB565; return true; -#endif case GrTexture::kRGBA_4444_PixelConfig: *format = GR_GL_RGBA4; return true; diff --git a/gpu/src/GrGpuGLFixed.cpp b/gpu/src/GrGpuGLFixed.cpp index 5a053a0223..3e6d909792 100644 --- a/gpu/src/GrGpuGLFixed.cpp +++ b/gpu/src/GrGpuGLFixed.cpp @@ -17,8 +17,6 @@ #include "GrGLConfig.h" -#if GR_SUPPORT_GLES1 || GR_SUPPORT_GLDESKTOP - #include "GrGpuGLFixed.h" #include "GrGpuVertex.h" @@ -137,13 +135,13 @@ bool GrGpuGLFixed::flushGraphicsState(GrPrimitiveType type) { } } -#if GR_SUPPORT_GLES1 - if (BlendCoefReferencesConstant(fCurrDrawState.fSrcBlend) || - BlendCoefReferencesConstant(fCurrDrawState.fDstBlend)) { - uimpl("ES1 doesn't support blend constant"); - return false; + if (GR_GL_SUPPORT_ES1) { + if (BlendCoefReferencesConstant(fCurrDrawState.fSrcBlend) || + BlendCoefReferencesConstant(fCurrDrawState.fDstBlend)) { + unimpl("ES1 doesn't support blend constant"); + return false; + } } -#endif if (!flushGLStateCommon(type)) { return false; @@ -330,6 +328,3 @@ void GrGpuGLFixed::setupGeometry(int* startVertex, fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout; fHWGeometryState.fArrayPtrsDirty = false; } - -#endif - diff --git a/gpu/src/GrGpuGLShaders2.cpp b/gpu/src/GrGpuGLShaders2.cpp index 972d8a3f7a..a56e511fca 100644 --- a/gpu/src/GrGpuGLShaders2.cpp +++ b/gpu/src/GrGpuGLShaders2.cpp @@ -17,8 +17,6 @@ #include "GrGLConfig.h" -#if GR_SUPPORT_GLES2 || GR_SUPPORT_GLDESKTOP - #include "GrGpuGLShaders2.h" #include "GrGpuVertex.h" #include "GrMemory.h" @@ -31,15 +29,6 @@ #define SKIP_CACHE_CHECK true -#if GR_SUPPORT_GLES2 - #define GR_PRECISION "mediump" - const char GR_SHADER_PRECISION[] = "precision mediump float;\n"; -#else - #define GR_PRECISION "" - const char GR_SHADER_PRECISION[] = ""; -#endif - - #define POS_ATTR_LOCATION 0 #define TEX_ATTR_LOCATION(X) (1 + X) #define COL_ATTR_LOCATION (2 + GrDrawTarget::kMaxTexCoords) @@ -51,6 +40,26 @@ #define GR_UINT32_MAX static_cast(-1) +namespace { + +const char* GrPrecision() { + if (GR_GL_SUPPORT_ES2) { + return "mediump"; + } else { + return ""; + } +} + +const char* GrShaderPrecision() { + if (GR_GL_SUPPORT_ES2) { + return "precision mediump float;\n"; + } else { + return ""; + } +} + +} // namespace + struct GrGpuGLShaders2::StageUniLocations { GrGLint fTextureMatrixUni; GrGLint fSamplerUni; @@ -501,11 +510,15 @@ void GrGpuGLShaders2::GenStageCode(int stageNum, if (StageDesc::kRadial2Gradient_CoordMapping == desc.fCoordMapping) { - segments->fVSUnis += "uniform " GR_PRECISION " float "; + segments->fVSUnis += "uniform "; + segments->fVSUnis += GrPrecision(); + segments->fVSUnis += " float "; segments->fVSUnis += radial2ParamsName; segments->fVSUnis += "[6];\n"; - segments->fFSUnis += "uniform " GR_PRECISION " float "; + segments->fFSUnis += "uniform "; + segments->fFSUnis += GrPrecision(); + segments->fFSUnis += " float "; segments->fFSUnis += radial2ParamsName; segments->fFSUnis += "[6];\n"; locations->fRadial2Uni = 1; @@ -821,9 +834,9 @@ void GrGpuGLShaders2::GenProgram(const ProgramDesc& desc, stringCnt = 0; - if (GR_ARRAY_COUNT(GR_SHADER_PRECISION) > 1) { - strings[stringCnt] = GR_SHADER_PRECISION; - lengths[stringCnt] = GR_ARRAY_COUNT(GR_SHADER_PRECISION) - 1; + if (strlen(GrShaderPrecision()) > 1) { + strings[stringCnt] = GrShaderPrecision(); + lengths[stringCnt] = strlen(GrShaderPrecision()); ++stringCnt; } if (segments.fFSUnis.length()) { @@ -844,7 +857,7 @@ void GrGpuGLShaders2::GenProgram(const ProgramDesc& desc, #if PRINT_SHADERS GrPrintf("%s%s%s%s\n", - GR_SHADER_PRECISION, + GrShaderPrecision(), segments.fFSUnis.cstr(), segments.fVaryings.cstr(), segments.fFSCode.cstr()); @@ -1401,6 +1414,3 @@ void GrGpuGLShaders2::setupGeometry(int* startVertex, fHWGeometryState.fVertexLayout = fGeometrySrc.fVertexLayout; fHWGeometryState.fArrayPtrsDirty = false; } -#endif - - -- cgit v1.2.3