Rendering Daydream controller in a fixed position.

chrome/browser/android/vr_shell/vr_shell.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.h"
 
 #include <android/native_window_jni.h>
 
 #include <string>
 #include <utility>
 
 #include "base/android/jni_string.h"
+#include "base/files/file_path.h"
+#include "base/json/json_file_value_serializer.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
+#include "base/path_service.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/android/tab_android.h"
 #include "chrome/browser/android/vr_shell/android_ui_gesture_target.h"
+#include "chrome/browser/android/vr_shell/gltf_parser.h"
+#include "chrome/browser/android/vr_shell/ui_interface.h"
 #include "chrome/browser/android/vr_shell/vr_compositor.h"
+#include "chrome/browser/android/vr_shell/vr_controller_model.h"
 #include "chrome/browser/android/vr_shell/vr_gl_thread.h"
 #include "chrome/browser/android/vr_shell/vr_input_manager.h"
 #include "chrome/browser/android/vr_shell/vr_shell_delegate.h"
 #include "chrome/browser/android/vr_shell/vr_shell_gl.h"
 #include "chrome/browser/android/vr_shell/vr_usage_monitor.h"
 #include "chrome/browser/android/vr_shell/vr_web_contents_observer.h"
+#include "components/component_updater/component_updater_paths.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/content_features.h"
 #include "content/public/common/referrer.h"
 #include "device/vr/android/gvr/gvr_device.h"
 #include "device/vr/android/gvr/gvr_device_provider.h"
 #include "device/vr/android/gvr/gvr_gamepad_data_fetcher.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "jni/VrShellImpl_jni.h"
 #include "third_party/WebKit/public/platform/WebInputEvent.h"
 #include "ui/android/view_android.h"
 #include "ui/android/window_android.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
