Add layout qualifiers to compositor 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 <stddef.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
 #include "cc/output/static_geometry_binding.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/size.h"
 
+static const char* blend_mode_to_layout_qualifier[cc::LAST_BLEND_MODE + 1] = {
+    // These first two should get skipped by conditionals and never
+    // appear in a shader.
+    "error_blend_none_shouldnt_use_this",
+    "error_blend_normal_shouldnt_use_this",
+    "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",
+};
+
 template <size_t size>
 std::string StripLambda(const char(&shader)[size]) {
   // Must contain at least "[]() {}" and trailing null (included in size).
   static_assert(size >= 8,
                 "String passed to StripLambda must be at least 8 characters");
   DCHECK_EQ(strncmp("[]() {", shader, 6), 0);
   DCHECK_EQ(shader[size - 2], '}');
   return std::string(shader + 6, shader + size - 2);
 }
 
@@ skipping 744 matching lines @@
 FragmentTexBlendMode::FragmentTexBlendMode()
     : backdrop_location_(-1),
       original_backdrop_location_(-1),
       backdrop_rect_location_(-1),
       blend_mode_(BLEND_MODE_NONE),
       mask_for_background_(false) {
 }
 
 std::string FragmentTexBlendMode::SetBlendModeFunctions(
     const std::string& shader_string) const {
-  if (shader_string.find("ApplyBlendMode") == std::string::npos)
-    return shader_string;
+  if (shader_string.find("ApplyBlendMode") == std::string::npos) {
+    return "out vec4 outFragColor;\n" + shader_string;
+  }
 
   if (!has_blend_mode()) {
-    return "#define ApplyBlendMode(X, Y) (X)\n" + shader_string;
+    return "#define ApplyBlendMode(X, Y) (X)\nout vec4 outFragColor;\n" +
+           shader_string;
   }
 
   static const std::string kUniforms = SHADER0([]() {
     uniform sampler2D s_backdropTexture;
     uniform sampler2D s_originalBackdropTexture;
     uniform TexCoordPrecision vec4 backdropRect;
   });
 
+  std::string outColor;
+  if (blend_mode() == BLEND_MODE_NORMAL) {
+    outColor = "out vec4 outFragColor;";
+  } else {
+    outColor = base::StringPrintf(
+        "#extension GL_KHR_blend_equation_advanced : require\n"

[Ken Russell (switch to Gerrit), 2016/12/05 05:44:33]

I'm pretty sure this extension directive has to come at the beginning of the
shader. Will that happen with the code as written?

+        "layout(%s) out vec4 outFragColor;\n",
+        blend_mode_to_layout_qualifier[blend_mode()]);
+  }
+
   std::string mixFunction;
   if (mask_for_background()) {
     mixFunction = SHADER0([]() {
       vec4 MixBackdrop(TexCoordPrecision vec2 bgTexCoord, float mask) {
         vec4 backdrop = texture2D(s_backdropTexture, bgTexCoord);
         vec4 original_backdrop =
             texture2D(s_originalBackdropTexture, bgTexCoord);
         return mix(original_backdrop, backdrop, mask);
       }
     });
@@ skipping 14 matching lines @@
     }
 
     vec4 ApplyBlendMode(vec4 src, float mask) {
       vec4 dst = GetBackdropColor(mask);
       return Blend(src, dst);
     }
   });
 
   return "precision mediump float;" + GetHelperFunctions() +
          GetBlendFunction() + kUniforms + mixFunction +
-         kFunctionApplyBlendMode + shader_string;
+         kFunctionApplyBlendMode + outColor + 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));
@@ skipping 315 matching lines @@
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform float alpha;
   });
 }
 
 std::string FragmentShaderRGBATexAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
-      gl_FragColor = ApplyBlendMode(texColor * alpha, 0.0);
+      outFragColor = ApplyBlendMode(texColor * alpha, 0.0);
     }
   });
 }
 
 void FragmentShaderRGBATexAlpha::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->alpha = alpha_location();
   locations->backdrop = backdrop_location();
   locations->backdrop_rect = backdrop_rect_location();
@@ skipping 18 matching lines @@
 
 std::string FragmentShaderRGBATexColorMatrixAlpha::GetShaderBody() {
   return SHADER0([]() {
     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 = ApplyBlendMode(texColor * alpha, 0.0);
+      outFragColor = ApplyBlendMode(texColor * alpha, 0.0);
     }
   });
 }
 
 void FragmentShaderRGBATexColorMatrixAlpha::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->alpha = alpha_location();
   locations->color_matrix = color_matrix_location();
   locations->color_offset = color_offset_location();
@@ skipping 13 matching lines @@
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform SamplerType s_texture;
   });
 }
 
 std::string FragmentShaderRGBATexVaryingAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
