[vr] Use ELEMENT_ARRAY_BUFFERS for quads in VrShellRenderer

chrome/browser/android/vr_shell/vr_shell_renderer.cc

 // Copyright 2016 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 "chrome/browser/android/vr_shell/vr_shell_renderer.h"
 
 #include <math.h>
 #include <algorithm>
 #include <string>
 
+#include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace {
 
 static constexpr float kHalfSize = 0.5f;
+
 /* clang-format off */
-static constexpr float kTextureQuadVertices[30] = {
-    //       x           y     z,    u,    v
-    -kHalfSize,  kHalfSize, 0.0f, 0.0f, 0.0f,
-    -kHalfSize, -kHalfSize, 0.0f, 0.0f, 1.0f,
-     kHalfSize,  kHalfSize, 0.0f, 1.0f, 0.0f,
-    -kHalfSize, -kHalfSize, 0.0f, 0.0f, 1.0f,
-     kHalfSize, -kHalfSize, 0.0f, 1.0f, 1.0f,
-     kHalfSize,  kHalfSize, 0.0f, 1.0f, 0.0f };
+static constexpr float kTexturedQuadVertices[8] = {
+    //       x           y
+    -kHalfSize,  kHalfSize,
+    -kHalfSize, -kHalfSize,
+     kHalfSize,  kHalfSize,
+     kHalfSize, -kHalfSize,
+};
+
+static constexpr GLushort kTexturedQuadIndices[6] = { 0, 1, 2, 1, 3, 2 };
 /* clang-format on */
-static constexpr size_t kTextureQuadVerticesSize = sizeof(float) * 30;
-static constexpr size_t kTextureQuadDataStride = sizeof(float) * 5;
-static constexpr int kPositionDataSize = 3;
-static constexpr size_t kPositionDataOffset = 0;
-static constexpr int kTextureCoordinateDataSize = 2;
-static constexpr size_t kTextureCoordinateDataOffset = sizeof(float) * 3;
-// Number of vertices passed to glDrawArrays().
-static constexpr int kVerticesNumber = 6;
+
+static constexpr int kTexturedQuadPositionDataSize = 2;
 
 // Reticle constants
 static constexpr float kRingDiameter = 1.0f;
 static constexpr float kInnerHole = 0.0f;
 static constexpr float kInnerRingEnd = 0.177f;
 static constexpr float kInnerRingThickness = 0.14f;
 static constexpr float kMidRingEnd = 0.177f;
 static constexpr float kMidRingOpacity = 0.22f;
 static constexpr float kReticleColor[] = {1.0f, 1.0f, 1.0f, 1.0f};
 
