Refactoring how WebVR eye bounds are handled

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 "chrome/browser/android/vr_shell/vr_gl_util.h"
 
 namespace {
 
 #define RECTANGULAR_TEXTURE_BUFFER(left, right, bottom, top) \
   { left, bottom, left, top, right, bottom, left, top, right, top, right, \
     bottom }
 
 static constexpr float kHalfHeight = 0.5f;
 static constexpr float kHalfWidth = 0.5f;
 static constexpr float kTextureQuadPosition[18] = {
     -kHalfWidth, kHalfHeight,  0.0f, -kHalfWidth, -kHalfHeight, 0.0f,
     kHalfWidth,  kHalfHeight,  0.0f, -kHalfWidth, -kHalfHeight, 0.0f,
     kHalfWidth,  -kHalfHeight, 0.0f, kHalfWidth,  kHalfHeight,  0.0f};
 static constexpr int kPositionDataSize = 3;
 // Number of vertices passed to glDrawArrays().
 static constexpr int kVerticesNumber = 6;
 
 static constexpr float kTexturedQuadTextureCoordinates[12] =
     RECTANGULAR_TEXTURE_BUFFER(0.0f, 1.0f, 0.0f, 1.0f);
 
 static constexpr int kTextureCoordinateDataSize = 2;
 
-static constexpr float kWebVrVertices[32] = {
+static constexpr float kWebVrVertices[16] = {
   //   x     y    u,   v
-    -1.f,  1.f, 0.f, 0.f, // Left Eye
+    -1.f,  1.f, 0.f, 0.f,
     -1.f, -1.f, 0.f, 1.f,
-     0.f, -1.f, 1.f, 1.f,
-     0.f,  1.f, 1.f, 0.f,
-
-     0.f,  1.f, 0.f, 0.f, // Right Eye
-     0.f, -1.f, 0.f, 1.f,
      1.f, -1.f, 1.f, 1.f,
      1.f,  1.f, 1.f, 0.f };
-static constexpr int kWebVrVerticesSize = sizeof(float) * 32;
+static constexpr int kWebVrVerticesSize = sizeof(float) * 16;
 
 // 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 44 matching lines @@
           uniform vec4 u_CopyRect;  // rectangle
           varying vec2 v_TexCoordinate;
           void main() {
             vec2 scaledTex =
                 vec2(u_CopyRect[0] + v_TexCoordinate.x * u_CopyRect[2],
                      u_CopyRect[1] + v_TexCoordinate.y * u_CopyRect[3]);
             gl_FragColor = texture2D(u_Texture, scaledTex);
           });
     case vr_shell::ShaderID::WEBVR_VERTEX_SHADER:
       return SHADER(
-          attribute vec2 a_Position;
-          attribute vec2 a_TexCoordinate;
-          uniform vec4 u_SrcRect;
+          attribute vec4 a_Position;
           varying vec2 v_TexCoordinate;
 
           void main() {
-            v_TexCoordinate = u_SrcRect.xy + (a_TexCoordinate * u_SrcRect.zw);
-            gl_Position = vec4(a_Position, 0.0, 1.0);
+            // Pack the texcoord into the position to avoid state changes.
+            v_TexCoordinate = a_Position.zw;
+            gl_Position = vec4(a_Position.xy, 0.0, 1.0);
           });
     case vr_shell::ShaderID::WEBVR_FRAGMENT_SHADER:
       return OEIE_SHADER(
           precision highp float;
           uniform samplerExternalOES u_Texture;
           varying vec2 v_TexCoordinate;
 
           void main() {
             gl_FragColor = texture2D(u_Texture, v_TexCoordinate);
           });
@@ skipping 128 matching lines @@
   glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
 
   glDisableVertexAttribArray(position_handle_);
   glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 TexturedQuadRenderer::~TexturedQuadRenderer() = default;
 
 WebVrRenderer::WebVrRenderer() :
     BaseRenderer(WEBVR_VERTEX_SHADER, WEBVR_FRAGMENT_SHADER) {
-  left_bounds_ = { 0.0f, 0.0f, 0.5f, 1.0f };
-  right_bounds_ = { 0.5f, 0.0f, 0.5f, 1.0f };
-
   tex_uniform_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
-  src_rect_uniform_handle_ = glGetUniformLocation(program_handle_, "u_SrcRect");
 
   // TODO(bajones): Figure out why this need to be restored.
   GLint old_buffer;
   glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &old_buffer);
 
   glGenBuffersARB(1, &vertex_buffer_);
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
   glBufferData(GL_ARRAY_BUFFER, kWebVrVerticesSize, kWebVrVertices,
       GL_STATIC_DRAW);
 
   glBindBuffer(GL_ARRAY_BUFFER, old_buffer);
 }
 
 // Draw the stereo WebVR frame
 void WebVrRenderer::Draw(int texture_handle) {
   // TODO(bajones): Figure out why this need to be restored.
   GLint old_buffer;
   glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &old_buffer);
 
   glUseProgram(program_handle_);
 
   // Bind vertex attributes
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
 
   glEnableVertexAttribArray(position_handle_);
