Implement displayName and stageParameters of VRDisplay for OpenVRDevice

device/vr/openvr/openvr_device.cc

 // Copyright (c) 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.
 
 #define _USE_MATH_DEFINES  // for M_PI
 #include "device/vr/openvr/openvr_device.h"
 #include <math.h>
 #include "third_party/openvr/src/headers/openvr.h"
 
 namespace {
 
 constexpr float kRadToDeg = static_cast<float>(180 / M_PI);
 constexpr float kDefaultIPD = 0.06f;  // Default average IPD
 
 device::mojom::VRFieldOfViewPtr openVRFovToWebVRFov(vr::IVRSystem* vr_system,
                                                     vr::Hmd_Eye eye) {
   device::mojom::VRFieldOfViewPtr out = device::mojom::VRFieldOfView::New();
   float up_tan, down_tan, left_tan, right_tan;
   vr_system->GetProjectionRaw(eye, &left_tan, &right_tan, &up_tan, &down_tan);
   out->upDegrees = -(atanf(up_tan) * kRadToDeg);
   out->downDegrees = atanf(down_tan) * kRadToDeg;
   out->leftDegrees = -(atanf(left_tan) * kRadToDeg);
   out->rightDegrees = atanf(right_tan) * kRadToDeg;
   return out;
 }
 
+std::string getOpenVRString(vr::IVRSystem* vr_system,
+                            vr::TrackedDeviceProperty prop) {
+  std::string out;
+
+  vr::TrackedPropertyError error = vr::TrackedProp_Success;
+  char openvr_string[vr::k_unMaxPropertyStringSize];
+  vr_system->GetStringTrackedDeviceProperty(
+      vr::k_unTrackedDeviceIndex_Hmd, prop, openvr_string,
+      vr::k_unMaxPropertyStringSize, &error);
+
+  if (error == vr::TrackedProp_Success)
+    out = openvr_string;
+
+  return out;
+}
+
 }  // namespace
 
 namespace device {
 
 OpenVRDevice::OpenVRDevice() {}
 OpenVRDevice::~OpenVRDevice() {}
 
 void OpenVRDevice::CreateVRDisplayInfo(
     const base::Callback<void(mojom::VRDisplayInfoPtr)>& on_created) {
   vr::EVRInitError init_error;
   auto vr_system =
       vr::VR_Init(&init_error, vr::EVRApplicationType::VRApplication_Scene);
 
   if (init_error != vr::VRInitError_None) {
     LOG(ERROR) << vr::VR_GetVRInitErrorAsEnglishDescription(init_error);
     on_created.Run(nullptr);
     return;
   }
 
   mojom::VRDisplayInfoPtr device = mojom::VRDisplayInfo::New();
   device->index = id();
+  device->displayName =
+      getOpenVRString(vr_system, vr::Prop_ManufacturerName_String) + " " +
+      getOpenVRString(vr_system, vr::Prop_ModelNumber_String);
   device->capabilities = mojom::VRDisplayCapabilities::New();
   device->capabilities->hasPosition = true;
   device->capabilities->hasExternalDisplay = true;
   device->capabilities->canPresent = false;
 
   device->leftEye = mojom::VREyeParameters::New();
   device->rightEye = mojom::VREyeParameters::New();
   mojom::VREyeParametersPtr& left_eye = device->leftEye;
   mojom::VREyeParametersPtr& right_eye = device->rightEye;
 
@@ skipping 16 matching lines @@
   right_eye->offset[1] = 0.0;
   right_eye->offset[2] = 0.0;
 
   uint32_t width, height;
   vr_system->GetRecommendedRenderTargetSize(&width, &height);
   left_eye->renderWidth = width;
   left_eye->renderHeight = height;
   right_eye->renderWidth = left_eye->renderWidth;
   right_eye->renderHeight = left_eye->renderHeight;
 
+  device->stageParameters = mojom::VRStageParameters::New();
+  vr::HmdMatrix34_t mat =
+      vr_system->GetSeatedZeroPoseToStandingAbsoluteTrackingPose();
+  device->stageParameters->standingTransform.resize(16);
+  std::vector<float>& transform = device->stageParameters->standingTransform;
+  transform[0] = mat.m[0][0];
+  transform[1] = mat.m[1][0];
+  transform[2] = mat.m[2][0];
+  transform[3] = 0.0f;
+  transform[4] = mat.m[0][1];
+  transform[5] = mat.m[1][1];
+  transform[6] = mat.m[2][1];
+  transform[7] = 0.0f;
+  transform[8] = mat.m[0][2];
+  transform[9] = mat.m[1][2];
+  transform[10] = mat.m[2][2];
+  transform[11] = 0.0f;
+  transform[12] = mat.m[0][3];
+  transform[13] = mat.m[1][3];
+  transform[14] = mat.m[2][3];
+  transform[15] = 1.0f;

[billorr, 2017/04/17 17:56:08]

converting transforms from openvr to mojo/webvr format should be a helper like
the fov and vector conversions

+
+  vr::IVRChaperone* chaperone = vr::VRChaperone();
+  if (chaperone) {
+    chaperone->GetPlayAreaSize(&device->stageParameters->sizeX,
+                               &device->stageParameters->sizeZ);
+  } else {
+    device->stageParameters->sizeX = 0.0f;
+    device->stageParameters->sizeZ = 0.0f;
+  }
+
   render_loop_ = std::make_unique<OpenVRRenderLoop>(vr_system);
 
   on_created.Run(std::move(device));
 }
 
 void OpenVRDevice::RequestPresent(mojom::VRSubmitFrameClientPtr submit_client,
                                   const base::Callback<void(bool)>& callback) {
   callback.Run(false);
   // We don't support presentation currently.
 }
@@ skipping 86 matching lines @@
   base::TimeDelta time = base::TimeDelta::FromSecondsD(2.0);
 
   device::mojom::VRPosePtr pose = getPose();
   Sleep(11);  // TODO (billorr): Use real vsync timing instead of a sleep (this
               // sleep just throttles vsyncs so we don't fill message queues).
   callback.Run(std::move(pose), time, frame,
                device::mojom::VRVSyncProvider::Status::SUCCESS);
 }
 
 }  // namespace device