@@ skipping 22 matching lines @@
 
 #define SHADER(Src) #Src
 #define OEIE_SHADER(Src) "#extension GL_OES_EGL_image_external : require\n" #Src
 #define VOID_OFFSET(x) reinterpret_cast<void*>(x)
 
 const char* GetShaderSource(vr_shell::ShaderID shader) {
   switch (shader) {
     case vr_shell::ShaderID::EXTERNAL_TEXTURED_QUAD_VERTEX_SHADER:
     case vr_shell::ShaderID::RETICLE_VERTEX_SHADER:
     case vr_shell::ShaderID::LASER_VERTEX_SHADER:
-    case vr_shell::ShaderID::CONTROLLER_VERTEX_SHADER:
     case vr_shell::ShaderID::TEXTURED_QUAD_VERTEX_SHADER:
       return SHADER(
           /* clang-format off */
           precision mediump float;
+          uniform mat4 u_ModelViewProjMatrix;
+          attribute vec4 a_Position;
+          varying vec2 v_TexCoordinate;
+
+          void main() {
+            v_TexCoordinate = vec2(0.5 + a_Position[0], 0.5 - a_Position[1]);
+            gl_Position = u_ModelViewProjMatrix * a_Position;
+          }
+          /* clang-format on */);
+    case vr_shell::ShaderID::CONTROLLER_VERTEX_SHADER:
+      return SHADER(
+          /* clang-format off */
+          precision mediump float;
           uniform mat4 u_ModelViewProjMatrix;
           attribute vec4 a_Position;
           attribute vec2 a_TexCoordinate;
           varying vec2 v_TexCoordinate;
 
           void main() {
             v_TexCoordinate = a_TexCoordinate;
             gl_Position = u_ModelViewProjMatrix * a_Position;
           }
           /* clang-format on */);
@@ skipping 224 matching lines @@
 
   program_handle_ =
       CreateAndLinkProgram(vertex_shader_handle, fragment_shader_handle, error);
   CHECK(program_handle_) << error;
 
   // Once the program is linked the shader objects are no longer needed
   glDeleteShader(vertex_shader_handle);
   glDeleteShader(fragment_shader_handle);
 
   position_handle_ = glGetAttribLocation(program_handle_, "a_Position");
-  tex_coord_handle_ = glGetAttribLocation(program_handle_, "a_TexCoordinate");
 }
 
 BaseRenderer::~BaseRenderer() = default;
 
 BaseQuadRenderer::BaseQuadRenderer(ShaderID vertex_id, ShaderID fragment_id)
     : BaseRenderer(vertex_id, fragment_id) {}
 
-GLuint BaseQuadRenderer::vertex_buffer_ = 0;
-
 BaseQuadRenderer::~BaseQuadRenderer() = default;
 
 void BaseQuadRenderer::PrepareToDraw(GLuint view_proj_matrix_handle,
                                      const gfx::Transform& view_proj_matrix) {
   glUseProgram(program_handle_);
 
   // Pass in model view project matrix.
   glUniformMatrix4fv(view_proj_matrix_handle, 1, false,
                      MatrixToGLArray(view_proj_matrix).data());
 
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
 
   // Set up position attribute.
-  glVertexAttribPointer(position_handle_, kPositionDataSize, GL_FLOAT, false,
-                        kTextureQuadDataStride,
-                        VOID_OFFSET(kPositionDataOffset));
+  glVertexAttribPointer(position_handle_, kTexturedQuadPositionDataSize,
+                        GL_FLOAT, false, 0, 0);
   glEnableVertexAttribArray(position_handle_);
 
-  // Set up texture coordinate attribute.
-  glVertexAttribPointer(tex_coord_handle_, kTextureCoordinateDataSize, GL_FLOAT,
-                        false, kTextureQuadDataStride,
-                        VOID_OFFSET(kTextureCoordinateDataOffset));
-  glEnableVertexAttribArray(tex_coord_handle_);
-
   glEnable(GL_BLEND);
   glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 }
 
+GLuint BaseQuadRenderer::vertex_buffer_ = 0;
+GLuint BaseQuadRenderer::index_buffer_ = 0;
+
 void BaseQuadRenderer::SetVertexBuffer() {
-  glGenBuffersARB(1, &vertex_buffer_);
+  GLuint buffers[2];
+  glGenBuffersARB(2, buffers);
+  vertex_buffer_ = buffers[0];
+  index_buffer_ = buffers[1];
+
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
-  glBufferData(GL_ARRAY_BUFFER, kTextureQuadVerticesSize, kTextureQuadVertices,
-               GL_STATIC_DRAW);
+  glBufferData(GL_ARRAY_BUFFER,
+               arraysize(kTexturedQuadVertices) * sizeof(float),
+               kTexturedQuadVertices, GL_STATIC_DRAW);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER,
+               arraysize(kTexturedQuadIndices) * sizeof(GLushort),
+               kTexturedQuadIndices, GL_STATIC_DRAW);
 }
 
 ExternalTexturedQuadRenderer::ExternalTexturedQuadRenderer()
     : BaseQuadRenderer(EXTERNAL_TEXTURED_QUAD_VERTEX_SHADER,
                        EXTERNAL_TEXTURED_QUAD_FRAGMENT_SHADER) {
   model_view_proj_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
   tex_uniform_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
   copy_rect_uniform_handle_ =
       glGetUniformLocation(program_handle_, "u_CopyRect");
@@ skipping 12 matching lines @@
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 
   glUniform1i(tex_uniform_handle_, 0);
   glUniform4fv(copy_rect_uniform_handle_, 1,
                reinterpret_cast<const float*>(&copy_rect));
   glUniform1f(opacity_handle_, opacity);
 
-  glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
+  glDrawElements(GL_TRIANGLES, arraysize(kTexturedQuadIndices),
+                 GL_UNSIGNED_SHORT, 0);
 
   glDisableVertexAttribArray(position_handle_);
-  glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 ExternalTexturedQuadRenderer::~ExternalTexturedQuadRenderer() = default;
 
 TexturedQuadRenderer::TexturedQuadRenderer()
     : BaseQuadRenderer(TEXTURED_QUAD_VERTEX_SHADER,
                        TEXTURED_QUAD_FRAGMENT_SHADER) {
   model_view_proj_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
   tex_uniform_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
@@ skipping 21 matching lines @@
 
   int last_texture = 0;
   float last_opacity = -1.0f;
 
   // Set up GL state that doesn't change between draw calls.
   glUseProgram(program_handle_);
 
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
 
   // Set up position attribute.
-  glVertexAttribPointer(position_handle_, kPositionDataSize, GL_FLOAT, false,
-                        kTextureQuadDataStride,
-                        VOID_OFFSET(kPositionDataOffset));
+  glVertexAttribPointer(position_handle_, kTexturedQuadPositionDataSize,
+                        GL_FLOAT, false, 0, 0);
   glEnableVertexAttribArray(position_handle_);
 
-  // Set up texture coordinate attribute.
-  glVertexAttribPointer(tex_coord_handle_, kTextureCoordinateDataSize, GL_FLOAT,
-                        false, kTextureQuadDataStride,
-                        VOID_OFFSET(kTextureCoordinateDataOffset));
-  glEnableVertexAttribArray(tex_coord_handle_);
-
   glEnable(GL_BLEND);
   glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
   // Link texture data with texture unit.
   glActiveTexture(GL_TEXTURE0);
   glUniform1i(tex_uniform_handle_, 0);
 
   // TODO(bajones): This should eventually be changed to use instancing so that
   // the entire queue can be processed in one draw call. For now this still
   // significantly reduces the amount of state changes made per draw.
@@ skipping 12 matching lines @@
     }
 
     // Pass in model view project matrix.
     glUniformMatrix4fv(model_view_proj_matrix_handle_, 1, false,
                        MatrixToGLArray(quad.view_proj_matrix).data());
 
     // Pass in the copy rect.
     glUniform4fv(copy_rect_uniform_handle_, 1,
                  reinterpret_cast<const float*>(&quad.copy_rect));
 
-    glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
+    glDrawElements(GL_TRIANGLES, arraysize(kTexturedQuadIndices),
+                   GL_UNSIGNED_SHORT, 0);
 
     quad_queue_.pop();
   }
 
   glDisableVertexAttribArray(position_handle_);
