Implement support for mixed sampled render targets

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 219 matching lines @@
                                     ctxInfo.hasExtension("GL_OES_vertex_array_object");
     }
 
     if (kGL_GrGLStandard == standard) {
         fES2CompatibilitySupport = ctxInfo.hasExtension("GL_ARB_ES2_compatibility");
     }
     else {
         fES2CompatibilitySupport = true;
     }
 
-    if (kGL_GrGLStandard == standard) {
+    if (kGL_GrGLStandard == standard || fShaderCaps->mixedSamplesSupport()) {

[Chris Dalton, 2015/06/11 23:34:38]

This won't quite work. See below how mixed samples support isn't initialized
until after this line. (In fact, it checks fMultisampleDisableSupport when
deciding if we can use mixed samples :) My bad for suggesting we do it this way.

I think we should take out the mixedSamplesSupport check entirely. The reason
being, ES is already locked out from using mixed samples because it dosen't have
dual source blending. NVIDIA is actively working on extensions that allow both
disabling multisample and dual source blend on ES, so we can wait until those
specs are published.

In other words, leave this line as:

 if (kGL_GrGLStandard == standard) {

In the future, once the specs are finished, we can change the ES branch to:

 fMultisampleDisableSupport =
ctxInfo.hasExtension("GL_EXT_multisample_compatibility");

         fMultisampleDisableSupport = true;
     } else {
         fMultisampleDisableSupport = false;
     }
 
     /**************************************************************************
     * GrShaderCaps fields
     **************************************************************************/
 
     glslCaps->fPathRenderingSupport = ctxInfo.hasExtension("GL_NV_path_rendering");
@@ skipping 531 matching lines @@
 void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
 
     fMSFBOType = kNone_MSFBOType;
     if (kGL_GrGLStandard != ctxInfo.standard()) {
         // We prefer the EXT/IMG extension over ES3 MSAA because we've observed
         // ES3 driver bugs on at least one device with a tiled GPU (N10).
         if (ctxInfo.hasExtension("GL_EXT_multisampled_render_to_texture")) {
             fMSFBOType = kES_EXT_MsToTexture_MSFBOType;
         } else if (ctxInfo.hasExtension("GL_IMG_multisampled_render_to_texture")) {
             fMSFBOType = kES_IMG_MsToTexture_MSFBOType;
+        } else if (fShaderCaps->mixedSamplesSupport() && fShaderCaps->pathRenderingSupport()) {
+            fMSFBOType = kMixedSamples_MSFBOType;
         } else if (ctxInfo.version() >= GR_GL_VER(3,0)) {
             fMSFBOType = GrGLCaps::kES_3_0_MSFBOType;
         } else if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {
             // chrome's extension is equivalent to the EXT msaa
             // and fbo_blit extensions.
             fMSFBOType = kDesktop_EXT_MSFBOType;
         } else if (ctxInfo.hasExtension("GL_APPLE_framebuffer_multisample")) {
             fMSFBOType = kES_Apple_MSFBOType;
         }
     } else {
-        if ((ctxInfo.version() >= GR_GL_VER(3,0)) ||
+        if (fShaderCaps->mixedSamplesSupport() && fShaderCaps->pathRenderingSupport()) {
+            fMSFBOType = kMixedSamples_MSFBOType;
+        } else if ((ctxInfo.version() >= GR_GL_VER(3,0)) ||
             ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {
             fMSFBOType = GrGLCaps::kDesktop_ARB_MSFBOType;
         } else if (ctxInfo.hasExtension("GL_EXT_framebuffer_multisample") &&
                    ctxInfo.hasExtension("GL_EXT_framebuffer_blit")) {
             fMSFBOType = GrGLCaps::kDesktop_EXT_MSFBOType;
         }
     }
 }
 
 namespace {
@@ skipping 112 matching lines @@
     }
 
     static const char* kMSFBOExtStr[] = {
         "None",
         "ARB",
         "EXT",
         "ES 3.0",
         "Apple",
         "IMG MS To Texture",
         "EXT MS To Texture",
+        "MixedSamples",
     };
     GR_STATIC_ASSERT(0 == kNone_MSFBOType);
     GR_STATIC_ASSERT(1 == kDesktop_ARB_MSFBOType);
     GR_STATIC_ASSERT(2 == kDesktop_EXT_MSFBOType);
     GR_STATIC_ASSERT(3 == kES_3_0_MSFBOType);
     GR_STATIC_ASSERT(4 == kES_Apple_MSFBOType);
     GR_STATIC_ASSERT(5 == kES_IMG_MsToTexture_MSFBOType);
     GR_STATIC_ASSERT(6 == kES_EXT_MsToTexture_MSFBOType);
+    GR_STATIC_ASSERT(7 == kMixedSamples_MSFBOType);
     GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMSFBOExtStr) == kLast_MSFBOType + 1);
 
     static const char* kInvalidateFBTypeStr[] = {
         "None",
         "Discard",
         "Invalidate",
     };
     GR_STATIC_ASSERT(0 == kNone_InvalidateFBType);
     GR_STATIC_ASSERT(1 == kDiscard_InvalidateFBType);
     GR_STATIC_ASSERT(2 == kInvalidate_InvalidateFBType);
@@ skipping 156 matching lines @@
     if (fGeometryShaderSupport) {
         for (int p = 0; p < kGrSLPrecisionCount; ++p) {
             fFloatPrecisions[kGeometry_GrShaderType][p] = fFloatPrecisions[kVertex_GrShaderType][p];
         }
     }
 }