Blend TextureLayer background-color at draw time.

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 80 matching lines @@
   gfx::PointF uv0 = quad->uv_top_left;
   gfx::PointF uv1 = quad->uv_bottom_right;
   Float4 xform = { { uv0.x(), uv0.y(), uv1.x() - uv0.x(), uv1.y() - uv0.y() } };
   if (quad->flipped) {
     xform.data[1] = 1.0f - xform.data[1];
     xform.data[3] = -xform.data[3];
   }
   return xform;
 }
 
+Float4 PremultipliedColor(SkColor color) {
+  const float factor = 1.0f / 255.0f;
+  const float alpha = SkColorGetA(color) * factor;
+
+  Float4 result = { {
+      SkColorGetR(color) * factor * alpha,
+      SkColorGetG(color) * factor * alpha,
+      SkColorGetB(color) * factor * alpha,
+      alpha
+  } };
+  return result;
+}
+
 // Smallest unit that impact anti-aliasing output. We use this to
 // determine when anti-aliasing is unnecessary.
 const float kAntiAliasingEpsilon = 1.0f / 1024.0f;
 
 }  // anonymous namespace
 
 struct GLRenderer::PendingAsyncReadPixels {
   PendingAsyncReadPixels() : buffer(0) {}
 
   scoped_ptr<CopyOutputRequest> copy_request;
@@ skipping 1533 matching lines @@
   DrawContentQuad(frame, quad, on_demand_tile_raster_resource_id_);
 }
 
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
     DCHECK(program && (program->initialized() || context->isContextLost()));
     program_id = program->program();
     sampler_location = program->fragment_shader().sampler_location();
     matrix_location = program->vertex_shader().matrix_location();
-    alpha_location = program->fragment_shader().alpha_location();
+    background_color_location =
+        program->fragment_shader().background_color_location();
   }
   int program_id;
   int sampler_location;
   int matrix_location;
-  int alpha_location;
+  int background_color_location;
 };
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
     TextureProgramBinding::Set(program, context);
     tex_transform_location = program->vertex_shader().tex_transform_location();
     vertex_opacity_location =
         program->vertex_shader().vertex_opacity_location();
   }
@@ skipping 33 matching lines @@
       context_->uniformMatrix4fv(
           static_cast<int>(draw_cache_.matrix_location),
           static_cast<int>(draw_cache_.matrix_data.size()),
           false,
           reinterpret_cast<float*>(&draw_cache_.matrix_data.front())));
   GLC(context_,
       context_->uniform4fv(
           static_cast<int>(draw_cache_.uv_xform_location),
           static_cast<int>(draw_cache_.uv_xform_data.size()),
           reinterpret_cast<float*>(&draw_cache_.uv_xform_data.front())));
