Adding support for per vertex opacity on textured layer

cc/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/gl_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 976 matching lines @@
     int matrixLocation;
     int alphaLocation;
 };
 
 struct TexTransformTextureProgramBinding : TextureProgramBinding {
     template<class Program> void set(
         Program* program, WebKit::WebGraphicsContext3D* context)
     {
         TextureProgramBinding::set(program, context);
         texTransformLocation = program->vertexShader().texTransformLocation();
+        vertexOpacityLocation = program->vertexShader().vertexOpacityLocation();
     }
     int texTransformLocation;
+    int vertexOpacityLocation;
 };
 
 void GLRenderer::flushTextureQuadCache()
 {
     // Check to see if we have anything to draw.
     if (m_drawCache.program_id == 0)
       return;
 
     // Set the correct blending mode.
     setBlendEnabled(m_drawCache.needs_blending);
@@ skipping 14 matching lines @@
         // will never cause the alpha channel to be set to anything less than 1.0 if it is
         // initialized to that value! Therefore, premultipliedAlpha being false is the first
         // situation we can generally see an alpha channel less than 1.0 coming out of the
         // compositor. This is causing platform differences in some layout tests (see
         // https://bugs.webkit.org/show_bug.cgi?id=82412), so in this situation, use a separate
         // blend function for the alpha channel to avoid modifying it. Don't use colorMask for this
         // as it has performance implications on some platforms.
         GLC(context(), context()->blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE));
     }
 
-    // Set the shader opacity.
-    setShaderOpacity(m_drawCache.alpha, m_drawCache.alpha_location);
-
     COMPILE_ASSERT(sizeof(Float4) == 4 * sizeof(float), struct_is_densely_packed);
     COMPILE_ASSERT(sizeof(Float16) == 16 * sizeof(float), struct_is_densely_packed);
 
     // Upload the tranforms for both points and uvs.
