Blend TextureLayer background-color at draw time.

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"
@@ skipping 650 matching lines @@
       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;
     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexVaryingAlpha::GetShaderString(
+FragmentTexBackgroundBinding::FragmentTexBackgroundBinding()
+    : background_color_location_(-1),
+      sampler_location_(-1) {
+}
+
+void FragmentTexBackgroundBinding::Init(WebGraphicsContext3D* context,
+                                        unsigned program,
+                                        bool using_bind_uniform,
+                                        int* base_uniform_index) {
+  static const char* shader_uniforms[] = {
+    "s_texture",
+    "background_color",
+  };
+  int locations[2];
+
+  GetProgramUniformLocations(context,
+                             program,
+                             shader_uniforms,
+                             arraysize(shader_uniforms),
+                             arraysize(locations),
+                             locations,
+                             using_bind_uniform,
+                             base_uniform_index);
+
+  sampler_location_ = locations[0];
+  DCHECK_NE(sampler_location_, -1);
+
+  background_color_location_ = locations[1];
+  DCHECK_NE(background_color_location_, -1);
+}
+
+std::string FragmentShaderTexture::GetShaderString(
     TexCoordPrecision precision) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform sampler2D s_texture;
+    uniform vec4 background_color;
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
+      texColor += background_color * (1.0 - texColor.a);

[piman, 2013/07/02 01:26:30]

drive-by: so, this extra cost is done on every pixel, for every TextureLayer,
even those that don't specify the background color to blend, or are opaque...

Can you instead keep the existing shaders for the common case (background is
transparent or quad is opaque), so that we don't have to pay this cost for, e.g.
Pepper, renderers in Aura, scrollbars, video, ...?

Also, I believe we draw quads with alpha != 0 with blending turned off (with the
intent to discard alpha). They will render differently with this.

[alokp, 2013/07/02 22:03:54]

I was hoping to not have to keep the existing shaders. The number of shaders we
have to maintain explodes with number of options. If we have to keep the
existing shaders, the number of shaders for texture layers will be 8:
texture precision - medium, high
premultiplied - yes, no
background color - yes, no

Do you think performance penalty would be too severe to warrant this complexity?
I do not understand how it will render differently if background-color is (0, 0,
0, 0). Can you elaborate?

       gl_FragColor = texColor * v_alpha;

[enne (OOO), 2013/07/02 01:27:22]

How does v_alpha interact with texColor.a? If the background color is supposed
to be a layer beneath the canvas, aren't these lines out of order?

[alokp, 2013/07/02 22:03:54]

This order is correct for this specific use case. In case of canvas elements,
the texture layer is first drawn on top of the background layer, with global
opacity applied to the combined texture (render-surface).

But yes, it is confusing. May be the term background-color is not appropriate
here?

[enne (OOO), 2013/07/02 23:08:29]

I think it's still correct.  I guess if I think about a content layer that has a
background color and an opacity, I would expect that the background color would
be blended with the rest of the content before having the opacity applied.

     }
   );  // NOLINT(whitespace/parens)
 }
 
-std::string FragmentShaderRGBATexPremultiplyAlpha::GetShaderString(
+std::string FragmentShaderNonPremulTexture::GetShaderString(
     TexCoordPrecision precision) const {
   return FRAGMENT_SHADER(
     precision mediump float;
     varying TexCoordPrecision vec2 v_texCoord;
     varying float v_alpha;
     uniform sampler2D s_texture;
+    uniform vec4 background_color;
     void main() {
       vec4 texColor = texture2D(s_texture, v_texCoord);
       texColor.rgb *= texColor.a;
+      texColor += background_color * (1.0 - texColor.a);
       gl_FragColor = texColor * v_alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 std::string FragmentShaderRGBATexRectVaryingAlpha::GetShaderString(
     TexCoordPrecision precision) const {
   return "#extension GL_ARB_texture_rectangle : require\n" +
       FRAGMENT_SHADER(
         precision mediump float;
@@ skipping 855 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);
       gl_FragColor = mix(color1, color2, picker) * alpha;
     }
   );  // NOLINT(whitespace/parens)
 }
 
 }  // namespace cc