-  glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 TexturedQuadRenderer::~TexturedQuadRenderer() = default;
 
 WebVrRenderer::WebVrRenderer()
     : BaseQuadRenderer(WEBVR_VERTEX_SHADER, WEBVR_FRAGMENT_SHADER) {
   tex_uniform_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
 }
 
 // Draw the stereo WebVR frame
 void WebVrRenderer::Draw(int texture_handle) {
   glUseProgram(program_handle_);
 
   // Bind vertex attributes
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
 
   // Set up position attribute.
-  glVertexAttribPointer(position_handle_, kPositionDataSize, GL_FLOAT, false,
-                        kTextureQuadDataStride,
-                        VOID_OFFSET(kPositionDataOffset));
+  glVertexAttribPointer(position_handle_, kTexturedQuadPositionDataSize,
+                        GL_FLOAT, false, 0, 0);
   glEnableVertexAttribArray(position_handle_);
 
-  // Set up texture coordinate attribute.
-  glVertexAttribPointer(tex_coord_handle_, kTextureCoordinateDataSize, GL_FLOAT,
-                        false, kTextureQuadDataStride,
-                        VOID_OFFSET(kTextureCoordinateDataOffset));
-  glEnableVertexAttribArray(tex_coord_handle_);
-
   // Bind texture. This is a 1:1 pixel copy since the source surface
   // and renderbuffer destination size are resized to match, so use
   // GL_NEAREST.
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_handle);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
   glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
   glUniform1i(tex_uniform_handle_, 0);
 
   // Blit texture to buffer
-  glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
+  glDrawElements(GL_TRIANGLES, arraysize(kTexturedQuadIndices),
+                 GL_UNSIGNED_SHORT, 0);
 
   glDisableVertexAttribArray(position_handle_);
