Implementing glTF 1.0 parser

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 205 matching lines @@
     default:
       LOG(ERROR) << "Shader source requested for unknown shader";
       return "";
   }
 }
 
 }  // namespace
 
 namespace vr_shell {
 
-BaseRenderer::BaseRenderer(ShaderID vertex_id,
-                           ShaderID fragment_id,
-                           bool setup_vertex_buffer = true) {
+BaseRenderer::BaseRenderer(ShaderID vertex_id, ShaderID fragment_id) {
   std::string error;
   GLuint vertex_shader_handle =
       CompileShader(GL_VERTEX_SHADER, GetShaderSource(vertex_id), error);
   CHECK(vertex_shader_handle) << error;
 
   GLuint fragment_shader_handle =
       CompileShader(GL_FRAGMENT_SHADER, GetShaderSource(fragment_id), error);
   CHECK(fragment_shader_handle) << error;
 
   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");
 
-  if (setup_vertex_buffer) {
-    // Generate the vertex buffer
-    glGenBuffersARB(1, &vertex_buffer_);
-    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
-    glBufferData(GL_ARRAY_BUFFER, kTextureQuadVerticesSize,
-                 kTextureQuadVertices, GL_STATIC_DRAW);
-  } else {
-    vertex_buffer_ = 0;
-  }
+  vertex_buffer_ = 0;

[cjgrant, 2017/03/21 16:16:47]

This could now be done in the header file, FWIW.

[acondor_, 2017/03/21 19:31:30]

Done.

 }
 
 BaseRenderer::~BaseRenderer() = default;
 
 void BaseRenderer::PrepareToDraw(GLuint view_proj_matrix_handle,
                                  const gvr::Mat4f& view_proj_matrix) {
   glUseProgram(program_handle_);
 
   // Pass in model view project matrix.
   glUniformMatrix4fv(view_proj_matrix_handle, 1, false,
@@ skipping 10 matching lines @@
   // 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_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
+BaseQuadRenderer::BaseQuadRenderer(ShaderID vertex_id, ShaderID fragment_id)
+    : BaseRenderer(vertex_id, fragment_id) {
+  glGenBuffersARB(1, &vertex_buffer_);
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
+  glBufferData(GL_ARRAY_BUFFER, kTextureQuadVerticesSize, kTextureQuadVertices,
+               GL_STATIC_DRAW);
+}
+
+BaseQuadRenderer::~BaseQuadRenderer() = default;
+
 TexturedQuadRenderer::TexturedQuadRenderer()
-    : BaseRenderer(TEXTURE_QUAD_VERTEX_SHADER, TEXTURE_QUAD_FRAGMENT_SHADER) {
+    : BaseQuadRenderer(TEXTURE_QUAD_VERTEX_SHADER,
+                       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,
@@ skipping 76 matching lines @@
     quad_queue_.pop();
   }
 
   glDisableVertexAttribArray(position_handle_);
   glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 TexturedQuadRenderer::~TexturedQuadRenderer() = default;
 
 WebVrRenderer::WebVrRenderer()
-    : BaseRenderer(WEBVR_VERTEX_SHADER, WEBVR_FRAGMENT_SHADER) {
+    : 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_);
 
@@ skipping 26 matching lines @@
   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()
-    : BaseRenderer(RETICLE_VERTEX_SHADER, RETICLE_FRAGMENT_SHADER) {
+    : BaseQuadRenderer(RETICLE_VERTEX_SHADER, RETICLE_FRAGMENT_SHADER) {
   model_view_proj_matrix_handle_ =
       glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
   color_handle_ = glGetUniformLocation(program_handle_, "color");
   ring_diameter_handle_ =
       glGetUniformLocation(program_handle_, "ring_diameter");
   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");
@@ skipping 16 matching lines @@
 
   glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
 
   glDisableVertexAttribArray(position_handle_);
   glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 ReticleRenderer::~ReticleRenderer() = default;
 
 LaserRenderer::LaserRenderer()
-    : BaseRenderer(LASER_VERTEX_SHADER, LASER_FRAGMENT_SHADER) {
+    : 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");
   fade_point_handle_ = glGetUniformLocation(program_handle_, "fade_point");
   fade_end_handle_ = glGetUniformLocation(program_handle_, "fade_end");
 
   glGenTextures(1, &texture_data_handle_);
   glBindTexture(GL_TEXTURE_2D, texture_data_handle_);
 
@@ skipping 21 matching lines @@
 
   glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
 
   glDisableVertexAttribArray(position_handle_);
   glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 LaserRenderer::~LaserRenderer() = default;
 
 GradientQuadRenderer::GradientQuadRenderer()
-    : BaseRenderer(GRADIENT_QUAD_VERTEX_SHADER, GRADIENT_QUAD_FRAGMENT_SHADER) {
+    : 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,
@@ skipping 13 matching lines @@
 
   glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
 
   glDisableVertexAttribArray(position_handle_);
   glDisableVertexAttribArray(tex_coord_handle_);
 }
 
 GradientQuadRenderer::~GradientQuadRenderer() = default;
 
 GradientGridRenderer::GradientGridRenderer()
-    : BaseRenderer(GRADIENT_QUAD_VERTEX_SHADER,
-                   GRADIENT_QUAD_FRAGMENT_SHADER,
-                   false) {
+    : 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,
@@ skipping 75 matching lines @@
     : textured_quad_renderer_(new TexturedQuadRenderer),
       webvr_renderer_(new WebVrRenderer),
       reticle_renderer_(new ReticleRenderer),
       laser_renderer_(new LaserRenderer),
       gradient_quad_renderer_(new GradientQuadRenderer),
       gradient_grid_renderer_(new GradientGridRenderer) {}
 
 VrShellRenderer::~VrShellRenderer() = default;
 
 }  // namespace vr_shell