+#include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/transform_util.h"
 
 using base::android::JavaParamRef;
 using base::android::JavaRef;
 
 namespace vr_shell {
 
 namespace {
 vr_shell::VrShell* g_instance;
 
 static const char kVrShellUIURL[] = "chrome://vr-shell-ui";
 
 // Default downscale factor for computing the recommended WebVR
 // renderWidth/Height from the 1:1 pixel mapped size. Using a rather
 // aggressive downscale due to the high overhead of copying pixels
 // twice before handing off to GVR. For comparison, the polyfill
 // uses approximately 0.55 on a Pixel XL.
 static constexpr float kWebVrRecommendedResolutionScale = 0.5;
 
 void SetIsInVR(content::WebContents* contents, bool is_in_vr) {
   if (contents && contents->GetRenderWidgetHostView())
     contents->GetRenderWidgetHostView()->SetIsInVR(is_in_vr);
 }
 
+void LoadControllerModelTask(

[asimjour1, 2017/03/29 20:40:44]

It should be moved to VrController

[acondor_, 2017/03/29 22:46:44]

Done.

+    base::WeakPtr<VrShell> weak_vr_shell,
+    scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner) {
+  base::FilePath models_path;
+  PathService::Get(component_updater::DIR_COMPONENT_USER, &models_path);
+  models_path = models_path.Append(VrControllerModel::kComponentName)
+                    .Append(VrControllerModel::kDefaultVersion)
+                    .Append(VrControllerModel::kModelsDirectory);
+  auto model_path = models_path.Append(VrControllerModel::kModelFilename);
+
+  // No further action if model file is not present
+  if (!base::PathExists(model_path)) {
+    LOG(WARNING) << "Controller model files not found";
+    return;
+  }
+
+  GltfParser gltf_parser;
+  std::vector<std::unique_ptr<gltf::Buffer>> buffers;
+  auto asset = gltf_parser.Parse(model_path, &buffers);
+  if (!asset) {
+    LOG(WARNING) << "Failed to read controller model";
+    return;
+  }
+
+  auto controller_model =
+      base::MakeUnique<VrControllerModel>(std::move(asset), std::move(buffers));
+
+  auto textures_path =
+      models_path.Append(VrControllerModel::kTexturesDirectory);
+
+  for (int i = 0; i < VrControllerModel::STATE_COUNT; i++) {
+    auto texture_path =
+        textures_path.Append(VrControllerModel::kTextureFilenames[i]);
+    std::string data;
+    auto bitmap = base::MakeUnique<SkBitmap>();
+    if (!base::ReadFileToString(texture_path, &data) ||
+        !gfx::PNGCodec::Decode(
+            reinterpret_cast<const unsigned char*>(data.data()), data.size(),
+            bitmap.get()) ||
+        bitmap->colorType() != kRGBA_8888_SkColorType) {
+      LOG(ERROR) << "Failed to read controller texture";
+      return;
+    }
+    controller_model->SetTexture(i, std::move(bitmap));
+  }
+
+  main_thread_task_runner->PostTask(
+      FROM_HERE, base::Bind(&VrShell::SubmitControllerModel, weak_vr_shell,
+                            base::Passed(&controller_model)));
+}
+
 }  // namespace
 
 VrShell::VrShell(JNIEnv* env,
                  jobject obj,
                  ui::WindowAndroid* content_window,
                  content::WebContents* ui_contents,
                  ui::WindowAndroid* ui_window,
                  bool for_web_vr,
                  VrShellDelegate* delegate,
                  gvr_context* gvr_api,
@@ skipping 21 matching lines @@
   gl_thread_ = base::MakeUnique<VrGLThread>(weak_ptr_factory_.GetWeakPtr(),
                                             main_thread_task_runner_, gvr_api,
                                             for_web_vr, reprojected_rendering_);
 
   base::Thread::Options options(base::MessageLoop::TYPE_DEFAULT, 0);
   options.priority = base::ThreadPriority::DISPLAY;
   gl_thread_->StartWithOptions(options);
 
   html_interface_ = base::MakeUnique<UiInterface>(
       for_web_vr ? UiInterface::Mode::WEB_VR : UiInterface::Mode::STANDARD);
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(LoadControllerModelTask, weak_ptr_factory_.GetWeakPtr(),
+                 main_thread_task_runner_));
 }
 
 void VrShell::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
 void VrShell::SwapContents(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobject>& web_contents,
@@ skipping 219 matching lines @@
 
 void VrShell::SubmitWebVRFrame(int16_t frame_index,
                                const gpu::MailboxHolder& mailbox) {
   TRACE_EVENT1("gpu", "SubmitWebVRFrame", "frame", frame_index);
 
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::SubmitWebVRFrame,
                                      gl_thread_->GetVrShellGl(), frame_index,
                                      mailbox));
 }
 
+void VrShell::SubmitControllerModel(std::unique_ptr<VrControllerModel> model) {
+  PostToGlThreadWhenReady(base::Bind(&VrShellGl::SetControllerModel,
+                                     gl_thread_->GetVrShellGl(),
+                                     base::Passed(&model)));
+}
+
 void VrShell::UpdateWebVRTextureBounds(int16_t frame_index,
                                        const gvr::Rectf& left_bounds,
                                        const gvr::Rectf& right_bounds,
                                        const gvr::Sizei& source_size) {
   PostToGlThreadWhenReady(base::Bind(&VrShellGl::UpdateWebVRTextureBounds,
                                      gl_thread_->GetVrShellGl(), frame_index,
                                      left_bounds, right_bounds, source_size));
 }
 
 bool VrShell::SupportsPresentation() {
@@ skipping 417 matching lines @@
            jboolean reprojected_rendering) {
   return reinterpret_cast<intptr_t>(new VrShell(
       env, obj, reinterpret_cast<ui::WindowAndroid*>(content_window_android),
       content::WebContents::FromJavaWebContents(ui_web_contents),
       reinterpret_cast<ui::WindowAndroid*>(ui_window_android), for_web_vr,
       VrShellDelegate::GetNativeVrShellDelegate(env, delegate),
       reinterpret_cast<gvr_context*>(gvr_api), reprojected_rendering));
 }
 
 }  // namespace vr_shell