Refactor VR math off of GVR types, onto gfx types where possible.

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>
 
@@ skipping 249 matching lines @@
 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 gvr::Mat4f& view_proj_matrix) {
+                                     const vr::Mat4f& 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,
@@ skipping 23 matching lines @@
                        TEXTURE_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");
   opacity_handle_ = glGetUniformLocation(program_handle_, "opacity");
 }
 
 void TexturedQuadRenderer::AddQuad(int texture_data_handle,
-                                   const gvr::Mat4f& view_proj_matrix,
-                                   const Rectf& copy_rect,
+                                   const vr::Mat4f& view_proj_matrix,
+                                   const gfx::RectF& copy_rect,
                                    float opacity) {
   TexturedQuad quad;
   quad.texture_data_handle = texture_data_handle;
   quad.view_proj_matrix = view_proj_matrix;
-  quad.copy_rect = copy_rect;
+  quad.copy_rect = {copy_rect.x(), copy_rect.y(), copy_rect.width(),
+                    copy_rect.height()};
   quad.opacity = opacity;
   quad_queue_.push(quad);
 }
 
 void TexturedQuadRenderer::Flush() {
   if (quad_queue_.empty())
     return;
 
   int last_texture = 0;
   float last_opacity = -1.0f;
@@ skipping 123 matching lines @@
   inner_hole_handle_ = glGetUniformLocation(program_handle_, "inner_hole");
   inner_ring_end_handle_ =
       glGetUniformLocation(program_handle_, "inner_ring_end");
   inner_ring_thickness_handle_ =
       glGetUniformLocation(program_handle_, "inner_ring_thickness");
   mid_ring_end_handle_ = glGetUniformLocation(program_handle_, "mid_ring_end");
   mid_ring_opacity_handle_ =
       glGetUniformLocation(program_handle_, "mid_ring_opacity");
 }
 
-void ReticleRenderer::Draw(const gvr::Mat4f& view_proj_matrix) {
+void ReticleRenderer::Draw(const vr::Mat4f& view_proj_matrix) {
   PrepareToDraw(model_view_proj_matrix_handle_, view_proj_matrix);
 
   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);
@@ skipping 20 matching lines @@
 
   glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, kLaserDataWidth, kLaserDataHeight, 0,
                GL_RGBA, GL_UNSIGNED_BYTE, kLaserData);
 
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
   glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 }
 
-void LaserRenderer::Draw(const gvr::Mat4f& view_proj_matrix) {
+void LaserRenderer::Draw(const vr::Mat4f& view_proj_matrix) {
   PrepareToDraw(model_view_proj_matrix_handle_, view_proj_matrix);
 
   // Link texture data with texture unit.
   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);
@@ skipping 54 matching lines @@
 
   draw_mode_ = model->DrawMode();
   accessor = model->IndicesAccessor();
   indices_count_ = accessor->count;
   indices_type_ = accessor->component_type;
   indices_offset_ = VOID_OFFSET(accessor->byte_offset);
   setup_ = true;
 }
 
 void ControllerRenderer::Draw(VrControllerModel::State state,
-                              const gvr::Mat4f& view_proj_matrix) {
+                              const vr::Mat4f& view_proj_matrix) {
   glUseProgram(program_handle_);
 
   glUniformMatrix4fv(model_view_proj_matrix_handle_, 1, false,
                      MatrixToGLArray(view_proj_matrix).data());
 
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
 
   glVertexAttribPointer(position_handle_, position_components_, position_type_,
                         GL_FALSE, position_stride_, position_offset_);
   glEnableVertexAttribArray(position_handle_);
@@ skipping 19 matching lines @@
     : BaseQuadRenderer(GRADIENT_QUAD_VERTEX_SHADER,
                        GRADIENT_QUAD_FRAGMENT_SHADER) {
   model_view_proj_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
   scene_radius_handle_ = glGetUniformLocation(program_handle_, "u_SceneRadius");
   center_color_handle_ = glGetUniformLocation(program_handle_, "u_CenterColor");
   edge_color_handle_ = glGetUniformLocation(program_handle_, "u_EdgeColor");
   opacity_handle_ = glGetUniformLocation(program_handle_, "u_Opacity");
 }
 
-void GradientQuadRenderer::Draw(const gvr::Mat4f& view_proj_matrix,
-                                const Colorf& edge_color,
-                                const Colorf& center_color,
+void GradientQuadRenderer::Draw(const vr::Mat4f& view_proj_matrix,
+                                const vr::Colorf& edge_color,
+                                const vr::Colorf& center_color,
                                 float opacity) {
   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.
   glUniform4f(edge_color_handle_, edge_color.r, edge_color.g, edge_color.b,
               edge_color.a);
   glUniform4f(center_color_handle_, center_color.r, center_color.g,
@@ skipping 11 matching lines @@
 GradientGridRenderer::GradientGridRenderer()
     : BaseRenderer(GRADIENT_QUAD_VERTEX_SHADER, GRADIENT_QUAD_FRAGMENT_SHADER) {
   model_view_proj_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
   scene_radius_handle_ = glGetUniformLocation(program_handle_, "u_SceneRadius");
   center_color_handle_ = glGetUniformLocation(program_handle_, "u_CenterColor");
   edge_color_handle_ = glGetUniformLocation(program_handle_, "u_EdgeColor");
   opacity_handle_ = glGetUniformLocation(program_handle_, "u_Opacity");
 }
 
-void GradientGridRenderer::Draw(const gvr::Mat4f& view_proj_matrix,
-                                const Colorf& edge_color,
-                                const Colorf& center_color,
+void GradientGridRenderer::Draw(const vr::Mat4f& view_proj_matrix,
+                                const vr::Colorf& edge_color,
+                                const vr::Colorf& center_color,
                                 int gridline_count,
                                 float opacity) {
   // In case the tile number changed we have to regenerate the grid lines.
   if (grid_lines_.size() != static_cast<size_t>(2 * (gridline_count + 1))) {
     MakeGridLines(gridline_count);
   }
 
   glUseProgram(program_handle_);
 
   // Pass in model view project matrix.
@@ skipping 67 matching lines @@
       laser_renderer_(base::MakeUnique<LaserRenderer>()),
       controller_renderer_(base::MakeUnique<ControllerRenderer>()),
       gradient_quad_renderer_(base::MakeUnique<GradientQuadRenderer>()),
       gradient_grid_renderer_(base::MakeUnique<GradientGridRenderer>()) {
   BaseQuadRenderer::SetVertexBuffer();
 }
 
 VrShellRenderer::~VrShellRenderer() = default;
 
 }  // namespace vr_shell