Initial version of R8 support

http://codereview.appspot.com/5967067/



git-svn-id: http://skia.googlecode.com/svn/trunk@3622 2bbb7eff-a529-9590-31e7-b0007b416f81

6 files changed, 83 insertions, 23 deletions

diff --git a/src/gpu/gl/GrGLCaps.cpp b/src/gpu/gl/GrGLCaps.cpp
index d690ff3fe1..8b14a1b678 100644
--- a/src/gpu/gl/GrGLCaps.cpp
+++ b/src/gpu/gl/GrGLCaps.cpp
@@ -30,6 +30,7 @@ void GrGLCaps::reset() {
     fPackFlipYSupport = false;
     fTextureUsageSupport = false;
     fTexStorageSupport = false;
+    fTextureRedSupport = false;
 }
 
 GrGLCaps::GrGLCaps(const GrGLCaps& caps) {
@@ -52,6 +53,7 @@ GrGLCaps& GrGLCaps::operator = (const GrGLCaps& caps) {
     fPackFlipYSupport = caps.fPackFlipYSupport;
     fTextureUsageSupport = caps.fTextureUsageSupport;
     fTexStorageSupport = caps.fTexStorageSupport;
+    fTextureRedSupport = caps.fTextureRedSupport;
 
     return *this;
 }
@@ -129,6 +131,14 @@ void GrGLCaps::init(const GrGLContextInfo& ctxInfo) {
                          ctxInfo.hasExtension("GL_ARB_texture_storage") ||
                          ctxInfo.hasExtension("GL_EXT_texture_storage");
 
+    // ARB_texture_rg is part of OpenGL 3.0
+    if (kDesktop_GrGLBinding == binding) {
+        fTextureRedSupport = version >= GR_GL_VER(3,0) ||
+                             ctxInfo.hasExtension("GL_ARB_texture_rg");
+    } else {
+        fTextureRedSupport = ctxInfo.hasExtension("GL_ARB_texture_rg");
+    }
+
     this->initFSAASupport(ctxInfo);
     this->initStencilFormats(ctxInfo);
 }
diff --git a/src/gpu/gl/GrGLCaps.h b/src/gpu/gl/GrGLCaps.h
index a5318ebde8..8b3f9e70a0 100644
--- a/src/gpu/gl/GrGLCaps.h
+++ b/src/gpu/gl/GrGLCaps.h
@@ -158,6 +158,9 @@ public:
     /// Is there support for glTexStorage
     bool texStorageSupport() const { return fTexStorageSupport; }
 
+    /// Is there support for GL_RED and GL_R8
+    bool textureRedSupport() const { return fTextureRedSupport; }
+
 private:
     /**
      * Maintains a bit per GrPixelConfig. It is used to avoid redundantly
@@ -222,6 +225,7 @@ private:
     bool fPackFlipYSupport : 1;
     bool fTextureUsageSupport : 1;
     bool fTexStorageSupport : 1;
+    bool fTextureRedSupport : 1;
 };
 
 #endif
diff --git a/src/gpu/gl/GrGLProgram.cpp b/src/gpu/gl/GrGLProgram.cpp
index a39b0b91bf..f2776474af 100644
--- a/src/gpu/gl/GrGLProgram.cpp
+++ b/src/gpu/gl/GrGLProgram.cpp
@@ -1897,11 +1897,17 @@ void GrGLProgram::genStageCode(const GrGLContextInfo& gl,
     const char* swizzle = "";
     if (desc.fInConfigFlags & StageDesc::kSwapRAndB_InConfigFlag) {
         GrAssert(!(desc.fInConfigFlags & StageDesc::kSmearAlpha_InConfigFlag));
+        GrAssert(!(desc.fInConfigFlags & StageDesc::kSmearRed_InConfigFlag));
         swizzle = ".bgra";
     } else if (desc.fInConfigFlags & StageDesc::kSmearAlpha_InConfigFlag) {
         GrAssert(!(desc.fInConfigFlags & kMulByAlphaMask));
+        GrAssert(!(desc.fInConfigFlags & StageDesc::kSmearRed_InConfigFlag));
         swizzle = ".aaaa";
-    } 
+    } else if (desc.fInConfigFlags & StageDesc::kSmearRed_InConfigFlag) {
+        GrAssert(!(desc.fInConfigFlags & kMulByAlphaMask));
+        GrAssert(!(desc.fInConfigFlags & StageDesc::kSmearAlpha_InConfigFlag));
+        swizzle = ".rrrr";
+    }
 
     GrStringBuilder modulate;
     if (NULL != fsInColor) {
@@ -1951,6 +1957,8 @@ void GrGLProgram::genStageCode(const GrGLContextInfo& gl,
             GrAssert(GrIsPow2(kMulByAlphaMask & desc.fInConfigFlags));
             GrAssert(!(desc.fInConfigFlags & 
                        StageDesc::kSmearAlpha_InConfigFlag));
+            GrAssert(!(desc.fInConfigFlags & 
+                       StageDesc::kSmearRed_InConfigFlag));
             segments->fFSCode.appendf("\t%s = %s(%s, %s)%s;\n",
                                       fsOutColor, texFunc.c_str(), 
                                       samplerName, sampleCoords.c_str(),
diff --git a/src/gpu/gl/GrGLProgram.h b/src/gpu/gl/GrGLProgram.h
index 76f9c9006f..0d8c39a786 100644
--- a/src/gpu/gl/GrGLProgram.h
+++ b/src/gpu/gl/GrGLProgram.h
@@ -120,7 +120,7 @@ public:
               described are performed after reading a texel.
              */
             enum InConfigFlags {
-                kNone_InConfigFlag                      = 0x0,
+                kNone_InConfigFlag                      = 0x00,
 
                 /**
                   Swap the R and B channels. This is incompatible with
@@ -128,15 +128,24 @@ public:
                   the shader using GL_ARB_texture_swizzle if possible rather
                   than setting this flag.
                  */
-                kSwapRAndB_InConfigFlag                 = 0x1,
+                kSwapRAndB_InConfigFlag                 = 0x01,
 
                 /**
                  Smear alpha across all four channels. This is incompatible with
-                 kSwapRAndB and kMulRGBByAlpha*. It is prefereable to perform
-                 the smear outside the shader using GL_ARB_texture_swizzle if
-                 possible rather than setting this flag.
+                 kSwapRAndB, kMulRGBByAlpha* and kSmearRed. It is prefereable 
+                 to perform the smear outside the shader using 
+                 GL_ARB_texture_swizzle if possible rather than setting this 
+                 flag.
                 */
-                kSmearAlpha_InConfigFlag                = 0x2,
+                kSmearAlpha_InConfigFlag                = 0x02,
+
+                /**
+                 Smear the red channel across all four channels. This flag is 
+                 incompatible with kSwapRAndB, kMulRGBByAlpha*and kSmearAlpha. 
+                 It is preferable to use GL_ARB_texture_swizzle instead of this 
+                 flag.
+                */
+                kSmearRed_InConfigFlag                  = 0x04,
 
                 /**
                  Multiply r,g,b by a after texture reads. This flag incompatible
@@ -147,8 +156,8 @@ public:
                  of 1/255.0 and the other rounds down. At most one of these
                  flags may be set.
                  */
-                kMulRGBByAlpha_RoundUp_InConfigFlag     =  0x4,
-                kMulRGBByAlpha_RoundDown_InConfigFlag   =  0x8,
+                kMulRGBByAlpha_RoundUp_InConfigFlag     =  0x08,
+                kMulRGBByAlpha_RoundDown_InConfigFlag   =  0x10,
 
                 kDummyInConfigFlag,
                 kInConfigBitMask = (kDummyInConfigFlag-1) |
diff --git a/src/gpu/gl/GrGpuGL.cpp b/src/gpu/gl/GrGpuGL.cpp
index 8214b6ea53..8481b74ab4 100644
--- a/src/gpu/gl/GrGpuGL.cpp
+++ b/src/gpu/gl/GrGpuGL.cpp
@@ -1947,12 +1947,20 @@ unsigned gr_to_gl_filter(GrSamplerState::Filter filter) {
     }
 }
 
-const GrGLenum* get_swizzle(GrPixelConfig config,
-                            const GrSamplerState& sampler) {
+// get_swizzle is only called from this .cpp so it is OK to inline it here
+inline const GrGLenum* get_swizzle(GrPixelConfig config,
+                                   const GrSamplerState& sampler,
+                                   const GrGLCaps& glCaps) {
     if (GrPixelConfigIsAlphaOnly(config)) {
-        static const GrGLenum gAlphaSmear[] = { GR_GL_ALPHA, GR_GL_ALPHA,
-                                                GR_GL_ALPHA, GR_GL_ALPHA };
-        return gAlphaSmear;
+        if (glCaps.textureRedSupport()) {
+            static const GrGLenum gRedSmear[] = { GR_GL_RED, GR_GL_RED,
+                                                  GR_GL_RED, GR_GL_RED };
+            return gRedSmear;
+        } else {
+            static const GrGLenum gAlphaSmear[] = { GR_GL_ALPHA, GR_GL_ALPHA,
+                                                    GR_GL_ALPHA, GR_GL_ALPHA };
+            return gAlphaSmear;
+        }
     } else if (sampler.swapsRAndB()) {
         static const GrGLenum gRedBlueSwap[] = { GR_GL_BLUE, GR_GL_GREEN,
                                                  GR_GL_RED,  GR_GL_ALPHA };
@@ -2032,7 +2040,7 @@ bool GrGpuGL::flushGLStateCommon(GrPrimitiveType type) {
             newTexParams.fWrapS = wraps[sampler.getWrapX()];
             newTexParams.fWrapT = wraps[sampler.getWrapY()];
             memcpy(newTexParams.fSwizzleRGBA,
-                   get_swizzle(nextTexture->config(), sampler),
+                   get_swizzle(nextTexture->config(), sampler, this->glCaps()),
                    sizeof(newTexParams.fSwizzleRGBA));
             if (setAll || newTexParams.fFilter != oldTexParams.fFilter) {
                 setTextureUnit(s);
@@ -2274,14 +2282,25 @@ bool GrGpuGL::configToGLFormats(GrPixelConfig config,
             }
             break;
         case kAlpha_8_GrPixelConfig:
-            *internalFormat = GR_GL_ALPHA;
-            *externalFormat = GR_GL_ALPHA;
-            if (getSizedInternalFormat) {
-                *internalFormat = GR_GL_ALPHA8;
+            if (this->glCaps().textureRedSupport()) {
+                *internalFormat = GR_GL_RED;
+                *externalFormat = GR_GL_RED;
+                if (getSizedInternalFormat) {
+                    *internalFormat = GR_GL_R8;
+                } else {
+                    *internalFormat = GR_GL_RED;
+                }
+                *externalType = GR_GL_UNSIGNED_BYTE;
             } else {
                 *internalFormat = GR_GL_ALPHA;
+                *externalFormat = GR_GL_ALPHA;
+                if (getSizedInternalFormat) {
+                    *internalFormat = GR_GL_ALPHA8;
+                } else {
+                    *internalFormat = GR_GL_ALPHA;
+                }
+                *externalType = GR_GL_UNSIGNED_BYTE;
             }
-            *externalType = GR_GL_UNSIGNED_BYTE;
             break;
         default:
             return false;
diff --git a/src/gpu/gl/GrGpuGLShaders.cpp b/src/gpu/gl/GrGpuGLShaders.cpp
index b416b5cdd1..9627107e79 100644
--- a/src/gpu/gl/GrGpuGLShaders.cpp
+++ b/src/gpu/gl/GrGpuGLShaders.cpp
@@ -178,6 +178,7 @@ bool GrGpuGLShaders::programUnitTest() {
         StageDesc::kMulRGBByAlpha_RoundUp_InConfigFlag,
         StageDesc::kMulRGBByAlpha_RoundDown_InConfigFlag,
         StageDesc::kSmearAlpha_InConfigFlag,
+        StageDesc::kSmearRed_InConfigFlag,
     };
     GrGLProgram program;
     ProgramDesc& pdesc = program.fProgramDesc;
@@ -271,6 +272,7 @@ bool GrGpuGLShaders::programUnitTest() {
             static const uint32_t kMulByAlphaMask =
                 StageDesc::kMulRGBByAlpha_RoundUp_InConfigFlag |
                 StageDesc::kMulRGBByAlpha_RoundDown_InConfigFlag;
+
             switch (stage.fFetchMode) {
                 case StageDesc::kSingle_FetchMode:
                     stage.fKernelWidth = 0;
@@ -1132,9 +1134,17 @@ void GrGpuGLShaders::buildProgram(GrPrimitiveType type,
             if (!this->glCaps().textureSwizzleSupport()) {
                 if (GrPixelConfigIsAlphaOnly(texture->config())) {
                     // if we don't have texture swizzle support then
-                    // the shader must do an alpha smear after reading
-                    // the texture
-                    stage.fInConfigFlags |= StageDesc::kSmearAlpha_InConfigFlag;
+                    // the shader must smear the single channel after
+                    // reading the texture
+                    if (this->glCaps().textureRedSupport()) {
+                        // we can use R8 textures so use kSmearRed
+                        stage.fInConfigFlags |= 
+                                        StageDesc::kSmearRed_InConfigFlag;
+                    } else {
+                        // we can use A8 textures so use kSmearAlpha
+                        stage.fInConfigFlags |= 
+                                        StageDesc::kSmearAlpha_InConfigFlag;
+                    }
                 } else if (sampler.swapsRAndB()) {
                     stage.fInConfigFlags |= StageDesc::kSwapRAndB_InConfigFlag;
                 }