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

cc/output/shader.cc

Index: cc/output/shader.cc
diff --git a/cc/output/shader.cc b/cc/output/shader.cc
index 72d89d23c0983ac7ddb3ec44acb0809984f3a80f..4e5acb27a7821671319da69f69d4d27a93791545 100644
--- a/cc/output/shader.cc
+++ b/cc/output/shader.cc
@@ -13,8 +13,10 @@
 
 #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;
 
@@ -626,6 +628,329 @@ std::string VertexShaderVideoTransform::GetShaderString() const {
   );  // NOLINT(whitespace/parens)
 }
 
+#define BLEND_MODE_UNIFORMS "s_backdropTexture", "backdropRect"
+#define UNUSED_BLEND_MODE_UNIFORMS (is_default_blend_mode() ? 2 : 0)
+#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;)
+      + 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) {}
@@ -636,17 +961,19 @@ void FragmentTexAlphaBinding::Init(GLES2Interface* context,
   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()
@@ -663,12 +990,13 @@ void FragmentTexColorMatrixAlphaBinding::Init(GLES2Interface* context,
     "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);
@@ -676,6 +1004,7 @@ void FragmentTexColorMatrixAlphaBinding::Init(GLES2Interface* context,
   alpha_location_ = locations[1];
   color_matrix_location_ = locations[2];
   color_offset_location_ = locations[3];
+  BLEND_MODE_SET_LOCATIONS(locations, 4);
 }
 
 FragmentTexOpaqueBinding::FragmentTexOpaqueBinding()
@@ -707,7 +1036,7 @@ std::string FragmentShaderRGBATexAlpha::GetShaderString(
     uniform float alpha;
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
-      gl_FragColor = texColor * alpha;
+      gl_FragColor = ApplyBlendMode(texColor * alpha);
     }
   );  // NOLINT(whitespace/parens)
 }
@@ -728,7 +1057,7 @@ std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderString(
       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)
 }
@@ -886,17 +1215,19 @@ void FragmentShaderRGBATexAlphaAA::Init(GLES2Interface* context,
   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(
@@ -913,7 +1244,7 @@ std::string FragmentShaderRGBATexAlphaAA::GetShaderString(
       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)
 }
@@ -1006,12 +1337,13 @@ void FragmentShaderRGBATexAlphaMask::Init(GLES2Interface* context,
     "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);
@@ -1020,6 +1352,7 @@ void FragmentShaderRGBATexAlphaMask::Init(GLES2Interface* context,
   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(
@@ -1038,7 +1371,7 @@ std::string FragmentShaderRGBATexAlphaMask::GetShaderString(
           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)
 }
@@ -1059,12 +1392,13 @@ void FragmentShaderRGBATexAlphaMaskAA::Init(GLES2Interface* context,
     "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);
@@ -1073,6 +1407,7 @@ void FragmentShaderRGBATexAlphaMaskAA::Init(GLES2Interface* context,
   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(
@@ -1096,7 +1431,7 @@ std::string FragmentShaderRGBATexAlphaMaskAA::GetShaderString(
       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)
 }
@@ -1122,12 +1457,13 @@ void FragmentShaderRGBATexAlphaMaskColorMatrixAA::Init(
     "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);
@@ -1138,6 +1474,7 @@ void FragmentShaderRGBATexAlphaMaskColorMatrixAA::Init(
   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(
@@ -1168,7 +1505,7 @@ std::string FragmentShaderRGBATexAlphaMaskColorMatrixAA::GetShaderString(
       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)
 }
@@ -1189,12 +1526,13 @@ void FragmentShaderRGBATexAlphaColorMatrixAA::Init(
     "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);
@@ -1202,6 +1540,7 @@ void FragmentShaderRGBATexAlphaColorMatrixAA::Init(
   alpha_location_ = locations[1];
   color_matrix_location_ = locations[2];
   color_offset_location_ = locations[3];
+  BLEND_MODE_SET_LOCATIONS(locations, 4);
 }
 
 std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString(
@@ -1225,7 +1564,7 @@ std::string FragmentShaderRGBATexAlphaColorMatrixAA::GetShaderString(
       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)
 }
@@ -1249,12 +1588,13 @@ void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(
     "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);
@@ -1265,6 +1605,7 @@ void FragmentShaderRGBATexAlphaMaskColorMatrix::Init(
   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(
@@ -1290,7 +1631,7 @@ std::string FragmentShaderRGBATexAlphaMaskColorMatrix::GetShaderString(
           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)
 }