Implement support for KHR_blend_equation_advanced

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 251 matching lines @@
         fTwoSidedStencilSupport = (ctxInfo.version() >= GR_GL_VER(2,0));
         // supported on GL 1.4 and higher or by extension
         fStencilWrapOpsSupport = (ctxInfo.version() >= GR_GL_VER(1,4)) ||
                                   ctxInfo.hasExtension("GL_EXT_stencil_wrap");
     } else {
         // ES 2 has two sided stencil and stencil wrap
         fTwoSidedStencilSupport = true;
         fStencilWrapOpsSupport = true;
     }
 
+    if (kIntel_GrGLVendor != ctxInfo.vendor()) {
+        if (ctxInfo.hasExtension("GL_KHR_blend_equation_advanced_coherent") ||
+            ctxInfo.hasExtension("GL_NV_blend_equation_advanced_coherent")) {
+            fBlendEquationSupport = kAdvancedCoherent_BlendEquationSupport;
+        } else if (ctxInfo.hasExtension("GL_KHR_blend_equation_advanced") ||
+                   ctxInfo.hasExtension("GL_NV_blend_equation_advanced")) {
+            fBlendEquationSupport = kAdvanced_BlendEquationSupport;
+        } else {
+            fBlendEquationSupport = kBasic_BlendEquationSupport;
+        }
+    } else {
+        // On Intel platforms, KHR_blend_equation_advanced is not conformant.
+        fBlendEquationSupport = kBasic_BlendEquationSupport;
+    }
+
     if (kGL_GrGLStandard == standard) {
         fMapBufferFlags = kCanMap_MapFlag; // we require VBO support and the desktop VBO
                                             // extension includes glMapBuffer.
         if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_map_buffer_range")) {
             fMapBufferFlags |= kSubset_MapFlag;
             fMapBufferType = kMapBufferRange_MapBufferType;
         } else {
             fMapBufferType = kMapBuffer_MapBufferType;
         }
     } else {
@@ skipping 63 matching lines @@
             SkASSERT(ctxInfo.hasExtension("GL_EXT_framebuffer_object"));
         }
     } else {
         // ES 3.0 supports mixed size FBO attachments, 2.0 does not.
         fOversizedStencilSupport = ctxInfo.version() >= GR_GL_VER(3, 0);
     }
 
     this->initConfigTexturableTable(ctxInfo, gli);
     this->initConfigRenderableTable(ctxInfo);
 
-    reinterpret_cast<GrGLSLCaps*>(fShaderCaps.get())->init(ctxInfo, gli);
+    reinterpret_cast<GrGLSLCaps*>(fShaderCaps.get())->init(ctxInfo, gli, *this);
 
     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 541 matching lines @@
     this->reset();
 }
 
 
 void GrGLSLCaps::reset() {
     INHERITED::reset();
 
     fDropsTileOnZeroDivide = false;
     fFBFetchSupport = false;
     fFBFetchNeedsCustomOutput = false;
+    fAdvBlendEqInteraction = kNotSupported_AdvBlendEqInteraction;
     fFBFetchColorName = NULL;
     fFBFetchExtensionString = NULL;
 }
 
 GrGLSLCaps::GrGLSLCaps(const GrGLSLCaps& caps) : GrShaderCaps() {
     *this = caps;
 }
 
 GrGLSLCaps& GrGLSLCaps::operator= (const GrGLSLCaps& caps) {
     INHERITED::operator=(caps);
     fDropsTileOnZeroDivide = caps.fDropsTileOnZeroDivide;
     fFBFetchSupport = caps.fFBFetchSupport;
     fFBFetchNeedsCustomOutput = caps.fFBFetchNeedsCustomOutput;
+    fAdvBlendEqInteraction = caps.fAdvBlendEqInteraction;
     fFBFetchColorName = caps.fFBFetchColorName;
     fFBFetchExtensionString = caps.fFBFetchExtensionString;
 
     return *this;
 }
 
-bool GrGLSLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
+bool GrGLSLCaps::init(const GrGLContextInfo& ctxInfo,
+                      const GrGLInterface* gli,
+                      const GrGLCaps& glCaps) {
     this->reset();
     if (!ctxInfo.isInitialized()) {
         return false;
     }
 
     GrGLStandard standard = ctxInfo.standard();
     GrGLVersion version = ctxInfo.version();
 
     /**************************************************************************
     * Caps specific to GrGLSLCaps
@@ skipping 56 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");
     }
 
+    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;
+        }
+    }
+
     this->initShaderPrecisionTable(ctxInfo, gli);
 
     return true;
 }
 
 SkString GrGLSLCaps::dump() const {
     SkString r = INHERITED::dump();
 
+    static const char* kAdvBlendEqInteractionStr[] = {
+        "Not Supported",
+        "Automatic",
+        "General Enable",
+        "Specific Enables",
+    };
+    GR_STATIC_ASSERT(0 == kNotSupported_AdvBlendEqInteraction);
+    GR_STATIC_ASSERT(1 == kAutomatic_AdvBlendEqInteraction);
+    GR_STATIC_ASSERT(2 == kGeneralEnable_AdvBlendEqInteraction);
+    GR_STATIC_ASSERT(3 == kSpecificEnables_AdvBlendEqInteraction);
+    GR_STATIC_ASSERT(SK_ARRAY_COUNT(kAdvBlendEqInteractionStr) == kLast_AdvBlendEqInteraction + 1);
+
     r.appendf("--- GLSL-Specific ---\n");
 
     r.appendf("FB Fetch Support: %s\n", (fFBFetchSupport ? "YES" : "NO"));
     r.appendf("Drops tile on zero divide: %s\n", (fDropsTileOnZeroDivide ? "YES" : "NO"));
+    r.appendf("Advanced blend equation interaction: %s\n",
+              kAdvBlendEqInteractionStr[fAdvBlendEqInteraction]);
     return r;
 }
 
 static GrGLenum precision_to_gl_float_type(GrSLPrecision p) {
     switch (p) {
     case kLow_GrSLPrecision:
         return GR_GL_LOW_FLOAT;
     case kMedium_GrSLPrecision:
         return GR_GL_MEDIUM_FLOAT;
     case kHigh_GrSLPrecision:
@@ skipping 67 matching lines @@
     if (fGeometryShaderSupport) {
         for (int p = 0; p < kGrSLPrecisionCount; ++p) {
             fFloatPrecisions[kGeometry_GrShaderType][p] = fFloatPrecisions[kVertex_GrShaderType][p];
         }
     }
 }