Implement mix-blend-mode in GL renderer using shaders.

cc/output/shader.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/output/shader.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "cc/output/gl_renderer.h"  // For the GLC() macro.
 #include "gpu/command_buffer/client/gles2_interface.h"
 
 #define SHADER0(Src) #Src
 #define VERTEX_SHADER(Src) SetVertexTexCoordPrecision(SHADER0(Src))
-#define FRAGMENT_SHADER(Src) SetFragmentTexCoordPrecision( \
-    precision, SetFragmentSamplerType(sampler, SHADER0(Src)))
+#define FRAGMENT_SHADER(Src)    \
+  SetFragmentTexCoordPrecision( \
+      precision,                \
+      SetFragmentSamplerType(sampler, SetBlendModeFunctions(SHADER0(Src))))
 
 using gpu::gles2::GLES2Interface;
 
 namespace cc {
 
 namespace {
 
 static void GetProgramUniformLocations(GLES2Interface* context,
                                        unsigned program,
                                        size_t count,
@@ skipping 591 matching lines @@
     uniform TexCoordPrecision mat4 texMatrix;
     varying TexCoordPrecision vec2 v_texCoord;
     void main() {
         gl_Position = matrix * a_position;
         v_texCoord =
             vec2(texMatrix * vec4(a_texCoord.x, 1.0 - a_texCoord.y, 0.0, 1.0));
     }
   );  // NOLINT(whitespace/parens)
 }
 
+#define BLEND_MODE_UNIFORMS "s_backdropTexture", "backdropRect"
+#define UNUSED_BLEND_MODE_UNIFORMS (is_default_blend_mode() ? 2 : 0)

[enne (OOO), 2014/10/16 01:41:25]

This doesn't need to be a macro, I think.

[rosca, 2014/10/16 16:14:56]

It looks weird to see this expression inline. It is tied to what is in
BLEND_MODE_UNIFORMS. Other options would be either to move all of them inline,
or to add a BLEND_MODE_UNIFORMS_COUNT and move UNUSED_BLEND_MODE_UNIFORMS and
BLEND_MODE_SET_LOCATIONS as methods in FragmentTexBlendMode. Wdyt?

+#define BLEND_MODE_SET_LOCATIONS(X, POS)                   \
+  if (!is_default_blend_mode()) {                          \
+    DCHECK_LT(static_cast<size_t>(POS) + 1, arraysize(X)); \
+    backdrop_location_ = locations[POS];                   \
+    backdrop_rect_location_ = locations[POS + 1];          \
+  }
+
+FragmentTexBlendMode::FragmentTexBlendMode()
+    : backdrop_location_(-1),
+      backdrop_rect_location_(-1),
+      blend_mode_(SkXfermode::kSrcOver_Mode) {
+}
+
+bool FragmentTexBlendMode::is_blend_mode_supported(
+    SkXfermode::Mode blend_mode) {
+  return blend_mode == kDefaultBlendMode ||
+         (blend_mode >= kFirstBlendMode && blend_mode <= kLastBlendMode &&
+          blend_mode != SkXfermode::kScreen_Mode);
+}
+
+void FragmentTexBlendMode::SetBlendMode(SkXfermode::Mode blend_mode) {
+  DCHECK(is_blend_mode_supported(blend_mode));
+  if (!is_blend_mode_supported(blend_mode))
+    blend_mode_ = kDefaultBlendMode;
+  else
+    blend_mode_ = blend_mode;
+}
+
+std::string FragmentTexBlendMode::SetBlendModeFunctions(
+    std::string shader_string) const {
+  DCHECK(is_blend_mode_supported(blend_mode_));
+  if (shader_string.find("ApplyBlendMode") == std::string::npos)
+    return shader_string;
+
+  if (is_default_blend_mode()) {
+    return
+        "#define ApplyBlendMode(X) (X)\n" +
+        shader_string;
+  }
+
+  return SHADER0(precision mediump float;)

[enne (OOO), 2014/10/16 01:41:25]

SHADER0 was intended as a way to make a big block of shader code look more
legible.  I don't know that it makes things better as a one-liner.  Maybe break
up each of these things into separate strings (maybe using Shader0 for the
larger chunk) and then put them together?

[rosca, 2014/10/16 16:14:56]

I replaced SHADER0 with quotes for one liners. Do you want me to remove it from
other places as well? The other occurrences look helpful to me. Maybe we can
make git cl format to be aware of this macro and skip fixing indentation.

[rosca, 2014/10/17 13:55:54]

I removed SHADER0 from small blocks of shader code and run cl format on big
blocks.

+      + GetHelperFunctions() +
+      SHADER0(
+      uniform SamplerType s_backdropTexture;
+      uniform TexCoordPrecision vec4 backdropRect;
+
+      vec4 GetBackdropColor() {
+        TexCoordPrecision vec2 bgTexCoord =
+            gl_FragCoord.xy - backdropRect.xy;
+        bgTexCoord.x /= backdropRect.z;
+        bgTexCoord.y /= backdropRect.w;
+        return TextureLookup(s_backdropTexture, bgTexCoord);
+      }
+
+      vec4 ApplyBlendMode(vec4 src) {
+        vec4 dst = GetBackdropColor();
+        vec4 result;
+        result.a = src.a + (1.0 - src.a) * dst.a;)
+
+        + GetMainBlendingCode() + SHADER0(
+        return result;
+      })
+      + shader_string;
+}
+
+std::string FragmentTexBlendMode::GetHelperFunctions() const {
+  static const std::string kFunctionHardLight = SHADER0(
+      vec3 hardLight(vec4 src, vec4 dst) {
+        vec3 result;
+        result.r = (2.0 * src.r <= src.a)
+                    ? (2.0 * src.r * dst.r)
+                    : (src.a * dst.a - 2.0 * (dst.a - dst.r) * (src.a - src.r));
+        result.g = (2.0 * src.g <= src.a)
+                    ? (2.0 * src.g * dst.g)
+                    : (src.a * dst.a - 2.0 * (dst.a - dst.g) * (src.a - src.g));
+        result.b = (2.0 * src.b <= src.a)
+                    ? (2.0 * src.b * dst.b)
+                    : (src.a * dst.a - 2.0 * (dst.a - dst.b) * (src.a - src.b));
+        result.rgb += src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a);
+        return result;
+      }
+  );
+
+  static const std::string kFunctionColorDodgeComponent = SHADER0(
+      float getColorDodgeComponent(float srcc, float srca,
+                                   float dstc, float dsta) {
+        if (0.0 == dstc)
+          return srcc * (1.0 - dsta);
+        float d = srca - srcc;
+        if (0.0 == d)
+          return srca * dsta + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
+        d = min(dsta, dstc * srca / d);
+        return d * srca + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
+      }
+  );
+
+  static const std::string kFunctionColorBurnComponent = SHADER0(
+      float getColorBurnComponent(float srcc, float srca,
+                                  float dstc, float dsta) {
+        if (dsta == dstc)
+          return srca * dsta + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
+        if (0.0 == srcc)
+          return dstc * (1.0 - srca);
+        float d = max(0.0, dsta - (dsta - dstc) * srca / srcc);
+        return srca * d + srcc * (1.0 - dsta) + dstc * (1.0 - srca);
+      }
+  );
+
+  static const std::string kFunctionSoftLightComponentPosDstAlpha = SHADER0(
+      float getSoftLightComponent(float srcc, float srca,
+                                  float dstc, float dsta) {
+        if (2.0 * srcc <= srca) {
+          return (dstc * dstc * (srca - 2.0 * srcc)) / dsta +
+                  (1.0 - dsta) * srcc + dstc * (-srca + 2.0 * srcc + 1.0);
+        } else if (4.0 * dstc <= dsta) {
+          float DSqd = dstc * dstc;
+          float DCub = DSqd * dstc;
+          float DaSqd = dsta * dsta;
+          float DaCub = DaSqd * dsta;
+          return (-DaCub * srcc +
+                  DaSqd * (srcc - dstc * (3.0 * srca - 6.0 * srcc - 1.0)) +
+                  12.0 * dsta * DSqd * (srca - 2.0 * srcc) -
+                  16.0 * DCub * (srca - 2.0 * srcc)) /
+                  DaSqd;
+        } else {
+          return -sqrt(dsta * dstc) * (srca - 2.0 * srcc) - dsta * srcc +
+                  dstc * (srca - 2.0 * srcc + 1.0) + srcc;
+        }
+      }
+  );
+
+  static const std::string kFunctionLum = SHADER0(
+      float luminance(vec3 color) {
+        return dot(vec3(0.3, 0.59, 0.11), color);
+      }
+      vec3 set_luminance(vec3 hueSat, float alpha, vec3 lumColor) {
+        float diff = luminance(lumColor - hueSat);
+        vec3 outColor = hueSat + diff;
+        float outLum = luminance(outColor);
+        float minComp = min(min(outColor.r, outColor.g), outColor.b);
+        float maxComp = max(max(outColor.r, outColor.g), outColor.b);
+        if (minComp < 0.0) {
+          outColor = outLum +
+                     ((outColor - vec3(outLum, outLum, outLum)) * outLum) /
+                         (outLum - minComp);
+        }
+        if (maxComp > alpha) {
+          outColor =
+              outLum +
+              ((outColor - vec3(outLum, outLum, outLum)) * (alpha - outLum)) /
+                  (maxComp - outLum);
+        }
+        return outColor;
+      }
+  );
+
+  static const std::string kFunctionSat = SHADER0(
+      float saturation(vec3 color) {
+        return max(max(color.r, color.g), color.b) -
+               min(min(color.r, color.g), color.b);
+      }
+      vec3 set_saturation_helper(float minComp,
+                                 float midComp,
+                                 float maxComp,
+                                 float sat) {
+        if (minComp < maxComp) {
+          vec3 result;
+          result.r = 0.0;
+          result.g = sat * (midComp - minComp) / (maxComp - minComp);
+          result.b = sat;
+          return result;
+        } else {
+          return vec3(0, 0, 0);
+        }
+      }
+      vec3 set_saturation(vec3 hueLumColor, vec3 satColor) {
+        float sat = saturation(satColor);
+        if (hueLumColor.r <= hueLumColor.g) {
+          if (hueLumColor.g <= hueLumColor.b) {
+            hueLumColor.rgb = set_saturation_helper(
+                hueLumColor.r, hueLumColor.g, hueLumColor.b, sat);
+          } else if (hueLumColor.r <= hueLumColor.b) {
+            hueLumColor.rbg = set_saturation_helper(
+                hueLumColor.r, hueLumColor.b, hueLumColor.g, sat);
+          } else {
+            hueLumColor.brg = set_saturation_helper(
+                hueLumColor.b, hueLumColor.r, hueLumColor.g, sat);
+          }
+        } else if (hueLumColor.r <= hueLumColor.b) {
+          hueLumColor.grb = set_saturation_helper(
+              hueLumColor.g, hueLumColor.r, hueLumColor.b, sat);
+        } else if (hueLumColor.g <= hueLumColor.b) {
+          hueLumColor.gbr = set_saturation_helper(
+              hueLumColor.g, hueLumColor.b, hueLumColor.r, sat);
+        } else {
+          hueLumColor.bgr = set_saturation_helper(
+              hueLumColor.b, hueLumColor.g, hueLumColor.r, sat);
+        }
+        return hueLumColor;
+      }
+  );
+
+  switch (blend_mode_) {
+    case SkXfermode::kOverlay_Mode:
+    case SkXfermode::kHardLight_Mode:
+      return kFunctionHardLight;
+    case SkXfermode::kColorDodge_Mode:
+      return kFunctionColorDodgeComponent;
+    case SkXfermode::kColorBurn_Mode:
+      return kFunctionColorBurnComponent;
+    case SkXfermode::kSoftLight_Mode:
+      return kFunctionSoftLightComponentPosDstAlpha;
+    case SkXfermode::kHue_Mode:
+    case SkXfermode::kSaturation_Mode:
+      return kFunctionLum + kFunctionSat;
+    case SkXfermode::kColor_Mode:
+    case SkXfermode::kLuminosity_Mode:
+      return kFunctionLum;
+    default:
+      return std::string();
+  }
+}
+
+std::string FragmentTexBlendMode::GetMainBlendingCode() const {
+  switch (blend_mode_) {
+    case SkXfermode::kLighten_Mode:
+      return SHADER0(
+          result.rgb = max((1.0 - src.a) * dst.rgb + src.rgb,
+                           (1.0 - dst.a) * src.rgb + dst.rgb);
+          );
+    case SkXfermode::kOverlay_Mode:
+      return SHADER0(
+          result.rgb = hardLight(dst, src);
+          );
+    case SkXfermode::kDarken_Mode:
+      return SHADER0(
+          result.rgb = min((1.0 - src.a) * dst.rgb + src.rgb,
+                           (1.0 - dst.a) * src.rgb + dst.rgb);
+          );
+    case SkXfermode::kColorDodge_Mode:
+      return SHADER0(
+          result.r = getColorDodgeComponent(src.r, src.a, dst.r, dst.a);
+          result.g = getColorDodgeComponent(src.g, src.a, dst.g, dst.a);
+          result.b = getColorDodgeComponent(src.b, src.a, dst.b, dst.a);
+          );
+    case SkXfermode::kColorBurn_Mode:
+      return SHADER0(
+          result.r = getColorBurnComponent(src.r, src.a, dst.r, dst.a);
+          result.g = getColorBurnComponent(src.g, src.a, dst.g, dst.a);
+          result.b = getColorBurnComponent(src.b, src.a, dst.b, dst.a);
+          );
+    case SkXfermode::kHardLight_Mode:
+      return SHADER0(
+          result.rgb = hardLight(src, dst);
+          );
+    case SkXfermode::kSoftLight_Mode:
+      return SHADER0(
+          if (0.0 == dst.a) {
+            result.rgba = src;
+          } else {
+            result.r = getSoftLightComponent(src.r, src.a, dst.r, dst.a);
+            result.g = getSoftLightComponent(src.g, src.a, dst.g, dst.a);
+            result.b = getSoftLightComponent(src.b, src.a, dst.b, dst.a);
+          }
+          );
+    case SkXfermode::kDifference_Mode:
+      return SHADER0(
+          result.rgb = src.rgb + dst.rgb -
+              2.0 * min(src.rgb * dst.a, dst.rgb * src.a);
+          );
+    case SkXfermode::kExclusion_Mode:
+      return SHADER0(
+          result.rgb = dst.rgb + src.rgb - 2.0 * dst.rgb * src.rgb;
+          );
+    case SkXfermode::kMultiply_Mode:
+      return SHADER0(
+          result.rgb = (1.0 - src.a) * dst.rgb +
+              (1.0 - dst.a) * src.rgb + src.rgb * dst.rgb;
+          );
+    case SkXfermode::kHue_Mode:
+      return SHADER0(
+          vec4 dstSrcAlpha = dst * src.a;
+          result.rgb =
+              set_luminance(set_saturation(src.rgb * dst.a, dstSrcAlpha.rgb),
+                            dstSrcAlpha.a,
+                            dstSrcAlpha.rgb);
+
+          result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;
+          );
+    case SkXfermode::kSaturation_Mode:
+      return SHADER0(
+          vec4 dstSrcAlpha = dst * src.a;
+          result.rgb =
+              set_luminance(set_saturation(dstSrcAlpha.rgb, src.rgb * dst.a),
+                            dstSrcAlpha.a,
+                            dstSrcAlpha.rgb);
+          result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;
+          );
+    case SkXfermode::kColor_Mode:
+      return SHADER0(
+          vec4 srcDstAlpha = src * dst.a;
+          result.rgb =
+              set_luminance(srcDstAlpha.rgb, srcDstAlpha.a, dst.rgb * src.a);
+          result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;
+          );
+    case SkXfermode::kLuminosity_Mode:
+      return SHADER0(
+          vec4 srcDstAlpha = src * dst.a;
+          result.rgb =
+              set_luminance(dst.rgb * src.a, srcDstAlpha.a, srcDstAlpha.rgb);
+          result.rgb += (1.0 - src.a) * dst.rgb + (1.0 - dst.a) * src.rgb;
+          );
+    default:
+      NOTREACHED();
+  }
+
+  return SHADER0(
+      result = src;
+      );
+}
+
 FragmentTexAlphaBinding::FragmentTexAlphaBinding()
     : sampler_location_(-1),
       alpha_location_(-1) {}
 
 void FragmentTexAlphaBinding::Init(GLES2Interface* context,
                                    unsigned program,
                                    int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
+    BLEND_MODE_UNIFORMS,
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
+  BLEND_MODE_SET_LOCATIONS(locations, 2);
 }
 
 FragmentTexColorMatrixAlphaBinding::FragmentTexColorMatrixAlphaBinding()
     : sampler_location_(-1),
       alpha_location_(-1),
       color_matrix_location_(-1),
       color_offset_location_(-1) {}
 
 void FragmentTexColorMatrixAlphaBinding::Init(GLES2Interface* context,
                                               unsigned program,
                                               int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
     "colorMatrix",
     "colorOffset",
+    BLEND_MODE_UNIFORMS,
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   color_matrix_location_ = locations[2];
   color_offset_location_ = locations[3];
+  BLEND_MODE_SET_LOCATIONS(locations, 4);
 }
 
 FragmentTexOpaqueBinding::FragmentTexOpaqueBinding()
     : sampler_location_(-1) {}
 
 void FragmentTexOpaqueBinding::Init(GLES2Interface* context,
                                     unsigned program,
                                     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
@@ skipping 11 matching lines @@
 
 std::string FragmentShaderRGBATexAlpha::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform float alpha;
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
-      gl_FragColor = texColor * alpha;
+      gl_FragColor = ApplyBlendMode(texColor * alpha);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform float alpha;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
-      gl_FragColor = texColor * alpha;
+      gl_FragColor = ApplyBlendMode(texColor * alpha);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexVaryingAlpha::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
@@ skipping 137 matching lines @@
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
     : sampler_location_(-1),
       alpha_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaAA::Init(GLES2Interface* context,
                                         unsigned program,
                                         int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
+    BLEND_MODE_UNIFORMS,
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
+  BLEND_MODE_SET_LOCATIONS(locations, 2);
 }
 
 std::string FragmentShaderRGBATexAlphaAA::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform SamplerType s_texture;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
-      gl_FragColor = texColor * alpha * aa;
+      gl_FragColor = ApplyBlendMode(texColor * alpha * aa);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentTexClampAlphaAABinding::FragmentTexClampAlphaAABinding()
     : sampler_location_(-1),
       alpha_location_(-1),
       fragment_tex_transform_location_(-1) {}
 
 void FragmentTexClampAlphaAABinding::Init(GLES2Interface* context,
@@ skipping 72 matching lines @@
 
 void FragmentShaderRGBATexAlphaMask::Init(GLES2Interface* context,
                                           unsigned program,
                                           int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
+    BLEND_MODE_UNIFORMS,
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
+  BLEND_MODE_SET_LOCATIONS(locations, 5);
 }
 
 std::string FragmentShaderRGBATexAlphaMask::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform SamplerType s_mask;
     uniform TexCoordPrecision vec2 maskTexCoordScale;
     uniform TexCoordPrecision vec2 maskTexCoordOffset;
     uniform float alpha;
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
-      gl_FragColor = texColor * alpha * maskColor.w;
+      gl_FragColor = ApplyBlendMode(texColor * alpha * maskColor.w);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMaskAA::FragmentShaderRGBATexAlphaMaskAA()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1),
       mask_tex_coord_offset_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaMaskAA::Init(GLES2Interface* context,
                                             unsigned program,
                                             int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
+    BLEND_MODE_UNIFORMS,
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
+  BLEND_MODE_SET_LOCATIONS(locations, 5);
 }
 
 std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform SamplerType s_texture;
     uniform SamplerType s_mask;
     uniform TexCoordPrecision vec2 maskTexCoordScale;
     uniform TexCoordPrecision vec2 maskTexCoordOffset;
     uniform float alpha;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
-      gl_FragColor = texColor * alpha * maskColor.w * aa;
+      gl_FragColor = ApplyBlendMode(texColor * alpha * maskColor.w * aa);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMaskColorMatrixAA::
     FragmentShaderRGBATexAlphaMaskColorMatrixAA()
         : sampler_location_(-1),
           mask_sampler_location_(-1),
           alpha_location_(-1),
           mask_tex_coord_scale_location_(-1),
           color_matrix_location_(-1),
           color_offset_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaMaskColorMatrixAA::Init(
     GLES2Interface* context,
     unsigned program,
     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
     "colorMatrix",
     "colorOffset",
+    BLEND_MODE_UNIFORMS,
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
+  BLEND_MODE_SET_LOCATIONS(locations, 7);
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform SamplerType s_texture;
     uniform SamplerType s_mask;
     uniform vec2 maskTexCoordScale;
     uniform vec2 maskTexCoordOffset;
@@ skipping 10 matching lines @@
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
-      gl_FragColor = texColor * alpha * maskColor.w * aa;
+      gl_FragColor = ApplyBlendMode(texColor * alpha * maskColor.w * aa);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaColorMatrixAA::
     FragmentShaderRGBATexAlphaColorMatrixAA()
         : sampler_location_(-1),
           alpha_location_(-1),
           color_matrix_location_(-1),
           color_offset_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaColorMatrixAA::Init(
       GLES2Interface* context,
       unsigned program,
       int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "alpha",
     "colorMatrix",
     "colorOffset",
+    BLEND_MODE_UNIFORMS,
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   alpha_location_ = locations[1];
   color_matrix_location_ = locations[2];
   color_offset_location_ = locations[3];
+  BLEND_MODE_SET_LOCATIONS(locations, 4);
 }
 
 std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     uniform SamplerType s_texture;
     uniform float alpha;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     varying TexCoordPrecision vec2 v_texCoord;
     varying TexCoordPrecision vec4 edge_dist[2];  // 8 edge distances.
 
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
       vec4 d4 = min(edge_dist[0], edge_dist[1]);
       vec2 d2 = min(d4.xz, d4.yw);
       float aa = clamp(gl_FragCoord.w * min(d2.x, d2.y), 0.0, 1.0);
-      gl_FragColor = texColor * alpha * aa;
+      gl_FragColor = ApplyBlendMode(texColor * alpha * aa);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderRGBATexAlphaMaskColorMatrix::
     FragmentShaderRGBATexAlphaMaskColorMatrix()
         : sampler_location_(-1),
           mask_sampler_location_(-1),
           alpha_location_(-1),
           mask_tex_coord_scale_location_(-1) {}
 
 void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(
     GLES2Interface* context,
     unsigned program,
     int* base_uniform_index) {
   static const char* uniforms[] = {
     "s_texture",
     "s_mask",
     "alpha",
     "maskTexCoordScale",
     "maskTexCoordOffset",
     "colorMatrix",
     "colorOffset",
+    BLEND_MODE_UNIFORMS,
   };
   int locations[arraysize(uniforms)];
 
   GetProgramUniformLocations(context,
                              program,
-                             arraysize(uniforms),
+                             arraysize(uniforms) - UNUSED_BLEND_MODE_UNIFORMS,
                              uniforms,
                              locations,
                              base_uniform_index);
   sampler_location_ = locations[0];
   mask_sampler_location_ = locations[1];
   alpha_location_ = locations[2];
   mask_tex_coord_scale_location_ = locations[3];
   mask_tex_coord_offset_location_ = locations[4];
   color_matrix_location_ = locations[5];
   color_offset_location_ = locations[6];
+  BLEND_MODE_SET_LOCATIONS(locations, 7);
 }
 
 std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString(
     TexCoordPrecision precision, SamplerType sampler) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform SamplerType s_mask;
     uniform vec2 maskTexCoordScale;
     uniform vec2 maskTexCoordOffset;
     uniform mat4 colorMatrix;
     uniform vec4 colorOffset;
     uniform float alpha;
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       float nonZeroAlpha = max(texColor.a, 0.00001);
       texColor = vec4(texColor.rgb / nonZeroAlpha, nonZeroAlpha);
       texColor = colorMatrix * texColor + colorOffset;
       texColor.rgb *= texColor.a;
       texColor = clamp(texColor, 0.0, 1.0);
       TexCoordPrecision vec2 maskTexCoord =
           vec2(maskTexCoordOffset.x + v_texCoord.x * maskTexCoordScale.x,
                maskTexCoordOffset.y + v_texCoord.y * maskTexCoordScale.y);
       vec4 maskColor = TextureLookup(s_mask, maskTexCoord);
-      gl_FragColor = texColor * alpha * maskColor.w;
+      gl_FragColor = ApplyBlendMode(texColor * alpha * maskColor.w);
     }
   );  // NOLINT(whitespace/parens)
 }
 
 FragmentShaderYUVVideo::FragmentShaderYUVVideo()
     : y_texture_location_(-1),
       u_texture_location_(-1),
       v_texture_location_(-1),
       alpha_location_(-1),
       yuv_matrix_location_(-1),
@@ skipping 226 matching lines @@
       vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * texTransform.zw + texTransform.xy;
       vec2 coord = mod(floor(texCoord * frequency * 2.0), 2.0);
       float picker = abs(coord.x - coord.y);  // NOLINT
       gl_FragColor = mix(color1, color2, picker) * alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 }  // namespace cc