Implement support for KHR_blend_equation_advanced

src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp

Index: src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
diff --git a/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp b/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
index 51a0340ea98b145d145addc252e5131e8870ad4c..0785e409bd4142de6c56d91935305586cf81e0b2 100644
--- a/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLFragmentShaderBuilder.cpp
@@ -183,6 +183,51 @@ const char* GrGLFragmentShaderBuilder::dstColor() {
     } 
 }
 
+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;