-  glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 // Note that we don't explicitly delete gl objects here, they're deleted
 // automatically when we call ShutdownGL, and deleting them here leads to
 // segfaults.
 WebVrRenderer::~WebVrRenderer() = default;
 
 ReticleRenderer::ReticleRenderer()
     : BaseQuadRenderer(RETICLE_VERTEX_SHADER, RETICLE_FRAGMENT_SHADER) {
   model_view_proj_matrix_handle_ =
@@ skipping 16 matching lines @@
 
   glUniform4f(color_handle_, kReticleColor[0], kReticleColor[1],
               kReticleColor[2], kReticleColor[3]);
   glUniform1f(ring_diameter_handle_, kRingDiameter);
   glUniform1f(inner_hole_handle_, kInnerHole);
   glUniform1f(inner_ring_end_handle_, kInnerRingEnd);
   glUniform1f(inner_ring_thickness_handle_, kInnerRingThickness);
   glUniform1f(mid_ring_end_handle_, kMidRingEnd);
   glUniform1f(mid_ring_opacity_handle_, kMidRingOpacity);
 
-  glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
+  glDrawElements(GL_TRIANGLES, arraysize(kTexturedQuadIndices),
+                 GL_UNSIGNED_SHORT, 0);
 
   glDisableVertexAttribArray(position_handle_);
-  glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 ReticleRenderer::~ReticleRenderer() = default;
 
 LaserRenderer::LaserRenderer()
     : BaseQuadRenderer(LASER_VERTEX_SHADER, LASER_FRAGMENT_SHADER) {
   model_view_proj_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
   texture_unit_handle_ = glGetUniformLocation(program_handle_, "texture_unit");
   color_handle_ = glGetUniformLocation(program_handle_, "color");
@@ skipping 21 matching lines @@
   glActiveTexture(GL_TEXTURE0);
   glBindTexture(GL_TEXTURE_2D, texture_data_handle_);
 
   glUniform1i(texture_unit_handle_, 0);
   glUniform4f(color_handle_, kLaserColor[0], kLaserColor[1], kLaserColor[2],
               kLaserColor[3]);
   glUniform1f(fade_point_handle_, kFadePoint);
   glUniform1f(fade_end_handle_, kFadeEnd);
   glUniform1f(opacity_handle_, opacity);
 
-  glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
+  glDrawElements(GL_TRIANGLES, arraysize(kTexturedQuadIndices),
+                 GL_UNSIGNED_SHORT, 0);
 
   glDisableVertexAttribArray(position_handle_);
-  glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 LaserRenderer::~LaserRenderer() = default;
 
 ControllerRenderer::ControllerRenderer()
     : BaseRenderer(CONTROLLER_VERTEX_SHADER, CONTROLLER_FRAGMENT_SHADER),
       texture_handles_(VrControllerModel::STATE_COUNT) {
   model_view_proj_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
+  tex_coord_handle_ = glGetAttribLocation(program_handle_, "a_TexCoordinate");
   tex_uniform_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
   opacity_handle_ = glGetUniformLocation(program_handle_, "u_Opacity");
 }
 
 ControllerRenderer::~ControllerRenderer() = default;
 
 void ControllerRenderer::SetUp(std::unique_ptr<VrControllerModel> model) {
   TRACE_EVENT0("gpu", "ControllerRenderer::SetUp");
   glGenBuffersARB(1, &indices_buffer_);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_buffer_);
@@ skipping 93 matching lines @@
   PrepareToDraw(model_view_proj_matrix_handle_, view_proj_matrix);
 
   // Tell shader the grid size so that it can calculate the fading.
   glUniform1f(scene_radius_handle_, kHalfSize);
 
   // Set the edge color to the fog color so that it seems to fade out.
   SetColorUniform(edge_color_handle_, edge_color);
   SetColorUniform(center_color_handle_, center_color);
   glUniform1f(opacity_handle_, opacity);
 
-  glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
+  glDrawElements(GL_TRIANGLES, arraysize(kTexturedQuadIndices),
+                 GL_UNSIGNED_SHORT, 0);
 
   glDisableVertexAttribArray(position_handle_);
-  glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 GradientQuadRenderer::~GradientQuadRenderer() = default;
 
 GradientGridRenderer::GradientGridRenderer()
     : BaseQuadRenderer(GRADIENT_QUAD_VERTEX_SHADER,
                        GRADIENT_GRID_FRAGMENT_SHADER) {
   model_view_proj_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
   scene_radius_handle_ = glGetUniformLocation(program_handle_, "u_SceneRadius");
@@ skipping 15 matching lines @@
   // Tell shader the grid size so that it can calculate the fading.
   glUniform1f(scene_radius_handle_, kHalfSize);
   glUniform1i(lines_count_handle_, gridline_count);
 
   // Set the edge color to the fog color so that it seems to fade out.
   SetColorUniform(edge_color_handle_, edge_color);
   SetColorUniform(center_color_handle_, center_color);
   SetColorUniform(grid_color_handle_, grid_color);
   glUniform1f(opacity_handle_, opacity);
 
-  glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_buffer_);
+  glDrawElements(GL_TRIANGLES, arraysize(kTexturedQuadIndices),
+                 GL_UNSIGNED_SHORT, 0);
 
   glDisableVertexAttribArray(position_handle_);
-  glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 GradientGridRenderer::~GradientGridRenderer() = default;
 
 VrShellRenderer::VrShellRenderer()
     : external_textured_quad_renderer_(
           base::MakeUnique<ExternalTexturedQuadRenderer>()),
       textured_quad_renderer_(base::MakeUnique<TexturedQuadRenderer>()),
       webvr_renderer_(base::MakeUnique<WebVrRenderer>()),
       reticle_renderer_(base::MakeUnique<ReticleRenderer>()),
@@ skipping 60 matching lines @@
 GradientGridRenderer* VrShellRenderer::GetGradientGridRenderer() {
   Flush();
   return gradient_grid_renderer_.get();
 }
 
 void VrShellRenderer::Flush() {
   textured_quad_renderer_->Flush();
 }
 
 }  // namespace vr_shell