Implement support for KHR_blend_equation_advanced

src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrGLFragmentShaderBuilder.h"
 #include "GrGLProgramBuilder.h"
 #include "../GrGLGpu.h"
@@ skipping 165 matching lines @@
             this->enableCustomOutput();
             fOutputs[fCustomColorOutputIndex].setTypeModifier(GrShaderVar::kInOut_TypeModifier);
             fbFetchColorName = declared_color_output_name();
         }
         return fbFetchColorName;
     } else {
         return kDstCopyColorName;
     } 
 }
 
+void GrGLFragmentShaderBuilder::enableAdvancedBlendEquation(GrBlendEquation advancedEquation) {
+    SkASSERT(fProgramBuilder->gpu()->glCaps().glslCaps()->mustEnableAdvancedBlendEquations());
+    SkASSERT(GrBlendEquationIsAdvanced(advancedEquation));
+
+    static const char* layoutQualifierNames[] = {
+        "blend_support_screen",
+        "blend_support_overlay",
+        "blend_support_darken",
+        "blend_support_lighten",
+        "blend_support_colordodge",
+        "blend_support_colorburn",
+        "blend_support_hardlight",
+        "blend_support_softlight",
+        "blend_support_difference",
+        "blend_support_exclusion",
+        "blend_support_multiply",
+        "blend_support_hsl_hue",
+        "blend_support_hsl_saturation",
+        "blend_support_hsl_color",
+        "blend_support_hsl_luminosity"
+    };
+    this->addFeature(1 << kBlendEquationAdvanced_GLSLPrivateFeature,
+                     "GL_KHR_blend_equation_advanced");
+    this->addLayoutQualifier(layoutQualifierNames[advancedEquation - kFirstAdvancedGrBlendEquation],

[egdaniel, 2015/05/04 19:51:21]

so this doesn't ever set to blend_support_all. I would have thought in most
cases blend_support_all might be faster since we can reuse programs (but it may
also add a bunch of slow conditionals to shader). I would say that we have a
caps for use all or use specific, and then check that here and do the
appropriate thing. My guess would be to default to "all" just to avoid compiles
of programs, but I don't have the greatest insight into which is better.

[Chris Dalton, 2015/05/04 20:33:12]

Yeah I don't have much insight either, outside the NVIDA driver.

My thoughts might be to default to using unique qualifiers per equation though,
for a few reasons: 
* The spec took the effort to create them
* Shader compilation is a one-time cost
* An app out in the wild seems unlikely to recompile many of the same shaders
for different blend equations
* There is a potential per-pixel cost associated with using blend_support_all

We already have the 'mustEnableAdvancedBlendEquations()' cap that will do the
right thing on NVIDIA and avoid redundant compiles. I can add another cap for
blend_support_all, but it won't get used yet since Intel is blacklisted and
they're the only other vendor to currently support this extension. Do we still
want to make one? Do you want me to default it to "yes, use blend_support_all",
or "no"?

[egdaniel, 2015/05/04 21:04:51]

Okay let's keep it as is and we'll just have a TODO on our end to test out other
devices. I think some of the new Adreno 400s suppport the KHR version.

[Chris Dalton, 2015/05/05 18:57:58]

I actually went ahead and handled blend_support_all_equations after all :)

+                             kOut_InterfaceQualifier);
+
+    GR_STATIC_ASSERT(0 == kScreen_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(1 == kOverlay_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(2 == kDarken_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(3 == kLighten_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(4 == kColorDodge_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(5 == kColorBurn_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(6 == kHardLight_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(7 == kSoftLight_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(8 == kDifference_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(9 == kExclusion_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(10 == kMultiply_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(11 == kHSLHue_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(12 == kHSLSaturation_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(13 == kHSLColor_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(14 == kHSLLuminosity_GrBlendEquation - kFirstAdvancedGrBlendEquation);
+    GR_STATIC_ASSERT(SK_ARRAY_COUNT(layoutQualifierNames) ==
+                     kTotalGrBlendEquationCount - kFirstAdvancedGrBlendEquation);
+}
+
 void GrGLFragmentShaderBuilder::enableCustomOutput() {
     if (!fHasCustomColorOutput) {
         fHasCustomColorOutput = true;
         fCustomColorOutputIndex = fOutputs.count();
         fOutputs.push_back().set(kVec4f_GrSLType,
                                  GrGLShaderVar::kOut_TypeModifier,
                                  declared_color_output_name());
     }
 }
 
@@ skipping 40 matching lines @@
     }
 }
 
 void GrGLFragmentShaderBuilder::addVarying(GrGLVarying* v, GrSLPrecision fsPrec) {
     v->fFsIn = v->fVsOut;
     if (v->fGsOut) {
         v->fFsIn = v->fGsOut;
     }
     fInputs.push_back().set(v->fType, GrGLShaderVar::kVaryingIn_TypeModifier, v->fFsIn, fsPrec);
 }