Make mixed samples contingent on auxiliary extensions

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 26 matching lines @@
     fPackRowLengthSupport = false;
     fPackFlipYSupport = false;
     fTextureUsageSupport = false;
     fTexStorageSupport = false;
     fTextureRedSupport = false;
     fImagingSupport = false;
     fTwoFormatLimit = false;
     fFragCoordsConventionSupport = false;
     fVertexArrayObjectSupport = false;
     fES2CompatibilitySupport = false;
+    fMultisampleDisableSupport = false;
     fUseNonVBOVertexAndIndexDynamicData = false;
     fIsCoreProfile = false;
     fFullClearIsFree = false;
-    fFBMixedSamplesSupport = false;
 
     fReadPixelsSupportedCache.reset();
 
     fShaderCaps.reset(SkNEW(GrGLSLCaps));
 
 }
 
 GrGLCaps::GrGLCaps(const GrGLCaps& caps) : GrCaps() {
     *this = caps;
 }
@@ skipping 18 matching lines @@
     fPackRowLengthSupport = caps.fPackRowLengthSupport;
     fPackFlipYSupport = caps.fPackFlipYSupport;
     fTextureUsageSupport = caps.fTextureUsageSupport;
     fTexStorageSupport = caps.fTexStorageSupport;
     fTextureRedSupport = caps.fTextureRedSupport;
     fImagingSupport = caps.fImagingSupport;
     fTwoFormatLimit = caps.fTwoFormatLimit;
     fFragCoordsConventionSupport = caps.fFragCoordsConventionSupport;
     fVertexArrayObjectSupport = caps.fVertexArrayObjectSupport;
     fES2CompatibilitySupport = caps.fES2CompatibilitySupport;
+    fMultisampleDisableSupport = caps.fMultisampleDisableSupport;
     fUseNonVBOVertexAndIndexDynamicData = caps.fUseNonVBOVertexAndIndexDynamicData;
     fIsCoreProfile = caps.fIsCoreProfile;
     fFullClearIsFree = caps.fFullClearIsFree;
-    fFBMixedSamplesSupport = caps.fFBMixedSamplesSupport;
 
     *(reinterpret_cast<GrGLSLCaps*>(fShaderCaps.get())) = 
                                           *(reinterpret_cast<GrGLSLCaps*>(caps.fShaderCaps.get()));
 
     return *this;
 }
 
 bool GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
 
     this->reset();
@@ skipping 142 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) {
+        fMultisampleDisableSupport = true;
+    } else {
+        fMultisampleDisableSupport = false;

[Chris Dalton, 2015/05/21 03:28:52]

This will eventually be replaced with a check for the ES extension.

+    }
+
     this->initFSAASupport(ctxInfo, gli);
     this->initStencilFormats(ctxInfo);
 
     /**************************************************************************
      * GrCaps fields
      **************************************************************************/
     if (kGL_GrGLStandard == standard) {
         // 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).
@@ skipping 64 matching lines @@
         // to alllow arbitrary wrap modes, however.
         fMipMapSupport = fNPOTTextureTileSupport || ctxInfo.hasExtension("GL_IMG_texture_npot");
     }
 
     GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureSize);
     GR_GL_GetIntegerv(gli, GR_GL_MAX_RENDERBUFFER_SIZE, &fMaxRenderTargetSize);
     // Our render targets are always created with textures as the color
     // attachment, hence this min:
     fMaxRenderTargetSize = SkTMin(fMaxTextureSize, fMaxRenderTargetSize);
 
-    fFBMixedSamplesSupport = ctxInfo.hasExtension("GL_NV_framebuffer_mixed_samples");
-
     fGpuTracingSupport = ctxInfo.hasExtension("GL_EXT_debug_marker");
 
     // Disable scratch texture reuse on Mali and Adreno devices
     fReuseScratchTextures = kARM_GrGLVendor != ctxInfo.vendor() &&
                             kQualcomm_GrGLVendor != ctxInfo.vendor();
 
     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);
@@ skipping 557 matching lines @@
     r.appendf("Pack Flip Y support: %s\n", (fPackFlipYSupport ? "YES": "NO"));
 
     r.appendf("Texture Usage support: %s\n", (fTextureUsageSupport ? "YES": "NO"));
     r.appendf("Texture Storage support: %s\n", (fTexStorageSupport ? "YES": "NO"));
     r.appendf("GL_R support: %s\n", (fTextureRedSupport ? "YES": "NO"));
     r.appendf("GL_ARB_imaging support: %s\n", (fImagingSupport ? "YES": "NO"));
     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("Multisample disable support: %s\n", (fMultisampleDisableSupport ? "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"));
     return r;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 
 GrGLSLCaps::GrGLSLCaps() {
     this->reset();
@@ skipping 99 matching lines @@
         fShaderDerivativeSupport = true;
         // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS
         fGeometryShaderSupport = ctxInfo.version() >= GR_GL_VER(3, 2) &&
             ctxInfo.glslGeneration() >= k150_GrGLSLGeneration;
     }
     else {
         fShaderDerivativeSupport = ctxInfo.version() >= GR_GL_VER(3, 0) ||
             ctxInfo.hasExtension("GL_OES_standard_derivatives");
     }
 
+    // We need dual source blending and the ability to disable multisample in order to support mixed
+    // samples in every corner case.
+    if (fDualSourceBlendingSupport && glCaps.multisampleDisableSupport()) {
+        // We understand "mixed samples" to mean the collective capability of 3 different extensions
+        fMixedSamplesSupport = ctxInfo.hasExtension("GL_NV_framebuffer_mixed_samples") &&
+                               ctxInfo.hasExtension("GL_NV_sample_mask_override_coverage") &&
+                               ctxInfo.hasExtension("GL_EXT_raster_multisample");
+    }
+
     if (glCaps.advancedBlendEquationSupport()) {
         bool coherent = glCaps.advancedCoherentBlendEquationSupport();
         if (ctxInfo.hasExtension(coherent ? "GL_NV_blend_equation_advanced_coherent"
                                           : "GL_NV_blend_equation_advanced")) {
             fAdvBlendEqInteraction = kAutomatic_AdvBlendEqInteraction;
         } else {
             fAdvBlendEqInteraction = kGeneralEnable_AdvBlendEqInteraction;
             // TODO: Use the following on any platform where "blend_support_all_equations" is slow.
             //fAdvBlendEqInteraction = kSpecificEnables_AdvBlendEqInteraction;
         }
@@ skipping 105 matching lines @@
     if (fGeometryShaderSupport) {
         for (int p = 0; p < kGrSLPrecisionCount; ++p) {
             fFloatPrecisions[kGeometry_GrShaderType][p] = fFloatPrecisions[kVertex_GrShaderType][p];
         }
     }
 }