-      gl_FragColor = texColor * v_alpha;
+      outFragColor = texColor * v_alpha;
     }
   });
 }
 
 std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform SamplerType s_texture;
   });
 }
 
 std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor.rgb *= texColor.a;
-      gl_FragColor = texColor * v_alpha;
+      outFragColor = texColor * v_alpha;
     }
   });
 }
 
 FragmentTexBackgroundBinding::FragmentTexBackgroundBinding()
     : background_color_location_(-1), sampler_location_(-1) {
 }
 
 void FragmentTexBackgroundBinding::Init(GLES2Interface* context,
                                         unsigned program,
@@ skipping 31 matching lines @@
     uniform vec4 background_color;
     uniform SamplerType s_texture;
   });
 }
 
 std::string FragmentShaderTexBackgroundVaryingAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor += background_color * (1.0 - texColor.a);
-      gl_FragColor = texColor * v_alpha;
+      outFragColor = texColor * v_alpha;
     }
   });
 }
 
 std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform vec4 background_color;
     uniform SamplerType s_texture;
   });
 }
 
 std::string FragmentShaderTexBackgroundPremultiplyAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
       texColor.rgb *= texColor.a;
       texColor += background_color * (1.0 - texColor.a);
-      gl_FragColor = texColor * v_alpha;
+      outFragColor = texColor * v_alpha;
     }
   });
 }
 
 std::string FragmentShaderRGBATexOpaque::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderRGBATexOpaque::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
   });
 }
 
 std::string FragmentShaderRGBATexOpaque::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
-      gl_FragColor = vec4(texColor.rgb, 1.0);
+      outFragColor = vec4(texColor.rgb, 1.0);
     }
   });
 }
 
 std::string FragmentShaderRGBATex::GetShaderString(TexCoordPrecision precision,
                                                    SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderRGBATex::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
   });
 }
 
 std::string FragmentShaderRGBATex::GetShaderBody() {
   return SHADER0([]() {
-    void main() { gl_FragColor = TextureLookup(s_texture, v_texCoord); }
+    void main() { outFragColor = TextureLookup(s_texture, v_texCoord); }
   });
 }
 
 std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
     uniform float alpha;
   });
 }
 
 std::string FragmentShaderRGBATexSwizzleAlpha::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
-      gl_FragColor =
+      outFragColor =
           vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha;
     }
   });
 }
 
 std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
 std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     uniform SamplerType s_texture;
   });
 }
 
 std::string FragmentShaderRGBATexSwizzleOpaque::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = TextureLookup(s_texture, v_texCoord);
-      gl_FragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
+      outFragColor = vec4(texColor.z, texColor.y, texColor.x, 1.0);
     }
   });
 }
 
 FragmentShaderRGBATexAlphaAA::FragmentShaderRGBATexAlphaAA()
     : sampler_location_(-1), alpha_location_(-1) {
 }
 
 void FragmentShaderRGBATexAlphaAA::Init(GLES2Interface* context,
                                         unsigned program,
@@ skipping 30 matching lines @@
   });
 }
 
 std::string FragmentShaderRGBATexAlphaAA::GetShaderBody() {
   return SHADER0([]() {
     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 = ApplyBlendMode(texColor * alpha * aa, 0.0);
+      outFragColor = ApplyBlendMode(texColor * alpha * aa, 0.0);
     }
   });
 }
 
 void FragmentShaderRGBATexAlphaAA::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->alpha = alpha_location();
   locations->backdrop = backdrop_location();
   locations->backdrop_rect = backdrop_rect_location();
@@ skipping 44 matching lines @@
 std::string FragmentShaderRGBATexClampAlphaAA::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       TexCoordPrecision vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +
           fragmentTexTransform.xy;
       vec4 texColor = TextureLookup(s_texture, 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;
+      outFragColor = texColor * alpha * aa;
     }
   });
 }
 
 std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderString(
     TexCoordPrecision precision,
     SamplerType sampler) const {
   return FRAGMENT_SHADER(GetShaderHead(), GetShaderBody());
 }
 
@@ skipping 11 matching lines @@
 std::string FragmentShaderRGBATexClampSwizzleAlphaAA::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       TexCoordPrecision vec2 texCoord =
           clamp(v_texCoord, 0.0, 1.0) * fragmentTexTransform.zw +
           fragmentTexTransform.xy;
       vec4 texColor = TextureLookup(s_texture, 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 =
+      outFragColor =
           vec4(texColor.z, texColor.y, texColor.x, texColor.w) * alpha * aa;
     }
   });
 }
 
 FragmentShaderRGBATexAlphaMask::FragmentShaderRGBATexAlphaMask()
     : sampler_location_(-1),
       mask_sampler_location_(-1),
       alpha_location_(-1),
       mask_tex_coord_scale_location_(-1) {
@@ skipping 45 matching lines @@
 }
 
 std::string FragmentShaderRGBATexAlphaMask::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       vec4 texColor = texture2D(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 = ApplyBlendMode(
-          texColor * alpha * maskColor.w, maskColor.w);
+      outFragColor =
+          ApplyBlendMode(texColor * alpha * maskColor.w, maskColor.w);
     }
   });
 }
 
 void FragmentShaderRGBATexAlphaMask::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->mask_sampler = mask_sampler_location();
   locations->mask_tex_coord_scale = mask_tex_coord_scale_location();
   locations->mask_tex_coord_offset = mask_tex_coord_offset_location();
