Adding support for per vertex opacity on textured layer

cc/geometry_binding.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/geometry_binding.h"
 
 #include "cc/gl_renderer.h" // For the GLC() macro.
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/gfx/rect_f.h"
 #include <public/WebGraphicsContext3D.h>
 
 namespace cc {
 
 GeometryBinding::GeometryBinding(WebKit::WebGraphicsContext3D* context, const gfx::RectF& quadVertexRect)
     : m_context(context)
     , m_quadVerticesVbo(0)
     , m_quadElementsVbo(0)
     , m_initialized(false)
 {
     float vertices[] = { quadVertexRect.x(), quadVertexRect.bottom(), 0.0f, 0.0f,  1.0f,
                          quadVertexRect.x(), quadVertexRect.y(), 0.0f, 0.0f,  0.0f,
                          quadVertexRect.right(), quadVertexRect.y(), 0.0f, 1.0f,  0.0f,
                          quadVertexRect.right(), quadVertexRect.bottom(), 0.0f, 1.0f,  1.0f };
 
     struct Vertex {
         float a_position[3];
         float a_texCoord[2];
-        float a_index; // index into the matrix array for this quad
+        float a_index; // index of the vertex, divide by 4 to have the matrix for this quad
     };
     struct Quad { Vertex v0, v1, v2, v3; };
     struct QuadIndex { uint16_t data[6]; };
 
     COMPILE_ASSERT(sizeof(Quad) == 24 * sizeof(float), struct_is_densely_packed);
     COMPILE_ASSERT(sizeof(QuadIndex) == 6 * sizeof(uint16_t), struct_is_densely_packed);
 
     Quad quad_list[8];
     QuadIndex quad_index_list[8];
     for (int i = 0; i < 8; i++) {

[whunt, 2012/12/14 21:13:45]

Why are we adding 0.5f to these indices?  They're intended to be integers.  When
used in the shaders they're cast to integers anyway.

[Jerome, 2012/12/14 21:48:47]

I was worried that the precision of the math might impact the index / 4.0 adding
0.5 does not change the result but is more robust to precision issues.

[whunt, 2012/12/14 22:38:44]

Every floating point standard known represents whole small integers correctly. 
Floating point operations where the values and results are small integers (small
being representable in 24 bits for float, 11 for half (CPUs don't support half
so this isn't relevant here) and 53 for double) are guaranteed by IEEE to not
generate reduced precision results.  Floating point isn't *that* scary =).

please remove the 0.5s

On 2012/12/14 21:48:47, Jerome wrote:

-        Vertex v0 = { quadVertexRect.x()    , quadVertexRect.bottom(), 0.0f,  0.0f, 1.0f, (float)i };
-        Vertex v1 = { quadVertexRect.x()    , quadVertexRect.y()     , 0.0f,  0.0f, 0.0f, (float)i };
-        Vertex v2 = { quadVertexRect.right(), quadVertexRect.y()     , 0.0f,  1.0f, 0.0f, (float)i };
-        Vertex v3 = { quadVertexRect.right(), quadVertexRect.bottom(), 0.0f,  1.0f, 1.0f, (float)i };
+        Vertex v0 = { quadVertexRect.x()    , quadVertexRect.bottom(), 0.0f,  0.0f, 1.0f, i * 4 + 0.5f };
+        Vertex v1 = { quadVertexRect.x()    , quadVertexRect.y()     , 0.0f,  0.0f, 0.0f, i * 4 + 1.5f };
+        Vertex v2 = { quadVertexRect.right(), quadVertexRect.y()     , 0.0f,  1.0f, 0.0f, i * 4 + 2.5f };
+        Vertex v3 = { quadVertexRect.right(), quadVertexRect.bottom(), 0.0f,  1.0f, 1.0f, i * 4 + 3.5f };
         Quad x = { v0, v1, v2, v3 };
         quad_list[i] = x;
         QuadIndex y = { 0 + 4 * i, 1 + 4 * i, 2 + 4 * i, 3 + 4 * i, 0 + 4 * i, 2 + 4 * i };
         quad_index_list[i] = y;
     }
 
     GLC(m_context, m_quadVerticesVbo = m_context->createBuffer());
     GLC(m_context, m_quadElementsVbo = m_context->createBuffer());
     GLC(m_context, m_quadListVerticesVbo = m_context->createBuffer());
     GLC(m_context, m_context->bindBuffer(GL_ARRAY_BUFFER, m_quadVerticesVbo));
@@ skipping 17 matching lines @@
     GLC(m_context, m_context->bindBuffer(GL_ARRAY_BUFFER, quadVerticesVbo()));
     GLC(m_context, m_context->vertexAttribPointer(positionAttribLocation(), 3, GL_FLOAT, false, 6 * sizeof(float), 0));
     GLC(m_context, m_context->vertexAttribPointer(texCoordAttribLocation(), 2, GL_FLOAT, false, 6 * sizeof(float), 3 * sizeof(float)));
     GLC(m_context, m_context->vertexAttribPointer(triangleIndexAttribLocation(), 1, GL_FLOAT, false, 6 * sizeof(float), 5 * sizeof(float)));
     GLC(m_context, m_context->enableVertexAttribArray(positionAttribLocation()));
     GLC(m_context, m_context->enableVertexAttribArray(texCoordAttribLocation()));
     GLC(m_context, m_context->enableVertexAttribArray(triangleIndexAttribLocation()));
 }
 
 }  // namespace cc