Update Stage Parameters After Session Starts

This is the second part of bug 976446 where first part only updates eye
and headset related parameters, this cl updates stage related parameters

Bug: 976446
Change-Id: I6f18a522a2f929e6c0f1e871eaa7bee85265fd75
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1762587
Commit-Queue: Zheng Qin <zheqi@microsoft.com>
Reviewed-by: Alexander Cooper <alcooper@chromium.org>
Cr-Commit-Position: refs/heads/master@{#690800}

device/vr/openxr/openxr_api_wrapper.cc

@@ -16,6 +16,8 @@
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/quaternion.h"
 #include "ui/gfx/geometry/size.h"
+#include "ui/gfx/transform.h"
+#include "ui/gfx/transform_util.h"
 
 namespace device {
 
@@ -102,6 +104,7 @@ OpenXrApiWrapper::~OpenXrApiWrapper() {
 
 void OpenXrApiWrapper::Reset() {
   local_space_ = XR_NULL_HANDLE;
+  stage_space_ = XR_NULL_HANDLE;
   view_space_ = XR_NULL_HANDLE;
   color_swapchain_ = XR_NULL_HANDLE;
   session_ = XR_NULL_HANDLE;
@@ -193,6 +196,8 @@ bool OpenXrApiWrapper::HasSpace(XrReferenceSpaceType type) const {
       return local_space_ != XR_NULL_HANDLE;
     case XR_REFERENCE_SPACE_TYPE_VIEW:
       return view_space_ != XR_NULL_HANDLE;
+    case XR_REFERENCE_SPACE_TYPE_STAGE:
+      return stage_space_ != XR_NULL_HANDLE;
     default:
       NOTREACHED();
       return false;
@@ -286,6 +291,10 @@ XrResult OpenXrApiWrapper::StartSession(
   RETURN_IF_XR_FAILED(CreateGamepadHelper(gamepad_helper));
   RETURN_IF_XR_FAILED(BeginSession());
 
+  // It's ok if stage_space_ fails since not all OpenXR devices are required to
+  // support this reference space.
+  CreateSpace(XR_REFERENCE_SPACE_TYPE_STAGE, &stage_space_);
+
   // Since the objects in these arrays are used on every frame,
   // we don't want to create and destroy these objects every frame,
   // so create the number of objects we need and reuse them.
@@ -619,6 +628,51 @@ const XrView& OpenXrApiWrapper::GetView(uint32_t index) const {
   return views_[index];
 }
 
+XrResult OpenXrApiWrapper::GetStageBounds(XrExtent2Df* stage_bounds) const {
+  DCHECK(stage_bounds);
+  DCHECK(HasSession());
+
+  return xrGetReferenceSpaceBoundsRect(session_, XR_REFERENCE_SPACE_TYPE_STAGE,
+                                       stage_bounds);
+}
+
+bool OpenXrApiWrapper::GetStageParameters(XrExtent2Df* stage_bounds,
+                                          gfx::Transform* transform) const {
+  DCHECK(stage_bounds);
+  DCHECK(transform);
+  DCHECK(HasSession());
+
+  if (!HasSpace(XR_REFERENCE_SPACE_TYPE_LOCAL))
+    return false;
+
+  if (!HasSpace(XR_REFERENCE_SPACE_TYPE_STAGE))
+    return false;
+
+  if (XR_FAILED(GetStageBounds(stage_bounds)))
+    return false;
+
+  XrSpaceLocation location = {XR_TYPE_SPACE_LOCATION};
+  if (FAILED(xrLocateSpace(stage_space_, local_space_,
+                           frame_state_.predictedDisplayTime, &location)) ||
+      !(location.locationFlags & XR_SPACE_LOCATION_ORIENTATION_VALID_BIT) ||
+      !(location.locationFlags & XR_SPACE_LOCATION_POSITION_VALID_BIT)) {
+    return false;
+  }
+
+  // Convert the orientation and translation given by runtime into a
+  // transformation matrix.
+  gfx::DecomposedTransform seat_to_standing_decomp;
+  seat_to_standing_decomp.quaternion =
+      gfx::Quaternion(location.pose.orientation.x, location.pose.orientation.y,
+                      location.pose.orientation.z, location.pose.orientation.w);
+  seat_to_standing_decomp.translate[0] = location.pose.position.x;
+  seat_to_standing_decomp.translate[1] = location.pose.position.y;
+  seat_to_standing_decomp.translate[2] = location.pose.position.z;
+
+  *transform = gfx::ComposeTransform(seat_to_standing_decomp);
+  return true;
+}
+
 VRTestHook* OpenXrApiWrapper::test_hook_ = nullptr;
 ServiceTestHook* OpenXrApiWrapper::service_test_hook_ = nullptr;
 void OpenXrApiWrapper::SetTestHook(VRTestHook* hook) {

device/vr/openxr/openxr_api_wrapper.h

@@ -21,6 +21,7 @@ namespace gfx {
 class Quaternion;
 class Point3F;
 class Size;
+class Transform;
 }  // namespace gfx
 
 namespace device {
@@ -57,6 +58,8 @@ class OpenXrApiWrapper {
   XrTime GetPredictedDisplayTime() const;
   XrResult GetLuid(LUID* luid) const;
   std::string GetRuntimeName() const;
+  bool GetStageParameters(XrExtent2Df* stage_bounds,
+                          gfx::Transform* standing_transform) const;
 
   static void DEVICE_VR_EXPORT SetTestHook(VRTestHook* hook);
 
@@ -87,6 +90,7 @@ class OpenXrApiWrapper {
   bool HasFrameState() const;
 
   uint32_t GetRecommendedSwapchainSampleCount() const;
+  XrResult GetStageBounds(XrExtent2Df* stage_bounds) const;
 
   // Testing objects
   static VRTestHook* test_hook_;
@@ -106,6 +110,7 @@ class OpenXrApiWrapper {
   XrSwapchain color_swapchain_;
   std::vector<XrSwapchainImageD3D11KHR> color_swapchain_images_;
   XrSpace local_space_;
+  XrSpace stage_space_;
   XrSpace view_space_;
 
   // These objects store information about the current frame. They're

device/vr/openxr/openxr_device.cc

@@ -30,6 +30,8 @@ constexpr unsigned int kRenderHeight = 1024;
 constexpr gfx::Vector3dF kLeftOffset = {-kInterpupillaryDistance * 0.5, 0, 0};
 constexpr gfx::Vector3dF kRightOffset = {kInterpupillaryDistance * 0.5, 0, 0};
 
+constexpr float kStageSizeX = 0.0f;
+constexpr float kStageSizeZ = 0.0f;
 // OpenXR doesn't give out display info until you start a session.
 // However our mojo interface expects display info right away to support WebVR.
 // We create a fake display info to use, then notify the client that the display
@@ -64,6 +66,11 @@ mojom::VRDisplayInfoPtr CreateFakeVRDisplayInfo(device::mojom::XRDeviceId id) {
   display_info->right_eye->render_width = kRenderWidth;
   display_info->right_eye->render_height = kRenderHeight;
 
+  display_info->stage_parameters = mojom::VRStageParameters::New();
+  display_info->stage_parameters->standing_transform = gfx::Transform();
+  display_info->stage_parameters->size_x = kStageSizeX;
+  display_info->stage_parameters->size_z = kStageSizeZ;
+
   return display_info;
 }
 

device/vr/openxr/openxr_render_loop.cc

@@ -53,13 +53,21 @@ mojom::XRFrameDataPtr OpenXrRenderLoop::GetNextFrameData() {
 
   bool updated_display_info = UpdateDisplayInfo();
   bool updated_eye_parameters = UpdateEyeParameters();
+  bool updated_stage_parameters = UpdateStageParameters();
 
   if (updated_eye_parameters) {
     frame_data->left_eye = current_display_info_->left_eye.Clone();
     frame_data->right_eye = current_display_info_->right_eye.Clone();
   }
 
-  if (updated_display_info || updated_eye_parameters) {
+  if (updated_stage_parameters) {
+    frame_data->stage_parameters_updated = true;
+    frame_data->stage_parameters =
+        current_display_info_->stage_parameters.Clone();
+  }
+
+  if (updated_display_info || updated_eye_parameters ||
+      updated_stage_parameters) {
     main_thread_task_runner_->PostTask(
         FROM_HERE, base::BindOnce(on_display_info_changed_,
                                   current_display_info_.Clone()));
@@ -246,4 +254,35 @@ bool OpenXrRenderLoop::UpdateEye(const XrView& view,
   return changed;
 }
 
+bool OpenXrRenderLoop::UpdateStageParameters() {
+  bool changed = false;
+  XrExtent2Df stage_bounds;
+  gfx::Transform transform;
+  if (openxr_->GetStageParameters(&stage_bounds, &transform)) {
+    if (!current_display_info_->stage_parameters) {
+      current_display_info_->stage_parameters = mojom::VRStageParameters::New();
+      changed = true;
+    }
+
+    if (current_display_info_->stage_parameters->size_x != stage_bounds.width ||
+        current_display_info_->stage_parameters->size_z !=
+            stage_bounds.height) {
+      current_display_info_->stage_parameters->size_x = stage_bounds.width;
+      current_display_info_->stage_parameters->size_z = stage_bounds.height;
+      changed = true;
+    }
+
+    if (current_display_info_->stage_parameters->standing_transform !=
+        transform) {
+      current_display_info_->stage_parameters->standing_transform = transform;
+      changed = true;
+    }
+  } else if (current_display_info_->stage_parameters) {
+    current_display_info_->stage_parameters = nullptr;
+    changed = true;
+  }
+
+  return changed;
+}
+
 }  // namespace device

device/vr/openxr/openxr_render_loop.h

@@ -42,6 +42,7 @@ class OpenXrRenderLoop : public XRCompositorCommon {
                  const gfx::Point3F& center,
                  const gfx::Size& view_size,
                  mojom::VREyeParametersPtr* eye) const;
+  bool UpdateStageParameters();
 
   std::unique_ptr<OpenXrApiWrapper> openxr_;
   std::unique_ptr<OpenXrGamepadHelper> gamepad_helper_;

device/vr/openxr/test/fake_openxr_impl_api.cc

@@ -515,6 +515,13 @@ XrResult xrGetInstanceProperties(XrInstance instance,
   return XR_ERROR_FUNCTION_UNSUPPORTED;
 }
 
+XrResult xrGetReferenceSpaceBoundsRect(XrSession session,
+                                       XrReferenceSpaceType referenceSpaceType,
+                                       XrExtent2Df* bounds) {
+  // TODO(https://crbug.com/996502)
+  return XR_ERROR_FUNCTION_UNSUPPORTED;
+}
+
 XrResult xrGetSystem(XrInstance instance,
                      const XrSystemGetInfo* get_info,
                      XrSystemId* system_id) {

device/vr/openxr/test/openxr_negotiate.h

@@ -76,6 +76,9 @@ XrResult XRAPI_PTR GetInstanceProcAddress(XrInstance instance,
     *function = reinterpret_cast<PFN_xrVoidFunction>(xrGetActionStatePose);
   } else if (strcmp(name, "xrGetInstanceProperties") == 0) {
     *function = reinterpret_cast<PFN_xrVoidFunction>(xrGetInstanceProperties);
+  } else if (strcmp(name, "xrGetReferenceSpaceBoundsRect") == 0) {
+    *function =
+        reinterpret_cast<PFN_xrVoidFunction>(xrGetReferenceSpaceBoundsRect);
   } else if (strcmp(name, "xrGetSystem") == 0) {
     *function = reinterpret_cast<PFN_xrVoidFunction>(xrGetSystem);
   } else if (strcmp(name, "xrGetSystemProperties") == 0) {