@@ skipping 62 matching lines @@
   return SHADER0([]() {
     void main() {
       vec4 texColor = texture2D(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 = ApplyBlendMode(
-          texColor * alpha * maskColor.w * aa, maskColor.w);
+      outFragColor =
+          ApplyBlendMode(texColor * alpha * maskColor.w * aa, maskColor.w);
     }
   });
 }
 
 void FragmentShaderRGBATexAlphaMaskAA::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->mask_sampler = mask_sampler_location();
   locations->mask_tex_coord_scale = mask_tex_coord_scale_location();
   locations->mask_tex_coord_offset = mask_tex_coord_offset_location();
@@ skipping 76 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 = ApplyBlendMode(
-          texColor * alpha * maskColor.w * aa, maskColor.w);
+      outFragColor =
+          ApplyBlendMode(texColor * alpha * maskColor.w * aa, maskColor.w);
     }
   });
 }
 
 void FragmentShaderRGBATexAlphaMaskColorMatrixAA::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->alpha = alpha_location();
   locations->mask_sampler = mask_sampler_location();
   locations->mask_tex_coord_scale = mask_tex_coord_scale_location();
@@ skipping 58 matching lines @@
     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 = ApplyBlendMode(texColor * alpha * aa, 0.0);
+      outFragColor = ApplyBlendMode(texColor * alpha * aa, 0.0);
     }
   });
 }
 
 void FragmentShaderRGBATexAlphaColorMatrixAA::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->alpha = alpha_location();
   locations->color_matrix = color_matrix_location();
   locations->color_offset = color_offset_location();
@@ skipping 66 matching lines @@
       vec4 texColor = texture2D(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 = ApplyBlendMode(
-          texColor * alpha * maskColor.w, maskColor.w);
+      outFragColor =
+          ApplyBlendMode(texColor * alpha * maskColor.w, maskColor.w);
     }
   });
 }
 
 void FragmentShaderRGBATexAlphaMaskColorMatrix::FillLocations(
     ShaderLocations* locations) const {
   locations->sampler = sampler_location();
   locations->mask_sampler = mask_sampler_location();
   locations->mask_tex_coord_scale = mask_tex_coord_scale_location();
   locations->mask_tex_coord_offset = mask_tex_coord_offset_location();
@@ skipping 155 matching lines @@
   }
 
   functions += SHADER0([]() {
     void main() {
       vec2 ya_clamped =
           max(ya_clamp_rect.xy, min(ya_clamp_rect.zw, v_yaTexCoord));
       float y_raw = TextureLookup(y_texture, ya_clamped).x;
       vec2 uv_clamped =
           max(uv_clamp_rect.xy, min(uv_clamp_rect.zw, v_uvTexCoord));
       vec3 yuv = vec3(y_raw, GetUV(uv_clamped));
-      gl_FragColor = vec4(yuv2rgb(yuv), 1.0) * GetAlpha(ya_clamped);
+      outFragColor = vec4(yuv2rgb(yuv), 1.0) * GetAlpha(ya_clamped);
     }
   });
 
   return FRAGMENT_SHADER(head, functions);
 }
 
 FragmentShaderColor::FragmentShaderColor() : color_location_(-1) {
 }
 
 void FragmentShaderColor::Init(GLES2Interface* context,
@@ skipping 20 matching lines @@
 
 std::string FragmentShaderColor::GetShaderHead() {
   return SHADER0([]() {
     precision mediump float;
     uniform vec4 color;
   });
 }
 
 std::string FragmentShaderColor::GetShaderBody() {
   return SHADER0([]() {
-    void main() { gl_FragColor = color; }
+    void main() { outFragColor = color; }
   });
 }
 
 FragmentShaderColorAA::FragmentShaderColorAA() : color_location_(-1) {
 }
 
 void FragmentShaderColorAA::Init(GLES2Interface* context,
                                  unsigned program,
                                  int* base_uniform_index) {
   static const char* uniforms[] = {
@@ skipping 22 matching lines @@
     varying vec4 edge_dist[2];  // 8 edge distances.
   });
 }
 
 std::string FragmentShaderColorAA::GetShaderBody() {
   return SHADER0([]() {
     void main() {
       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 = color * aa;
+      outFragColor = color * aa;
     }
   });
 }
 
 }  // namespace cc