Add support for half float alpha textures.

src/gpu/gl/GrGLCaps.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "GrGLCaps.h"
 
@@ skipping 372 matching lines @@
         fUseDrawInsteadOfClear = true;
     }
 
     this->initConfigTexturableTable(ctxInfo, gli);
     this->initConfigRenderableTable(ctxInfo);
 
     return true;
 }
 
 void GrGLCaps::initConfigRenderableTable(const GrGLContextInfo& ctxInfo) {
-
     // OpenGL < 3.0
     //  no support for render targets unless the GL_ARB_framebuffer_object
     //  extension is supported (in which case we get ALPHA, RED, RG, RGB,
     //  RGBA (ALPHA8, RGBA4, RGBA8) for OpenGL > 1.1). Note that we
     //  probably don't get R8 in this case.
 
     // OpenGL 3.0
     //  base color renderable: ALPHA, RED, RG, RGB, and RGBA
     //  sized derivatives: ALPHA8, R8, RGBA4, RGBA8
 
@@ skipping 59 matching lines @@
         if (ctxInfo.hasExtension("GL_CHROMIUM_renderbuffer_format_BGRA8888")) {
             fConfigRenderSupport[kBGRA_8888_GrPixelConfig][kYes_MSAA] = true;
         } else {
             fConfigRenderSupport[kBGRA_8888_GrPixelConfig][kYes_MSAA] =
                 !fBGRAIsInternalFormat || !this->usesMSAARenderBuffers();
         }
     }
 
     if (this->isConfigTexturable(kRGBA_float_GrPixelConfig)) {
         fConfigRenderSupport[kRGBA_float_GrPixelConfig][kNo_MSAA] = true;
+        if (kGL_GrGLStandard == standard) {
+            fConfigRenderSupport[kRGBA_float_GrPixelConfig][kYes_MSAA] = true;
+        } else {
+            // for now we don't support float point MSAA on ES
+            fConfigRenderSupport[kAlpha_half_GrPixelConfig][kYes_MSAA] = false;
+        }
     }
 
+    if (this->isConfigTexturable(kAlpha_half_GrPixelConfig)) {
+        fConfigRenderSupport[kAlpha_half_GrPixelConfig][kNo_MSAA] = true;
+        if (kGL_GrGLStandard == standard) {
+            fConfigRenderSupport[kAlpha_half_GrPixelConfig][kYes_MSAA] = true;
+        } else {
+            // for now we don't support float point MSAA on ES
+            fConfigRenderSupport[kAlpha_half_GrPixelConfig][kYes_MSAA] = false;
+        }
+    }
+    
     // If we don't support MSAA then undo any places above where we set a config as renderable with
     // msaa.
     if (kNone_MSFBOType == fMSFBOType) {
         for (int i = 0; i < kGrPixelConfigCnt; ++i) {
             fConfigRenderSupport[i][kYes_MSAA] = false;
         }
     }
 }
 
 void GrGLCaps::initConfigTexturableTable(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
@@ skipping 115 matching lines @@
     // filtering modes are not supported.  This is for simplicity, but a more
     // granular approach is possible.  Coincidentally, floating point textures became part of
     // the standard in ES3.1 / OGL 3.1, hence the shorthand
     bool hasFPTextures = version >= GR_GL_VER(3, 1);
     if (!hasFPTextures) {
         hasFPTextures = ctxInfo.hasExtension("GL_ARB_texture_float") ||
                         (ctxInfo.hasExtension("OES_texture_float_linear") &&
                          ctxInfo.hasExtension("GL_OES_texture_float"));
     }
     fConfigTextureSupport[kRGBA_float_GrPixelConfig] = hasFPTextures;
+
+    // Check for fp16 texture support
+    // NOTE: We disallow floating point textures on ES devices if linear
+    // filtering modes are not supported.  This is for simplicity, but a more
+    // granular approach is possible.  Coincidentally, 16-bit floating point textures became part of
+    // the standard in ES3.1 / OGL 3.1, hence the shorthand
+    bool hasHalfFPTextures = version >= GR_GL_VER(3, 1);
+    if (!hasHalfFPTextures) {
+        hasHalfFPTextures = ctxInfo.hasExtension("GL_ARB_texture_float") ||
+        (ctxInfo.hasExtension("OES_texture_half_float_linear") &&
+         ctxInfo.hasExtension("GL_OES_texture_half_float"));
+    }
+    fConfigTextureSupport[kAlpha_half_GrPixelConfig] = hasHalfFPTextures && fTextureRedSupport;
 }
 
 bool GrGLCaps::doReadPixelsSupported(const GrGLInterface* intf,
                                      GrGLenum format,
                                      GrGLenum type) const {
     if (GR_GL_RGBA == format && GR_GL_UNSIGNED_BYTE == type) {
         // ES 2 guarantees this format is supported
         return true;
     }
 
@@ skipping 249 matching lines @@
     r.appendf("Two Format Limit: %s\n", (fTwoFormatLimit ? "YES": "NO"));
     r.appendf("Fragment coord conventions support: %s\n",
              (fFragCoordsConventionSupport ? "YES": "NO"));
     r.appendf("Vertex array object support: %s\n", (fVertexArrayObjectSupport ? "YES": "NO"));
     r.appendf("Use non-VBO for dynamic data: %s\n",
              (fUseNonVBOVertexAndIndexDynamicData ? "YES" : "NO"));
     r.appendf("Full screen clear is free: %s\n", (fFullClearIsFree ? "YES" : "NO"));
     r.appendf("Drops tile on zero divide: %s\n", (fDropsTileOnZeroDivide ? "YES" : "NO"));
     return r;
 }