Implementation of elbow model for the controller position and rotation.

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 167 matching lines @@
           }
           /* clang-format on */);
     case vr_shell::ShaderID::LASER_FRAGMENT_SHADER:
       return SHADER(
           /* clang-format off */
           varying mediump vec2 v_TexCoordinate;
           uniform sampler2D texture_unit;
           uniform lowp vec4 color;
           uniform mediump float fade_point;
           uniform mediump float fade_end;
+          uniform mediump float u_Opacity;
 
           void main() {
             mediump vec2 uv = v_TexCoordinate;
             mediump float front_fade_factor = 1.0 -
                 clamp(1.0 - (uv.y - fade_point) / (1.0 - fade_point), 0.0, 1.0);
             mediump float back_fade_factor =
                 clamp((uv.y - fade_point) / (fade_end - fade_point), 0.0, 1.0);
             mediump float total_fade = front_fade_factor * back_fade_factor;
             lowp vec4 texture_color = texture2D(texture_unit, uv);
             lowp vec4 final_color = color * texture_color;
-            gl_FragColor = vec4(final_color.xyz, final_color.w * total_fade);
+            gl_FragColor = vec4(final_color.xyz,
+                                final_color.w * total_fade * u_Opacity);
           }
           /* clang-format on */);
     case vr_shell::ShaderID::GRADIENT_QUAD_FRAGMENT_SHADER:
     case vr_shell::ShaderID::GRADIENT_GRID_FRAGMENT_SHADER:
       return OEIE_SHADER(
           /* clang-format off */
           precision highp float;
           varying vec2 v_GridPosition;
           uniform vec4 u_CenterColor;
           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;
+          uniform mediump float u_Opacity;
 
           void main() {
-            gl_FragColor = texture2D(u_texture, v_TexCoordinate);
+            lowp vec4 texture_color = texture2D(u_texture, v_TexCoordinate);
+            gl_FragColor = vec4(texture_color.xyz, texture_color.w * u_Opacity);
           }
           /* clang-format on */);
     default:
       LOG(ERROR) << "Shader source requested for unknown shader";
       return "";
   }
 }
 
 }  // namespace
 
@@ skipping 246 matching lines @@
 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");
   fade_point_handle_ = glGetUniformLocation(program_handle_, "fade_point");
   fade_end_handle_ = glGetUniformLocation(program_handle_, "fade_end");
+  opacity_handle_ = glGetUniformLocation(program_handle_, "u_Opacity");
 
   glGenTextures(1, &texture_data_handle_);
   glBindTexture(GL_TEXTURE_2D, texture_data_handle_);
 
   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(float opacity, const gvr::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);
   glUniform1f(fade_end_handle_, kFadeEnd);
+  glUniform1f(opacity_handle_, opacity);
 
   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");
+  opacity_handle_ = glGetUniformLocation(program_handle_, "u_Opacity");
 }
 
 ControllerRenderer::~ControllerRenderer() = default;
 
 void ControllerRenderer::SetUp(std::unique_ptr<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);
 
@@ skipping 28 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,
+                              float opacity,
                               const gvr::Mat4f& view_proj_matrix) {
   glUseProgram(program_handle_);
 
+  glUniform1f(opacity_handle_, opacity);
+
   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_);
 
   glVertexAttribPointer(tex_coord_handle_, tex_coord_components_,
@@ skipping 141 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