[vr] Procedural controller model

Procedurally generate a controller model as a replacement for the Gltf
mesh. Procedural controller is disabled for now until we have the proper
button icons.

Bug: 799606
Cq-Include-Trybots: master.tryserver.chromium.android:android_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_optional_gpu_tests_rel;master.tryserver.chromium.linux:linux_vr;master.tryserver.chromium.mac:mac_optional_gpu_tests_rel;master.tryserver.chromium.win:win_optional_gpu_tests_rel
Change-Id: I09ce54d3374154db9baf352e5a2e7b5b923d1618
Reviewed-on: https://chromium-review.googlesource.com/887626
Commit-Queue: Tibor Goldschwendt <tiborg@chromium.org>
Reviewed-by: Christopher Grant <cjgrant@chromium.org>
Reviewed-by: Ian Vollick <vollick@chromium.org>
Cr-Commit-Position: refs/heads/master@{#533766}

chrome/browser/vr/BUILD.gn

@@ -58,6 +58,8 @@ static_library("vr_common") {
     "elements/exit_prompt_texture.h",
     "elements/full_screen_rect.cc",
     "elements/full_screen_rect.h",
+    "elements/gltf_controller.cc",
+    "elements/gltf_controller.h",
     "elements/invisible_hit_target.cc",
     "elements/invisible_hit_target.h",
     "elements/keyboard.cc",

chrome/browser/vr/elements/controller.h

-// Copyright 2017 The Chromium Authors. All rights reserved.
+// Copyright 2018 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.
 
@@ -8,26 +8,17 @@
 #include <vector>
 
 #include "base/macros.h"
-#include "chrome/browser/vr/controller_mesh.h"
 #include "chrome/browser/vr/elements/ui_element.h"
 #include "chrome/browser/vr/renderers/base_renderer.h"
 
 namespace vr {
 
-// This represents the controller.
+// This represents a procedurally generated Daydream controller.
 class Controller : public UiElement {
  public:
   Controller();
   ~Controller() override;
 
-  void set_touchpad_button_pressed(bool pressed) {
-    touchpad_button_pressed_ = pressed;
-  }
-
-  void set_app_button_pressed(bool pressed) { app_button_pressed_ = pressed; }
-
-  void set_home_button_pressed(bool pressed) { home_button_pressed_ = pressed; }
-
   void set_local_transform(const gfx::Transform& transform) {
     local_transform_ = transform;
   }
@@ -37,33 +28,18 @@ class Controller : public UiElement {
     Renderer();
     ~Renderer() override;
 
-    void SetUp(std::unique_ptr<ControllerMesh> model);
-    void Draw(ControllerMesh::State state,
-              float opacity,
-              const gfx::Transform& view_proj_matrix);
-    bool IsSetUp() const { return setup_; }
+    void Draw(float opacity, const gfx::Transform& view_proj_matrix);
 
    private:
-    GLuint model_view_proj_matrix_handle_;
-    GLuint tex_coord_handle_;
-    GLuint texture_handle_;
-    GLuint opacity_handle_;
-    GLuint indices_buffer_ = 0;
+    GLuint model_view_proj_matrix_handle_ = 0;
+    GLuint color_handle_ = 0;
+    GLuint opacity_handle_ = 0;
+    std::vector<float> vertices_;
+    std::vector<GLushort> indices_;
+    std::vector<float> colors_;
     GLuint vertex_buffer_ = 0;
-    GLint position_components_ = 0;
-    GLenum position_type_ = GL_FLOAT;
-    GLsizei position_stride_ = 0;
-    const GLvoid* position_offset_ = nullptr;
-    GLint tex_coord_components_ = 0;
-    GLenum tex_coord_type_ = GL_FLOAT;
-    GLsizei tex_coord_stride_ = 0;
-    const GLvoid* tex_coord_offset_ = nullptr;
-    GLenum draw_mode_ = GL_TRIANGLES;
-    GLsizei indices_count_ = 0;
-    GLenum indices_type_ = GL_INT;
-    const GLvoid* indices_offset_ = nullptr;
-    std::vector<GLuint> texture_handles_;
-    bool setup_ = false;
+    GLuint color_buffer_ = 0;
+    GLuint index_buffer_ = 0;
 
     DISALLOW_COPY_AND_ASSIGN(Renderer);
   };
@@ -74,9 +50,6 @@ class Controller : public UiElement {
 
   gfx::Transform LocalTransform() const override;
 
-  bool touchpad_button_pressed_ = false;
-  bool app_button_pressed_ = false;
-  bool home_button_pressed_ = false;
   gfx::Transform local_transform_;
 
   DISALLOW_COPY_AND_ASSIGN(Controller);

chrome/browser/vr/elements/gltf_controller.cc

+// Copyright 2017 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/vr/elements/gltf_controller.h"
+
+#include "base/trace_event/trace_event.h"
+#include "chrome/browser/vr/controller_mesh.h"
+#include "chrome/browser/vr/ui_element_renderer.h"
+#include "chrome/browser/vr/vr_gl_util.h"
+
+namespace vr {
+
+namespace {
+
+// clang-format off
+static constexpr char const* kVertexShader = SHADER(
+  precision mediump float;
+  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;
+  }
+);
+
+static constexpr char const* kFragmentShader = SHADER(
+    precision mediump float;
+    uniform sampler2D u_texture;
+  varying vec2 v_TexCoordinate;
+  uniform mediump float u_Opacity;
+
+  void main() {
+    lowp vec4 texture_color = texture2D(u_texture, v_TexCoordinate);
+    gl_FragColor = texture_color * u_Opacity;
+  }
+);
+// clang-format on
+
+}  // namespace
+
+GltfController::GltfController() {
+  SetName(kController);
+  set_hit_testable(false);
+  SetVisible(true);
+}
+
+GltfController::~GltfController() = default;
+
+void GltfController::Render(UiElementRenderer* renderer,
+                            const CameraModel& model) const {
+  ControllerMesh::State state;
+  if (touchpad_button_pressed_) {
+    state = ControllerMesh::TOUCHPAD;
+  } else if (app_button_pressed_) {
+    state = ControllerMesh::APP;
+  } else if (home_button_pressed_) {
+    state = ControllerMesh::SYSTEM;
+  } else {
+    state = ControllerMesh::IDLE;
+  }
+
+  renderer->DrawGltfController(
+      state, computed_opacity(),
+      model.view_proj_matrix * world_space_transform());
+}
+
+gfx::Transform GltfController::LocalTransform() const {
+  return local_transform_;
+}
+
+GltfController::Renderer::Renderer()
+    : BaseRenderer(kVertexShader, kFragmentShader),
+      texture_handles_(ControllerMesh::STATE_COUNT) {
+  model_view_proj_matrix_handle_ =
+      glGetUniformLocation(program_handle_, "u_ModelViewProjMatrix");
+  tex_coord_handle_ = glGetAttribLocation(program_handle_, "a_TexCoordinate");
+  texture_handle_ = glGetUniformLocation(program_handle_, "u_Texture");
+  opacity_handle_ = glGetUniformLocation(program_handle_, "u_Opacity");
+}
+
+GltfController::Renderer::~Renderer() = default;
+
+void GltfController::Renderer::SetUp(std::unique_ptr<ControllerMesh> model) {
+  TRACE_EVENT0("gpu", "ControllerRenderer::SetUp");
+  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(ControllerMesh::STATE_COUNT, texture_handles_.data());
+  for (int i = 0; i < ControllerMesh::STATE_COUNT; i++) {
+    sk_sp<SkImage> texture = model->GetTexture(i);
+    SkPixmap pixmap;
+    if (!texture->peekPixels(&pixmap)) {
+      LOG(ERROR) << "Failed to read controller texture pixels";
+      continue;
+    }
+    glBindTexture(GL_TEXTURE_2D, texture_handles_[i]);
+    SetTexParameters(GL_TEXTURE_2D);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pixmap.width(), pixmap.height(), 0,
+                 GL_RGBA, GL_UNSIGNED_BYTE, pixmap.addr());
+  }
+
+  const vr::gltf::Accessor* accessor = model->PositionAccessor();
+  position_components_ = vr::gltf::GetTypeComponents(accessor->type);
+  position_type_ = accessor->component_type;
+  position_stride_ = accessor->byte_stride;
+  position_offset_ = VOID_OFFSET(accessor->byte_offset);
+
+  accessor = model->TextureCoordinateAccessor();
+  tex_coord_components_ = vr::gltf::GetTypeComponents(accessor->type);
+  tex_coord_type_ = accessor->component_type;
+  tex_coord_stride_ = accessor->byte_stride;
+  tex_coord_offset_ = VOID_OFFSET(accessor->byte_offset);
+
+  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 GltfController::Renderer::Draw(
+    ControllerMesh::State state,
+    float opacity,
+    const gfx::Transform& model_view_proj_matrix) {
+  glUseProgram(program_handle_);
+
+  glUniform1f(opacity_handle_, opacity);
+
+  glUniformMatrix4fv(model_view_proj_matrix_handle_, 1, false,
+                     MatrixToGLArray(model_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_,
+                        tex_coord_type_, GL_FALSE, tex_coord_stride_,
+                        tex_coord_offset_);
+  glEnableVertexAttribArray(tex_coord_handle_);
+
+  glEnable(GL_BLEND);
+  glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+
+  glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices_buffer_);
+
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, texture_handles_[state]);
+  glUniform1i(texture_handle_, 0);
+
+  glDrawElements(draw_mode_, indices_count_, indices_type_, indices_offset_);
+}
+
+}  // namespace vr

chrome/browser/vr/elements/gltf_controller.h

+// Copyright 2017 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.
+
+#ifndef CHROME_BROWSER_VR_ELEMENTS_GLTF_CONTROLLER_H_
+#define CHROME_BROWSER_VR_ELEMENTS_GLTF_CONTROLLER_H_
+
+#include <vector>
+
+#include "base/macros.h"
+#include "chrome/browser/vr/controller_mesh.h"
+#include "chrome/browser/vr/elements/ui_element.h"
+#include "chrome/browser/vr/renderers/base_renderer.h"
+
+namespace vr {
+
+// This represents the controller.
+class GltfController : public UiElement {
+ public:
+  GltfController();
+  ~GltfController() override;
+
+  void set_touchpad_button_pressed(bool pressed) {
+    touchpad_button_pressed_ = pressed;
+  }
+
+  void set_app_button_pressed(bool pressed) { app_button_pressed_ = pressed; }
+
+  void set_home_button_pressed(bool pressed) { home_button_pressed_ = pressed; }
+
+  void set_local_transform(const gfx::Transform& transform) {
+    local_transform_ = transform;
+  }
+
+  class Renderer : public BaseRenderer {
+   public:
+    Renderer();
+    ~Renderer() override;
+
+    void SetUp(std::unique_ptr<ControllerMesh> model);
+    void Draw(ControllerMesh::State state,
+              float opacity,
+              const gfx::Transform& view_proj_matrix);
+    bool IsSetUp() const { return setup_; }
+
+   private:
+    GLuint model_view_proj_matrix_handle_;
+    GLuint tex_coord_handle_;
+    GLuint texture_handle_;
+    GLuint opacity_handle_;
+    GLuint indices_buffer_ = 0;
+    GLuint vertex_buffer_ = 0;
+    GLint position_components_ = 0;
+    GLenum position_type_ = GL_FLOAT;
+    GLsizei position_stride_ = 0;
+    const GLvoid* position_offset_ = nullptr;
+    GLint tex_coord_components_ = 0;
+    GLenum tex_coord_type_ = GL_FLOAT;
+    GLsizei tex_coord_stride_ = 0;
+    const GLvoid* tex_coord_offset_ = nullptr;
+    GLenum draw_mode_ = GL_TRIANGLES;
+    GLsizei indices_count_ = 0;
+    GLenum indices_type_ = GL_INT;
+    const GLvoid* indices_offset_ = nullptr;
+    std::vector<GLuint> texture_handles_;
+    bool setup_ = false;
+
+    DISALLOW_COPY_AND_ASSIGN(Renderer);
+  };
+
+ private:
+  void Render(UiElementRenderer* renderer,
+              const CameraModel& model) const final;
+
+  gfx::Transform LocalTransform() const override;
+
+  bool touchpad_button_pressed_ = false;
+  bool app_button_pressed_ = false;
+  bool home_button_pressed_ = false;
+  gfx::Transform local_transform_;
+
+  DISALLOW_COPY_AND_ASSIGN(GltfController);
+};
+
+}  // namespace vr
+
+#endif  // CHROME_BROWSER_VR_ELEMENTS_GLTF_CONTROLLER_H_

chrome/browser/vr/model/color_scheme.cc

@@ -142,6 +142,9 @@ void InitializeColorSchemes() {
   normal_scheme.snackbar_button_colors.background_down = 0xDD2D2D2D;
 
   normal_scheme.controller_label_callout = SK_ColorWHITE;
+  normal_scheme.controller_button = 0xFFEFEFEF;
+  normal_scheme.controller_button_down = 0xFF2979FF;
+
   normal_scheme.reposition_label = SK_ColorWHITE;
   normal_scheme.reposition_label_background = 0xAA333333;
 

chrome/browser/vr/model/color_scheme.h

@@ -121,6 +121,9 @@ struct ColorScheme {
   ButtonColors snackbar_button_colors;
 
   SkColor controller_label_callout;
+  SkColor controller_button;
+  SkColor controller_button_down;
+
   SkColor reposition_label;
   SkColor reposition_label_background;
 

chrome/browser/vr/model/model.h

@@ -47,6 +47,9 @@ struct Model {
   bool background_available = false;
   bool can_apply_new_background = false;
   bool background_loaded = false;
+  // TODO(crbug.com/799606): Use procedural controller model once we have the
+  // proper button icons.
+  bool procedural_controller_enabled = false;
 
   // WebVR state.
   WebVrModel web_vr;

chrome/browser/vr/test/fake_ui_element_renderer.cc

@@ -45,10 +45,17 @@ void FakeUiElementRenderer::DrawGradientGridQuad(
   called_ = true;
 }
 
-void FakeUiElementRenderer::DrawController(
+void FakeUiElementRenderer::DrawGltfController(
     ControllerMesh::State state,
     float opacity,
-    const gfx::Transform& view_proj_matrix) {
+    const gfx::Transform& model_view_proj_matrix) {
+  opacity_ = opacity;
+  called_ = true;
+}
+
+void FakeUiElementRenderer::DrawController(
+    float opacity,
+    const gfx::Transform& model_view_proj_matrix) {
   opacity_ = opacity;
   called_ = true;
 }

chrome/browser/vr/test/fake_ui_element_renderer.h

@@ -40,9 +40,13 @@ class FakeUiElementRenderer : public UiElementRenderer {
                             int gridline_count,
                             float opacity) override;
 
-  void DrawController(ControllerMesh::State state,
-                      float opacity,
-                      const gfx::Transform& view_proj_matrix) override;
+  void DrawGltfController(
+      ControllerMesh::State state,
+      float opacity,
+      const gfx::Transform& model_view_proj_matrix) override;
+
+  void DrawController(float opacity,
+                      const gfx::Transform& model_view_proj_matrix) override;
 
   void DrawLaser(float opacity,
                  const gfx::Transform& view_proj_matrix) override;

chrome/browser/vr/ui_element_renderer.cc

@@ -42,6 +42,7 @@ void UiElementRenderer::Init() {
   webvr_renderer_ = std::make_unique<WebVrRenderer>();
   reticle_renderer_ = std::make_unique<Reticle::Renderer>();
   laser_renderer_ = std::make_unique<Laser::Renderer>();
+  gltf_controller_renderer_ = std::make_unique<GltfController::Renderer>();
   controller_renderer_ = std::make_unique<Controller::Renderer>();
   gradient_grid_renderer_ = std::make_unique<Grid::Renderer>();
   shadow_renderer_ = std::make_unique<Shadow::Renderer>();
@@ -95,15 +96,22 @@ void UiElementRenderer::DrawGradientGridQuad(
                                 opacity);
 }
 
-void UiElementRenderer::DrawController(
+void UiElementRenderer::DrawGltfController(
     ControllerMesh::State state,
     float opacity,
     const gfx::Transform& model_view_proj_matrix) {
-  if (!controller_renderer_->IsSetUp()) {
+  if (!gltf_controller_renderer_->IsSetUp()) {
     return;
   }
+  FlushIfNecessary(gltf_controller_renderer_.get());
+  gltf_controller_renderer_->Draw(state, opacity, model_view_proj_matrix);
+}
+
+void UiElementRenderer::DrawController(
+    float opacity,
+    const gfx::Transform& model_view_proj_matrix) {
   FlushIfNecessary(controller_renderer_.get());
-  controller_renderer_->Draw(state, opacity, model_view_proj_matrix);
+  controller_renderer_->Draw(opacity, model_view_proj_matrix);
 }
 
 void UiElementRenderer::DrawLaser(
@@ -170,7 +178,7 @@ void UiElementRenderer::Flush() {
 }
 
 void UiElementRenderer::SetUpController(std::unique_ptr<ControllerMesh> mesh) {
-  controller_renderer_->SetUp(std::move(mesh));
+  gltf_controller_renderer_->SetUp(std::move(mesh));
 }
 
 void UiElementRenderer::FlushIfNecessary(BaseRenderer* renderer) {

chrome/browser/vr/ui_element_renderer.h

@@ -14,6 +14,7 @@
 #include "chrome/browser/vr/elements/environment/background.h"
 #include "chrome/browser/vr/elements/environment/grid.h"
 #include "chrome/browser/vr/elements/environment/stars.h"
+#include "chrome/browser/vr/elements/gltf_controller.h"
 #include "chrome/browser/vr/elements/laser.h"
 #include "chrome/browser/vr/elements/reticle.h"
 #include "chrome/browser/vr/elements/shadow.h"
@@ -82,11 +83,15 @@ class UiElementRenderer {
       float opacity);
 
   // TODO(crbug/779108) This presumes a Daydream controller.
-  VIRTUAL_FOR_MOCKS void DrawController(
+  VIRTUAL_FOR_MOCKS void DrawGltfController(
       ControllerMesh::State state,
       float opacity,
       const gfx::Transform& model_view_proj_matrix);
 
+  VIRTUAL_FOR_MOCKS void DrawController(
+      float opacity,
+      const gfx::Transform& model_view_proj_matrix);
+
   VIRTUAL_FOR_MOCKS void DrawLaser(
       float opacity,
       const gfx::Transform& model_view_proj_matrix);
@@ -140,6 +145,7 @@ class UiElementRenderer {
   std::unique_ptr<WebVrRenderer> webvr_renderer_;
   std::unique_ptr<Reticle::Renderer> reticle_renderer_;
   std::unique_ptr<Laser::Renderer> laser_renderer_;
+  std::unique_ptr<GltfController::Renderer> gltf_controller_renderer_;
   std::unique_ptr<Controller::Renderer> controller_renderer_;
   std::unique_ptr<Grid::Renderer> gradient_grid_renderer_;
   std::unique_ptr<Shadow::Renderer> shadow_renderer_;

chrome/browser/vr/ui_scene_constants.h

@@ -276,6 +276,13 @@ static constexpr float kControllerBackButtonOffset = -0.008f;
 
 static constexpr int kControllerLabelTransitionDurationMs = 700;
 
+static constexpr float kControllerWidth = 0.035f;
+static constexpr float kControllerHeight = 0.016f;
+static constexpr float kControllerLength = 0.105f;
+static constexpr float kControllerSmallButtonSize = kControllerWidth * 0.306f;
+static constexpr float kControllerAppButtonZ = kControllerLength * -0.075f;
+static constexpr float kControllerHomeButtonZ = kControllerLength * 0.075f;
+
 static constexpr float kSkyDistance = 1000.0f;
 static constexpr float kGridOpacity = 0.5f;
 

chrome/browser/vr/ui_scene_creator.cc

@@ -470,6 +470,97 @@ std::unique_ptr<UiElement> CreateControllerLabel(UiElementName name,
   return layout;
 }
 
+std::unique_ptr<UiElement> CreateControllerModel(Model* model) {
+  auto controller = std::make_unique<Controller>();
+  controller->SetDrawPhase(kPhaseForeground);
+  controller->AddBinding(VR_BIND_FUNC(gfx::Transform, Model, model,
+                                      model->controller.transform, Controller,
+                                      controller.get(), set_local_transform));
+  controller->AddBinding(VR_BIND_FUNC(float, Model, model,
+                                      model->controller.opacity, Controller,
+                                      controller.get(), SetOpacity));
+
+  auto touchpad_button = Create<Rect>(kNone, kPhaseForeground);
+  touchpad_button->SetVisible(true);
+  touchpad_button->set_hit_testable(false);
+  touchpad_button->SetColor(model->color_scheme().controller_button);
+  touchpad_button->SetSize(kControllerWidth, kControllerWidth);
+  touchpad_button->SetRotate(1, 0, 0, -base::kPiFloat / 2);
+  touchpad_button->SetTranslate(0.0f, 0.0f,
+                                -(kControllerLength - kControllerWidth) / 2);
+  touchpad_button->SetCornerRadii({kControllerWidth / 2, kControllerWidth / 2,
+                                   kControllerWidth / 2, kControllerWidth / 2});
+  touchpad_button->AddBinding(VR_BIND_FUNC(
+      SkColor, Model, model,
+      model->controller.touchpad_button_state == UiInputManager::DOWN
+          ? model->color_scheme().controller_button_down
+          : model->color_scheme().controller_button,
+      Rect, touchpad_button.get(), SetColor));
+  controller->AddChild(std::move(touchpad_button));
+
+  auto app_button = Create<Rect>(kNone, kPhaseForeground);
+  app_button->SetVisible(true);
+  app_button->set_hit_testable(false);
+  app_button->SetColor(model->color_scheme().controller_button);
+  app_button->SetSize(kControllerSmallButtonSize, kControllerSmallButtonSize);
+  app_button->SetRotate(1, 0, 0, -base::kPiFloat / 2);
+  app_button->SetTranslate(0.0f, 0.0f, kControllerAppButtonZ);
+  app_button->SetCornerRadii(
+      {kControllerSmallButtonSize / 2, kControllerSmallButtonSize / 2,
+       kControllerSmallButtonSize / 2, kControllerSmallButtonSize / 2});
+  app_button->AddBinding(
+      VR_BIND_FUNC(SkColor, Model, model,
+                   model->controller.app_button_state == UiInputManager::DOWN
+                       ? model->color_scheme().controller_button_down
+                       : model->color_scheme().controller_button,
+                   Rect, app_button.get(), SetColor));
+  controller->AddChild(std::move(app_button));
+
+  auto home_button = Create<Rect>(kNone, kPhaseForeground);
+  home_button->SetVisible(true);
+  home_button->set_hit_testable(false);
+  home_button->SetColor(model->color_scheme().controller_button);
+  home_button->SetSize(kControllerSmallButtonSize, kControllerSmallButtonSize);
+  home_button->SetRotate(1, 0, 0, -base::kPiFloat / 2);
+  home_button->SetTranslate(0.0f, 0.0f, kControllerHomeButtonZ);
+  home_button->SetCornerRadii(
+      {kControllerSmallButtonSize / 2, kControllerSmallButtonSize / 2,
+       kControllerSmallButtonSize / 2, kControllerSmallButtonSize / 2});
+  home_button->AddBinding(
+      VR_BIND_FUNC(SkColor, Model, model,
+                   model->controller.home_button_state == UiInputManager::DOWN
+                       ? model->color_scheme().controller_button_down
+                       : model->color_scheme().controller_button,
+                   Rect, home_button.get(), SetColor));
+  controller->AddChild(std::move(home_button));
+
+  return controller;
+}
+
+std::unique_ptr<UiElement> CreateGltfControllerModel(Model* model) {
+  auto controller = std::make_unique<GltfController>();
+  controller->SetDrawPhase(kPhaseForeground);
+  controller->AddBinding(
+      VR_BIND_FUNC(gfx::Transform, Model, model, model->controller.transform,
+                   GltfController, controller.get(), set_local_transform));
+  controller->AddBinding(VR_BIND_FUNC(
+      bool, Model, model,
+      model->controller.touchpad_button_state == UiInputManager::DOWN,
+      GltfController, controller.get(), set_touchpad_button_pressed));
+  controller->AddBinding(
+      VR_BIND_FUNC(bool, Model, model,
+                   model->controller.app_button_state == UiInputManager::DOWN,
+                   GltfController, controller.get(), set_app_button_pressed));
+  controller->AddBinding(
+      VR_BIND_FUNC(bool, Model, model,
+                   model->controller.home_button_state == UiInputManager::DOWN,
+                   GltfController, controller.get(), set_home_button_pressed));
+  controller->AddBinding(VR_BIND_FUNC(float, Model, model,
+                                      model->controller.opacity, GltfController,
+                                      controller.get(), SetOpacity));
+  return controller;
+}
+
 }  // namespace
 
 UiSceneCreator::UiSceneCreator(UiBrowserInterface* browser,
@@ -1384,26 +1475,9 @@ void UiSceneCreator::CreateController() {
           base::Unretained(group.get()))));
   scene_->AddUiElement(kControllerRoot, std::move(group));
 
-  auto controller = std::make_unique<Controller>();
-  controller->SetDrawPhase(kPhaseForeground);
-  controller->AddBinding(VR_BIND_FUNC(gfx::Transform, Model, model_,
-                                      model->controller.transform, Controller,
-                                      controller.get(), set_local_transform));
-  controller->AddBinding(VR_BIND_FUNC(
-      bool, Model, model_,
-      model->controller.touchpad_button_state == UiInputManager::DOWN,
-      Controller, controller.get(), set_touchpad_button_pressed));
-  controller->AddBinding(
-      VR_BIND_FUNC(bool, Model, model_,
-                   model->controller.app_button_state == UiInputManager::DOWN,
-                   Controller, controller.get(), set_app_button_pressed));
-  controller->AddBinding(
-      VR_BIND_FUNC(bool, Model, model_,
-                   model->controller.home_button_state == UiInputManager::DOWN,
-                   Controller, controller.get(), set_home_button_pressed));
-  controller->AddBinding(VR_BIND_FUNC(float, Model, model_,
-                                      model->controller.opacity, Controller,
-                                      controller.get(), SetOpacity));
+  auto controller = model_->procedural_controller_enabled
+                        ? CreateControllerModel(model_)
+                        : CreateGltfControllerModel(model_);
 
   auto callout_group = Create<UiElement>(kNone, kPhaseNone);
   callout_group->SetVisible(false);