+
+  if (draw_cache_.background_color != SK_ColorTRANSPARENT) {
+    Float4 background_color = PremultipliedColor(draw_cache_.background_color);
+    GLC(context_,
+        context_->uniform4fv(
+            draw_cache_.background_color_location, 1, background_color.data));
+  }
+
   GLC(context_,
       context_->uniform1fv(
           static_cast<int>(draw_cache_.vertex_opacity_location),
           static_cast<int>(draw_cache_.vertex_opacity_data.size()),
           static_cast<float*>(&draw_cache_.vertex_opacity_data.front())));
 
   // Draw the quads!
   GLC(context_,
       context_->drawElements(GL_TRIANGLES,
                              6 * draw_cache_.matrix_data.size(),
                              GL_UNSIGNED_SHORT,
                              0));
 
   // Clear the cache.
   draw_cache_.program_id = 0;
   draw_cache_.uv_xform_data.resize(0);
   draw_cache_.vertex_opacity_data.resize(0);
   draw_cache_.matrix_data.resize(0);
 }
 
 void GLRenderer::EnqueueTextureQuad(const DrawingFrame* frame,
                                     const TextureDrawQuad* quad) {
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       context_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   // Choose the correct texture program binding
   TexTransformTextureProgramBinding binding;
   if (quad->premultiplied_alpha) {
-    binding.Set(GetTextureProgram(tex_coord_precision), Context());
+    if (quad->background_color == SK_ColorTRANSPARENT) {
+      binding.Set(GetTextureProgram(tex_coord_precision), Context());
+    } else {
+      binding.Set(GetTextureBackgroundProgram(tex_coord_precision), Context());
+    }
   } else {
-    binding.Set(GetNonPremultipliedTextureProgram(tex_coord_precision),
-                Context());
+    if (quad->background_color == SK_ColorTRANSPARENT) {
+      binding.Set(GetNonPremultipliedTextureProgram(tex_coord_precision),
+                  Context());
+    } else {
+      binding.Set(
+          GetNonPremultipliedTextureBackgroundProgram(tex_coord_precision),
+          Context());
+    }
   }
 
   int resource_id = quad->resource_id;
 
   if (draw_cache_.program_id != binding.program_id ||
       draw_cache_.resource_id != resource_id ||
       draw_cache_.needs_blending != quad->ShouldDrawWithBlending() ||
+      draw_cache_.background_color != quad->background_color ||
       draw_cache_.matrix_data.size() >= 8) {
     FlushTextureQuadCache();
     draw_cache_.program_id = binding.program_id;
     draw_cache_.resource_id = resource_id;
     draw_cache_.needs_blending = quad->ShouldDrawWithBlending();
+    draw_cache_.background_color = quad->background_color;
 
     draw_cache_.uv_xform_location = binding.tex_transform_location;
+    draw_cache_.background_color_location = binding.background_color_location;
     draw_cache_.vertex_opacity_location = binding.vertex_opacity_location;
     draw_cache_.matrix_location = binding.matrix_location;
     draw_cache_.sampler_location = binding.sampler_location;
   }
 
   // Generate the uv-transform
   draw_cache_.uv_xform_data.push_back(UVTransform(quad));
 
   // Generate the vertex opacity
   const float opacity = quad->opacity();
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
   draw_cache_.vertex_opacity_data.push_back(quad->vertex_opacity[3] * opacity);
 
   // Generate the transform matrix
   gfx::Transform quad_rect_matrix;
   QuadRectTransform(&quad_rect_matrix, quad->quadTransform(), quad->rect);
   quad_rect_matrix = frame->projection_matrix * quad_rect_matrix;
 
   Float16 m;
   quad_rect_matrix.matrix().asColMajorf(m.data);
   draw_cache_.matrix_data.push_back(m);
 }
 
 void GLRenderer::DrawTextureQuad(const DrawingFrame* frame,
                                  const TextureDrawQuad* quad) {

[piman, 2013/07/03 20:11:12]

FYI this method was removed by https://codereview.chromium.org/18582003/

[alokp, 2013/07/09 00:08:06]

Thanks for the heads up.

   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       context_, &highp_threshold_cache_, highp_threshold_min_,
       quad->shared_quad_state->visible_content_rect.bottom_right());
 
   TexTransformTextureProgramBinding binding;
   if (quad->premultiplied_alpha) {
-    binding.Set(GetTextureProgram(tex_coord_precision), Context());
+    if (quad->background_color == SK_ColorTRANSPARENT) {
+      binding.Set(GetTextureProgram(tex_coord_precision), Context());
+    } else {
+      binding.Set(GetTextureBackgroundProgram(tex_coord_precision), Context());
+    }
   } else {
-    binding.Set(GetNonPremultipliedTextureProgram(tex_coord_precision),
-                Context());
+    if (quad->background_color == SK_ColorTRANSPARENT) {
+      binding.Set(GetNonPremultipliedTextureProgram(tex_coord_precision),
+                  Context());
+    } else {
+      binding.Set(
+          GetNonPremultipliedTextureBackgroundProgram(tex_coord_precision),
+          Context());
+    }
   }
   SetUseProgram(binding.program_id);
   GLC(Context(), Context()->uniform1i(binding.sampler_location, 0));
   Float4 uv_xform = UVTransform(quad);
   GLC(Context(),
       Context()->uniform4f(binding.tex_transform_location,
                            uv_xform.data[0],
                            uv_xform.data[1],
                            uv_xform.data[2],
                            uv_xform.data[3]));
 
+  if (quad->background_color != SK_ColorTRANSPARENT) {
+    Float4 background_color = PremultipliedColor(quad->background_color);
+    GLC(Context(),
+        Context()->uniform4fv(
+            binding.background_color_location, 1, background_color.data));
+  }
+
   GLC(Context(),
       Context()->uniform1fv(
           binding.vertex_opacity_location, 4, quad->vertex_opacity));
 
   ResourceProvider::ScopedSamplerGL quad_resource_lock(
       resource_provider_, quad->resource_id, GL_TEXTURE_2D, GL_LINEAR);
 
   DrawQuadGeometry(
       frame, quad->quadTransform(), quad->rect, binding.matrix_location);
 }
