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)

[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) {}
@@ -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)
 }