-  glEnableVertexAttribArray(tex_coord_handle_);
 
-  glVertexAttribPointer(position_handle_, POSITION_ELEMENTS, GL_FLOAT, false,
-      VERTEX_STRIDE, VOID_OFFSET(POSITION_OFFSET));
-  glVertexAttribPointer(tex_coord_handle_, TEXCOORD_ELEMENTS, GL_FLOAT, false,
-      VERTEX_STRIDE, VOID_OFFSET(TEXCOORD_OFFSET));
+  glVertexAttribPointer(position_handle_, VERTEX_ELEMENTS, GL_FLOAT, false,
+      VERTEX_STRIDE, VOID_OFFSET(VERTEX_OFFSET));
 
   // Bind texture. Ideally this should be a 1:1 pixel copy. (Or even more
   // ideally, a zero copy reuse of the texture.) For now, we're using an
   // undersized render target for WebVR, so GL_LINEAR makes it look slightly
   // less chunky. TODO(klausw): change this to GL_NEAREST once we're doing
   // a 1:1 copy since that should be more efficient.
   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_LINEAR);
-  glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  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);
 
-  // TODO(bajones): Should be able handle both eyes in a single draw call.
-  // Left eye
-  glUniform4fv(src_rect_uniform_handle_, 1, (float*)(&left_bounds_));
+  // Blit texture to buffer
   glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
 
-  // Right eye
-  glUniform4fv(src_rect_uniform_handle_, 1, (float*)(&right_bounds_));
-  glDrawArrays(GL_TRIANGLE_FAN, 4, 4);
-
   glDisableVertexAttribArray(position_handle_);
-  glDisableVertexAttribArray(tex_coord_handle_);
 
   glBindBuffer(GL_ARRAY_BUFFER, old_buffer);
 }
 
-void WebVrRenderer::UpdateTextureBounds(int eye, const gvr::Rectf& bounds) {
-  if (eye == 0) {
-    left_bounds_ = bounds;
-  } else if (eye == 1) {
-    right_bounds_ = bounds;
-  }
-}
-
 // Note that we don't explicitly delete gl objects here, they're deleted
 // automatically when we call ClearGLBindings, and deleting them here leads to
 // segfaults.
 WebVrRenderer::~WebVrRenderer() = default;
 
 ReticleRenderer::ReticleRenderer()
     : BaseRenderer(RETICLE_VERTEX_SHADER, RETICLE_FRAGMENT_SHADER) {
   combined_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_CombinedMatrix");
   color_handle_ = glGetUniformLocation(program_handle_, "color");
@@ skipping 103 matching lines @@
 
 VrShellRenderer::VrShellRenderer()
     : textured_quad_renderer_(new TexturedQuadRenderer),
       webvr_renderer_(new WebVrRenderer),
       reticle_renderer_(new ReticleRenderer),
       laser_renderer_(new LaserRenderer) {}
 
 VrShellRenderer::~VrShellRenderer() = default;
 
 }  // namespace vr_shell