Move ETC1 and LATC enums value to GrPixelConfig

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"
 #include "GrGLContext.h"
@@ skipping 351 matching lines @@
     }
 
     if (GrGLCaps::kES_IMG_MsToTexture_MSFBOType == fMSFBOType) {
         GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES_IMG, &fMaxSampleCount);
     } else if (GrGLCaps::kNone_MSFBOType != fMSFBOType) {
         GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES, &fMaxSampleCount);
     }
 
     this->initConfigRenderableTable(ctxInfo);
 
-    this->initCompressedTextureSupport(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.
@@ skipping 13 matching lines @@
     // ES 2.0
     //  color renderable: RGBA4, RGB5_A1, RGB565
     //  GL_EXT_texture_rg adds support for R8 as a color render target
     //  GL_OES_rgb8_rgba8 and/or GL_ARM_rgba8 adds support for RGBA8
     //  GL_EXT_texture_format_BGRA8888 and/or GL_APPLE_texture_format_BGRA8888 added BGRA support
 
     // ES 3.0
     // Same as ES 2.0 except R8 and RGBA8 are supported without extensions (the functions called
     // below already account for this).
 
+    GrGLStandard standard = ctxInfo.standard();
+    GrGLVersion version = ctxInfo.version();
+
     enum {
         kNo_MSAA = 0,
         kYes_MSAA = 1,
     };
 
-    if (kGL_GrGLStandard == ctxInfo.standard()) {
+    if (kGL_GrGLStandard == standard) {
         // Post 3.0 we will get R8
         // Prior to 3.0 we will get ALPHA8 (with GL_ARB_framebuffer_object)
         if (ctxInfo.version() >= GR_GL_VER(3,0) ||
             ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {
             fConfigRenderSupport[kAlpha_8_GrPixelConfig][kNo_MSAA] = true;
             fConfigRenderSupport[kAlpha_8_GrPixelConfig][kYes_MSAA] = true;
         }
     } else {
         // On ES we can only hope for R8
         fConfigRenderSupport[kAlpha_8_GrPixelConfig][kNo_MSAA] = fTextureRedSupport;
         fConfigRenderSupport[kAlpha_8_GrPixelConfig][kYes_MSAA] = fTextureRedSupport;
     }
 
-    if (kGL_GrGLStandard != ctxInfo.standard()) {
+    if (kGL_GrGLStandard != standard) {
         // only available in ES
         fConfigRenderSupport[kRGB_565_GrPixelConfig][kNo_MSAA] = true;
         fConfigRenderSupport[kRGB_565_GrPixelConfig][kYes_MSAA] = true;
     }
 
     // we no longer support 444 as a render target
     fConfigRenderSupport[kRGBA_4444_GrPixelConfig][kNo_MSAA]  = false;
     fConfigRenderSupport[kRGBA_4444_GrPixelConfig][kYes_MSAA]  = false;
 
     if (this->fRGBA8RenderbufferSupport) {
         fConfigRenderSupport[kRGBA_8888_GrPixelConfig][kNo_MSAA]  = true;
         fConfigRenderSupport[kRGBA_8888_GrPixelConfig][kYes_MSAA]  = true;
     }
 
     if (this->fBGRAFormatSupport) {
         fConfigRenderSupport[kBGRA_8888_GrPixelConfig][kNo_MSAA]  = true;
         // The GL_EXT_texture_format_BGRA8888 extension does not add BGRA to the list of
         // configs that are color-renderable and can be passed to glRenderBufferStorageMultisample.
         // Chromium may have an extension to allow BGRA renderbuffers to work on desktop platforms.
         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();
         }
     }
 
+    // Compressed texture support
+
+    // Check for ETC1
+    bool hasCompressTex2D = (kGL_GrGLStandard != standard || version > GR_GL_VER(1, 3));
+

[robertphillips, 2014/05/29 12:53:18]

Shouldn't this comment go above the prior line of code?

[krajcevski, 2014/05/29 14:28:22]

Done.

+    // glCompressedTexImage2D is available on all OpenGL ES devices...
+    // however, it is only available on standard OpenGL after version 1.3

[robertphillips, 2014/05/29 12:53:18]

I think setting this to false and just using 'hasCompressTex2D' in the following
logic might be clearer. What do you think?

[krajcevski, 2014/05/29 14:28:22]

I agree. This is left over from when I was reordering the checks.

+    bool hasETC1 = hasCompressTex2D;
+
+    // First check version for support
+    if (kGL_GrGLStandard == standard) {
+        hasETC1 = hasETC1 && (version >= GR_GL_VER(4, 3) || 
+                              ctxInfo.hasExtension("GL_ARB_ES3_compatibility"));
+    } else {
+        hasETC1 = hasETC1 &&
+            (version >= GR_GL_VER(3, 0) ||
+             ctxInfo.hasExtension("GL_OES_compressed_ETC1_RGB8_texture") ||
+             // ETC2 is a superset of ETC1, so we can just check for that, too.
+             (ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGB8_texture") &&
+              ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGBA8_texture")));
+    }
+    fConfigRenderSupport[kETC1_GrPixelConfig][kYes_MSAA] = hasETC1;
+    fConfigRenderSupport[kETC1_GrPixelConfig][kNo_MSAA] = hasETC1;
+
+    // Check for LATC under its various forms
+    LATCAlias alias = kLATC_LATCAlias;
+    bool hasLATC = hasCompressTex2D && (ctxInfo.hasExtension("GL_EXT_texture_compression_latc") ||
+                                        ctxInfo.hasExtension("GL_NV_texture_compression_latc"));
+
+    // Check for RGTC
+    if (!hasLATC) {
+        // If we're using OpenGL 3.0 or later, then we have RGTC, an identical compression format.
+        if (kGL_GrGLStandard == standard) {
+            hasLATC = version >= GR_GL_VER(3, 0);
+        }
+
+        if (!hasLATC) {
+            hasLATC =
+                ctxInfo.hasExtension("GL_EXT_texture_compression_rgtc") ||
+                ctxInfo.hasExtension("GL_ARB_texture_compression_rgtc");
+        }
+
+        if (hasLATC) {
+            alias = kRGTC_LATCAlias;
+        }
+    }
+
+    // Check for 3DC
+    if (!hasLATC) {
+        hasLATC = ctxInfo.hasExtension("GL_AMD_compressed_3DC_texture");
+        if (hasLATC) {
+            alias = k3DC_LATCAlias;
+        }
+    }
+
+    fConfigRenderSupport[kLATC_GrPixelConfig][kYes_MSAA] = hasLATC;
+    fConfigRenderSupport[kLATC_GrPixelConfig][kNo_MSAA] = hasLATC;
+    fLATCAlias = alias;
+
     // 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::initCompressedTextureSupport(const GrGLContextInfo &ctxInfo) {
-    GrGLStandard standard = ctxInfo.standard();
-    GrGLVersion version = ctxInfo.version();
-
-    // glCompressedTexImage2D is available on all OpenGL ES devices...
-    // however, it is only available on standard OpenGL after version 1.3
-    if (kGL_GrGLStandard == standard && version < GR_GL_VER(1, 3)) {
-        return;
-    }
-
-    // Check for ETC1
-    bool hasETC1 = false;
-
-    // First check version for support
-    if (kGL_GrGLStandard == standard) {
-        hasETC1 =
-            version >= GR_GL_VER(4, 3) ||
-            ctxInfo.hasExtension("GL_ARB_ES3_compatibility");
-    } else {
-        hasETC1 =
-            version >= GR_GL_VER(3, 0) ||
-            ctxInfo.hasExtension("GL_OES_compressed_ETC1_RGB8_texture") ||
-            // ETC2 is a superset of ETC1, so we can just check for that, too.
-            (ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGB8_texture") &&
-             ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGBA8_texture"));
-    }
-    fCompressedFormatSupport[kETC1_GrCompressedFormat] = hasETC1;
-
-    fCompressedFormatSupport[kETC2_GrCompressedFormat] = false;
-    fCompressedFormatSupport[kDXT1_GrCompressedFormat] = false;
-}
-
 bool GrGLCaps::readPixelsSupported(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;
     }
 
     if (!fTwoFormatLimit) {
         // not limited by ES 2's constraints
@@ skipping 238 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;
 }