@@ skipping 957 matching lines @@
         new NonPremultipliedTextureProgram(context_, precision));
   }
   if (!program->initialized()) {
     TRACE_EVENT0("cc",
                  "GLRenderer::NonPremultipliedTextureProgram::Initialize");
     program->Initialize(context_, is_using_bind_uniform_);
   }
   return program.get();
 }
 
+const GLRenderer::TextureBackgroundProgram*
+GLRenderer::GetTextureBackgroundProgram(TexCoordPrecision precision) {
+  scoped_ptr<TextureBackgroundProgram>& program =
+      (precision == TexCoordPrecisionHigh) ? texture_background_program_highp_
+                                           : texture_background_program_;
+  if (!program)
+    program = make_scoped_ptr(
+        new TextureBackgroundProgram(context_, precision));
+  if (!program->initialized()) {
+    TRACE_EVENT0("cc", "GLRenderer::textureProgram::initialize");
+    program->Initialize(context_, is_using_bind_uniform_);
+  }
+  return program.get();
+}
+
+const GLRenderer::NonPremultipliedTextureBackgroundProgram*
+GLRenderer::GetNonPremultipliedTextureBackgroundProgram(
+    TexCoordPrecision precision) {
+  scoped_ptr<NonPremultipliedTextureBackgroundProgram>& program =
+      (precision == TexCoordPrecisionHigh) ?
+         nonpremultiplied_texture_background_program_highp_ :
+         nonpremultiplied_texture_background_program_;
+  if (!program) {
+    program = make_scoped_ptr(
+        new NonPremultipliedTextureBackgroundProgram(context_, precision));
+  }
+  if (!program->initialized()) {
+    TRACE_EVENT0("cc",
+                 "GLRenderer::NonPremultipliedTextureProgram::Initialize");
+    program->Initialize(context_, is_using_bind_uniform_);
+  }
+  return program.get();
+}
+
 const GLRenderer::TextureIOSurfaceProgram*
 GLRenderer::GetTextureIOSurfaceProgram(TexCoordPrecision precision) {
   scoped_ptr<TextureIOSurfaceProgram>& program =
       (precision == TexCoordPrecisionHigh) ? texture_io_surface_program_highp_
                                            : texture_io_surface_program_;
   if (!program)
     program =
         make_scoped_ptr(new TextureIOSurfaceProgram(context_, precision));
   if (!program->initialized()) {
     TRACE_EVENT0("cc", "GLRenderer::textureIOSurfaceProgram::initialize");
@@ skipping 111 matching lines @@
     render_pass_mask_color_matrix_program_aa_highp_->Cleanup(context_);
   if (render_pass_color_matrix_program_aa_highp_)
     render_pass_color_matrix_program_aa_highp_->Cleanup(context_);
   if (render_pass_mask_color_matrix_program_highp_)
     render_pass_mask_color_matrix_program_highp_->Cleanup(context_);
 
   if (texture_program_)
     texture_program_->Cleanup(context_);
   if (nonpremultiplied_texture_program_)
     nonpremultiplied_texture_program_->Cleanup(context_);
+  if (texture_background_program_)
+    texture_background_program_->Cleanup(context_);
+  if (nonpremultiplied_texture_background_program_)
+    nonpremultiplied_texture_background_program_->Cleanup(context_);
   if (texture_io_surface_program_)
     texture_io_surface_program_->Cleanup(context_);
 
   if (texture_program_highp_)
     texture_program_highp_->Cleanup(context_);
   if (nonpremultiplied_texture_program_highp_)
     nonpremultiplied_texture_program_highp_->Cleanup(context_);
+  if (texture_background_program_highp_)
+    texture_background_program_highp_->Cleanup(context_);
+  if (nonpremultiplied_texture_background_program_highp_)
+    nonpremultiplied_texture_background_program_highp_->Cleanup(context_);
   if (texture_io_surface_program_highp_)
     texture_io_surface_program_highp_->Cleanup(context_);
 
   if (video_yuv_program_)
     video_yuv_program_->Cleanup(context_);
   if (video_yuva_program_)
     video_yuva_program_->Cleanup(context_);
   if (video_stream_texture_program_)
     video_stream_texture_program_->Cleanup(context_);
 
@@ skipping 76 matching lines @@
   std::string unique_context_name = base::StringPrintf(
       "%s-Offscreen-%p",
       Settings().compositor_name.c_str(),
       context_);
   resource_provider()->offscreen_context_provider()->Context3d()->
     pushGroupMarkerEXT(unique_context_name.c_str());
 }
 
 
 }  // namespace cc