Rendering Daydream controller in a fixed position.

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/memory/ptr_util.h"
 #include "chrome/browser/android/vr_shell/vr_gl_util.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,
@@ skipping 45 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::TEXTURE_QUAD_VERTEX_SHADER:
     case vr_shell::ShaderID::RETICLE_VERTEX_SHADER:
     case vr_shell::ShaderID::LASER_VERTEX_SHADER:
+    case vr_shell::ShaderID::CONTROLLER_VERTEX_SHADER:
       return SHADER(
           /* clang-format off */
           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;
@@ skipping 120 matching lines @@
           uniform vec4 u_EdgeColor;
           uniform mediump float u_Opacity;
 
           void main() {
             float edgeColorWeight = clamp(length(v_GridPosition), 0.0, 1.0);
             float centerColorWeight = 1.0 - edgeColorWeight;
             gl_FragColor = (u_CenterColor * centerColorWeight +
                 u_EdgeColor * edgeColorWeight) * vec4(1.0, 1.0, 1.0, u_Opacity);
           }
           /* clang-format on */);
+    case vr_shell::ShaderID::CONTROLLER_FRAGMENT_SHADER:
+      return SHADER(
+          /* clang-format off */
+          uniform sampler2D u_texture;
+          varying vec2 v_TexCoordinate;
+
+          void main() {
+            gl_FragColor = texture2D(u_texture, v_TexCoordinate);
+          }
+          /* clang-format on */);
     default:
       LOG(ERROR) << "Shader source requested for unknown shader";
       return "";
   }
 }
 
 }  // namespace
 
 namespace vr_shell {
 
@@ skipping 14 matching lines @@
   // 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;
 
-void BaseRenderer::PrepareToDraw(GLuint view_proj_matrix_handle,
-                                 const gvr::Mat4f& view_proj_matrix) {
+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) {
   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));
   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_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 }
 
-BaseQuadRenderer::BaseQuadRenderer(ShaderID vertex_id, ShaderID fragment_id)
-    : BaseRenderer(vertex_id, fragment_id) {
+void BaseQuadRenderer::SetVertexBuffer() {
   glGenBuffersARB(1, &vertex_buffer_);
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
   glBufferData(GL_ARRAY_BUFFER, kTextureQuadVerticesSize, kTextureQuadVertices,
                GL_STATIC_DRAW);
 }
 
-BaseQuadRenderer::~BaseQuadRenderer() = default;
-
 TexturedQuadRenderer::TexturedQuadRenderer()
     : 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");
 }
@@ skipping 204 matching lines @@
   glUniform1f(fade_end_handle_, kFadeEnd);
 
   glDrawArrays(GL_TRIANGLES, 0, kVerticesNumber);
 
   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_uniform_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
+}
+
+ControllerRenderer::~ControllerRenderer() = default;
+
+void ControllerRenderer::SetUp(const VrControllerModel& model) {
+  glGenBuffersARB(1, &indices_buffer_);
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_buffer_);
+  glBufferData(GL_ELEMENT_ARRAY_BUFFER, model.IndicesBufferSize(),
+               model.IndicesBuffer(), GL_STATIC_DRAW);
+
+  glGenBuffersARB(1, &vertex_buffer_);
+  glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
+  glBufferData(GL_ARRAY_BUFFER, model.ElementsBufferSize(),
+               model.ElementsBuffer(), GL_STATIC_DRAW);
+
+  glGenTextures(VrControllerModel::STATE_COUNT, texture_handles_.data());
+  for (int i = 0; i < VrControllerModel::STATE_COUNT; i++) {
+    glBindTexture(GL_TEXTURE_2D, texture_handles_[i]);
+    const SkBitmap* bitmap = model.GetTexture(i);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, bitmap->width(), bitmap->height(),
+                 0, GL_RGBA, GL_UNSIGNED_BYTE, bitmap->getPixels());
+    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 ControllerRenderer::Draw(const VrControllerModel& model,
+                              VrControllerModel::State state,
+                              const gvr::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_);
+
+  const gltf::Accessor* accessor = model.PositionAccessor();
+  glVertexAttribPointer(
+      position_handle_, gltf::GetTypeComponents(accessor->type),
+      accessor->component_type, GL_FALSE, accessor->byte_stride,
+      VOID_OFFSET(accessor->byte_offset));
+  glEnableVertexAttribArray(position_handle_);
+
+  accessor = model.TextureCoordinateAccessor();
+  glVertexAttribPointer(
+      tex_coord_handle_, gltf::GetTypeComponents(accessor->type),
+      accessor->component_type, GL_FALSE, accessor->byte_stride,
+      VOID_OFFSET(accessor->byte_offset));
+  glEnableVertexAttribArray(tex_coord_handle_);
+
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_buffer_);
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, texture_handles_[state]);
+  glUniform1i(tex_uniform_handle_, 0);
+
+  accessor = model.IndicesAccessor();
+  glDrawElements(model.DrawMode(), accessor->count, accessor->component_type,
+                 VOID_OFFSET(accessor->byte_offset));
+}
+
 GradientQuadRenderer::GradientQuadRenderer()
     : 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");
 }
@@ skipping 102 matching lines @@
 
   size_t vertex_buffer_size = sizeof(Line3d) * linesNumber;
 
   glGenBuffersARB(1, &vertex_buffer_);
   glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_);
   glBufferData(GL_ARRAY_BUFFER, vertex_buffer_size, grid_lines_.data(),
                GL_STATIC_DRAW);
 }
 
 VrShellRenderer::VrShellRenderer()
-    : 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) {}
+    : textured_quad_renderer_(base::MakeUnique<TexturedQuadRenderer>()),

[cjgrant, 2017/03/29 13:20:54]

Thank you. :)

[acondor_, 2017/03/29 20:13:26]

:)

+      webvr_renderer_(base::MakeUnique<WebVrRenderer>()),
+      reticle_renderer_(base::MakeUnique<ReticleRenderer>()),
+      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