Texture Draw Calls Coalescing

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)
 {
     // Vertex positions and texture coordinates for the 4 corners of a 1x1 quad.
     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 };
-    uint16_t indices[] = { 0, 1, 2, 0, 2, 3, // The two triangles that make up the layer quad.
-                           0, 1, 2, 3}; // A line path for drawing the layer border.
+
+    // Vertex positions, texture coordinates and skinning values for the 4 corners of 8 1x1 quads.

[shawnsingh, 2012/11/28 19:44:16]

I think the word skinning might confuse/complicate things unnecessarily.  Would
it be just as correct to say "triangle index" here, like you did in other
places?

[whunt, 2012/11/28 22:01:15]

Done, I made the language more uniform and avoided the term skinning.

On 2012/11/28 19:44:16, shawnsingh wrote:

+    float vertexListData[] = {

[shawnsingh, 2012/11/28 19:44:16]

If possible, we should make this an array of structs, where the struct is:

struct vertexInfo {
  float vertex[3];
  float texCoords[2];
  int triangleIndex;
}

And then on the vertexAttribPointer for the index below, we should give GL_INT
(or whatever it is correctly) instead of GL_FLOAT.

[whunt, 2012/11/28 22:01:15]

Done.

On 2012/11/28 19:44:16, shawnsingh wrote:

+      -0.5f,  0.5f, 0.0f, 0.0f, 1.0f, 0.0f,
+      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 0.0f,
+       0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f,
+       0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 0.0f,
+      -0.5f,  0.5f, 0.0f, 0.0f, 1.0f, 1.0f,

[jamesr, 2012/11/28 00:00:37]

Can we generate this data with a loop instead of lots of copy-pasted lines? 
That's a bit easier to verify and will be easier to extend

[whunt, 2012/11/28 22:01:15]

Sure, Done.

On 2012/11/28 00:00:37, jamesr wrote:

+      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 1.0f,
+       0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f,
+       0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 1.0f,
+      -0.5f,  0.5f, 0.0f, 0.0f, 1.0f, 2.0f,
+      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 2.0f,
+       0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 2.0f,
+       0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 2.0f,
+      -0.5f,  0.5f, 0.0f, 0.0f, 1.0f, 3.0f,
+      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 3.0f,
+       0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 3.0f,
+       0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 3.0f,
+      -0.5f,  0.5f, 0.0f, 0.0f, 1.0f, 4.0f,
+      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 4.0f,
+       0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 4.0f,
+       0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 4.0f,
+      -0.5f,  0.5f, 0.0f, 0.0f, 1.0f, 5.0f,
+      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 5.0f,
+       0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 5.0f,
+       0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 5.0f,
+      -0.5f,  0.5f, 0.0f, 0.0f, 1.0f, 6.0f,
+      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 6.0f,
+       0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 6.0f,
+       0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 6.0f,
+      -0.5f,  0.5f, 0.0f, 0.0f, 1.0f, 7.0f,
+      -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, 7.0f,
+       0.5f, -0.5f, 0.0f, 1.0f, 0.0f, 7.0f,
+       0.5f,  0.5f, 0.0f, 1.0f, 1.0f, 7.0f,
+    };
+
+    // Index buffer for up to 8 quads.
+    uint16_t indices[] = {
+       0,  1,  2,
+       3,  0,  2,
+       4,  5,  6,

[jamesr, 2012/11/28 00:00:37]

Same here - each 6-tuple is just the previous one incremented by 4, so should be
easy to programatically generate

[whunt, 2012/11/28 22:01:15]

Yes, but this one is slightly more subtle.  You probably didn't notice that the
first set of quads is slightly different than the rest.  All sets can be made
the same.

The reason for the difference is that the first pair of quads (0, 1, 2) (3, 0,
2) also doubles as the first quad of lines when drawing a line loop (0, 1, 2,
3).  That can be maintained during automatic generation.

On 2012/11/28 00:00:37, jamesr wrote:

+       4,  6,  7,
+       8,  9, 10,
+       8, 10, 11,
+      12, 13, 14,
+      12, 14, 15,
+      16, 17, 18,
+      16, 18, 19,
+      20, 21, 22,
+      20, 22, 23,
+      24, 25, 26,
+      24, 26, 27,
+      28, 29, 30,
+      28, 30, 31,
+    };
 
     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));
-    GLC(m_context, m_context->bufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW));
+    GLC(m_context, m_context->bufferData(GL_ARRAY_BUFFER, sizeof(vertexListData), vertexListData, GL_STATIC_DRAW));
     GLC(m_context, m_context->bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_quadElementsVbo));
     GLC(m_context, m_context->bufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW));
 
     m_initialized = true;
 }
 
 GeometryBinding::~GeometryBinding()
 {
     GLC(m_context, m_context->deleteBuffer(m_quadVerticesVbo));
     GLC(m_context, m_context->deleteBuffer(m_quadElementsVbo));
 }
 
 void GeometryBinding::prepareForDraw()
 {
+    GLC(m_context, m_context->bindBuffer(GL_ELEMENT_ARRAY_BUFFER, quadElementsVbo()));
+
     GLC(m_context, m_context->bindBuffer(GL_ARRAY_BUFFER, quadVerticesVbo()));
-    GLC(m_context, m_context->bindBuffer(GL_ELEMENT_ARRAY_BUFFER, quadElementsVbo()));
-    unsigned offset = 0;
-    GLC(m_context, m_context->vertexAttribPointer(positionAttribLocation(), 3, GL_FLOAT, false, 5 * sizeof(float), offset));
-    offset += 3 * sizeof(float);
-    GLC(m_context, m_context->vertexAttribPointer(texCoordAttribLocation(), 2, GL_FLOAT, false, 5 * sizeof(float), offset));
+    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), 12));

[shawnsingh, 2012/11/28 19:44:16]

This "12" should probably remain 3 * sizeof(float)

+    GLC(m_context, m_context->vertexAttribPointer(triangleIndexAttribLocation(), 1, GL_FLOAT, false, 6 * sizeof(float), 20));

[shawnsingh, 2012/11/28 19:44:16]

And this "20" should probably remain 5 * sizeof(float)

if we can use array-of-structs, then this should also be GL_INT instead of
GL_FLOAT

     GLC(m_context, m_context->enableVertexAttribArray(positionAttribLocation()));
     GLC(m_context, m_context->enableVertexAttribArray(texCoordAttribLocation()));
+    GLC(m_context, m_context->enableVertexAttribArray(triangleIndexAttribLocation()));
 }
 
 }  // namespace cc