-    GLC(m_context, m_context->uniformMatrix4fv((int)m_drawCache.matrix_location, (int)m_drawCache.matrix_data.size(), false, (float*)&m_drawCache.matrix_data.front()));
-    GLC(m_context, m_context->uniform4fv((int)m_drawCache.uv_xform_location, (int)m_drawCache.uv_xform_data.size(), (float*)&m_drawCache.uv_xform_data.front()));
+    GLC(m_context, m_context->uniformMatrix4fv(static_cast<int>(m_drawCache.matrix_location), static_cast<int>(m_drawCache.matrix_data.size()), false, reinterpret_cast<float*>(&m_drawCache.matrix_data.front())));
+    GLC(m_context, m_context->uniform4fv(static_cast<int>(m_drawCache.uv_xform_location), static_cast<int>(m_drawCache.uv_xform_data.size()), reinterpret_cast<float*>(&m_drawCache.uv_xform_data.front())));
+    GLC(m_context, m_context->uniform1fv(static_cast<int>(m_drawCache.vertex_opacity_location), static_cast<int>(m_drawCache.vertex_opacity_data.size()), static_cast<float*>(&m_drawCache.vertex_opacity_data.front())));
 
     // Draw the quads!
     GLC(m_context, m_context->drawElements(GL_TRIANGLES, 6 * m_drawCache.matrix_data.size(), GL_UNSIGNED_SHORT, 0));
 
     // Clean up after ourselves (reset state set above).
      if (!m_drawCache.use_premultiplied_alpha)
         GLC(m_context, m_context->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 
     // Clear the cache.
     m_drawCache.program_id = 0;
     m_drawCache.uv_xform_data.resize(0);
+    m_drawCache.vertex_opacity_data.resize(0);
     m_drawCache.matrix_data.resize(0);
 }
 
 void GLRenderer::enqueueTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
 {
-    // Choose the correcte texture program binding
+    // Choose the correct texture program binding
     TexTransformTextureProgramBinding binding;
     if (quad->flipped)
         binding.set(textureProgramFlip(), context());
     else
         binding.set(textureProgram(), context());
 
     int resourceID = quad->resource_id;
 
     if (m_drawCache.program_id != binding.programId ||
         m_drawCache.resource_id != resourceID ||
-        m_drawCache.alpha != quad->opacity() ||
         m_drawCache.use_premultiplied_alpha != quad->premultiplied_alpha ||
         m_drawCache.needs_blending != quad->ShouldDrawWithBlending() ||
         m_drawCache.matrix_data.size() >= 8) {
         flushTextureQuadCache();
         m_drawCache.program_id = binding.programId;
         m_drawCache.resource_id = resourceID;
-        m_drawCache.alpha = quad->opacity();
         m_drawCache.use_premultiplied_alpha = quad->premultiplied_alpha;
         m_drawCache.needs_blending = quad->ShouldDrawWithBlending();
 
-        m_drawCache.alpha_location = binding.alphaLocation;
         m_drawCache.uv_xform_location = binding.texTransformLocation;
+        m_drawCache.vertex_opacity_location = binding.vertexOpacityLocation;
         m_drawCache.matrix_location = binding.matrixLocation;
         m_drawCache.sampler_location = binding.samplerLocation;
     }
 
     // Generate the uv-transform
     const gfx::RectF& uvRect = quad->uv_rect;
     Float4 uv = {uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()};
     m_drawCache.uv_xform_data.push_back(uv);
 
+    // Generate the vertex opacity
+    const float opacity = quad->opacity();
+    m_drawCache.vertex_opacity_data.push_back(quad->vertex_opacity[0] * opacity);
+    m_drawCache.vertex_opacity_data.push_back(quad->vertex_opacity[1] * opacity);
+    m_drawCache.vertex_opacity_data.push_back(quad->vertex_opacity[2] * opacity);
+    m_drawCache.vertex_opacity_data.push_back(quad->vertex_opacity[3] * opacity);
+
     // Generate the transform matrix
     gfx::Transform quadRectMatrix;
     quadRectTransform(&quadRectMatrix, quad->quadTransform(), quad->rect);
     quadRectMatrix = frame.projectionMatrix * quadRectMatrix;
 
     Float16 m;
     quadRectMatrix.matrix().asColMajorf(m.data);
     m_drawCache.matrix_data.push_back(m);
 }
 
 void GLRenderer::drawTextureQuad(const DrawingFrame& frame, const TextureDrawQuad* quad)
 {
     TexTransformTextureProgramBinding binding;
     if (quad->flipped)
         binding.set(textureProgramFlip(), context());
     else
         binding.set(textureProgram(), context());
     setUseProgram(binding.programId);
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
     const gfx::RectF& uvRect = quad->uv_rect;
     GLC(context(), context()->uniform4f(binding.texTransformLocation, uvRect.x(), uvRect.y(), uvRect.width(), uvRect.height()));
 
+    GLC(context(), context()->uniform1fv(binding.vertexOpacityLocation, 4, quad->vertex_opacity));
+
     ResourceProvider::ScopedSamplerGL quadResourceLock(m_resourceProvider, quad->resource_id, GL_TEXTURE_2D, GL_LINEAR);
 
     if (!quad->premultiplied_alpha) {
         // As it turns out, the premultiplied alpha blending function (ONE, ONE_MINUS_SRC_ALPHA)
         // will never cause the alpha channel to be set to anything less than 1.0 if it is
         // initialized to that value! Therefore, premultipliedAlpha being false is the first
         // situation we can generally see an alpha channel less than 1.0 coming out of the
         // compositor. This is causing platform differences in some layout tests (see
         // https://bugs.webkit.org/show_bug.cgi?id=82412), so in this situation, use a separate
         // blend function for the alpha channel to avoid modifying it. Don't use colorMask for this
         // as it has performance implications on some platforms.
         GLC(context(), context()->blendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE));
     }
 
-    setShaderOpacity(quad->opacity(), binding.alphaLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation);
 
     if (!quad->premultiplied_alpha)
         GLC(m_context, m_context->blendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA));
 }
 
 void GLRenderer::drawIOSurfaceQuad(const DrawingFrame& frame, const IOSurfaceDrawQuad* quad)
 {
     TexTransformTextureProgramBinding binding;
     binding.set(textureIOSurfaceProgram(), context());
 
     setUseProgram(binding.programId);
     GLC(context(), context()->uniform1i(binding.samplerLocation, 0));
     if (quad->orientation == IOSurfaceDrawQuad::FLIPPED)
         GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, quad->io_surface_size.height(), quad->io_surface_size.width(), quad->io_surface_size.height() * -1.0));
     else
         GLC(context(), context()->uniform4f(binding.texTransformLocation, 0, 0, quad->io_surface_size.width(), quad->io_surface_size.height()));
 
+    const float vertex_opacity[] = {quad->opacity(), quad->opacity(), quad->opacity(), quad->opacity()};
+    GLC(context(), context()->uniform1fv(binding.vertexOpacityLocation, 4, vertex_opacity));
+
     GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, quad->io_surface_texture_id));
 
-    setShaderOpacity(quad->opacity(), binding.alphaLocation);
     drawQuadGeometry(frame, quad->quadTransform(), quad->rect, binding.matrixLocation);
 
     GLC(context(), context()->bindTexture(GL_TEXTURE_RECTANGLE_ARB, 0));
 }
 
 void GLRenderer::finishDrawingFrame(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
     m_swapBufferRect.Union(gfx::ToEnclosingRect(frame.rootDamageRect));
 
@@ skipping 616 matching lines @@
 
     releaseRenderPassTextures();
 }
 
 bool GLRenderer::isContextLost()
 {
     return (m_context->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc