Replace originOffset public member with getOffsetReferenceSpace method

Remove originOffset as a public member of XRReferenceSpace. Add
getOffsetReferenceSpace() method for creating a new XRReferenceSpace
instead of mutating originOffset.

Bug: 958440
Change-Id: I9af336112df7a359a6ac02bd8d30e554ae540511
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1595131
Commit-Queue: Will Cassella <cassew@google.com>
Reviewed-by: Bill Orr <billorr@chromium.org>
Reviewed-by: Brandon Jones <bajones@chromium.org>
Cr-Commit-Position: refs/heads/master@{#659786}

third_party/blink/renderer/modules/xr/xr_bounded_reference_space.cc

@@ -14,15 +14,12 @@ namespace blink {
 XRBoundedReferenceSpace::XRBoundedReferenceSpace(XRSession* session)
     : XRReferenceSpace(session) {}
 
-XRBoundedReferenceSpace::~XRBoundedReferenceSpace() = default;
-
-void XRBoundedReferenceSpace::setOriginOffset(XRRigidTransform* transform) {
-  XRReferenceSpace::setOriginOffset(transform);
+XRBoundedReferenceSpace::XRBoundedReferenceSpace(
+    XRSession* session,
+    XRRigidTransform* origin_offset)
+    : XRReferenceSpace(session, origin_offset) {}
 
-  // Force a bounds update.
-  stage_parameters_id_ = 0;
-  EnsureUpdated();
-}
+XRBoundedReferenceSpace::~XRBoundedReferenceSpace() = default;
 
 // No default pose for bounded reference spaces.
 std::unique_ptr<TransformationMatrix> XRBoundedReferenceSpace::DefaultPose() {
@@ -51,8 +48,7 @@ void XRBoundedReferenceSpace::EnsureUpdated() {
     // In order to ensure that the bounds continue to line up with the user's
     // physical environment we need to transform by the inverse of the
     // originOffset.
-    TransformationMatrix bounds_transform =
-        originOffset()->InverseTransformMatrix();
+    TransformationMatrix bounds_transform = InverseOriginOffsetMatrix();
 
     if (display_info->stageParameters->bounds) {
       bounds_geometry_.clear();
@@ -126,4 +122,10 @@ void XRBoundedReferenceSpace::OnReset() {
   DispatchEvent(*XRReferenceSpaceEvent::Create(event_type_names::kReset, this));
 }
 
+XRBoundedReferenceSpace* XRBoundedReferenceSpace::cloneWithOriginOffset(
+    XRRigidTransform* origin_offset) {
+  return MakeGarbageCollected<XRBoundedReferenceSpace>(this->session(),
+                                                       origin_offset);
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/xr/xr_bounded_reference_space.h

@@ -15,15 +15,14 @@ class XRBoundedReferenceSpace final : public XRReferenceSpace {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  XRBoundedReferenceSpace(XRSession*);
+  explicit XRBoundedReferenceSpace(XRSession*);
+  XRBoundedReferenceSpace(XRSession*, XRRigidTransform*);
   ~XRBoundedReferenceSpace() override;
 
   std::unique_ptr<TransformationMatrix> DefaultPose() override;
   std::unique_ptr<TransformationMatrix> TransformBasePose(
       const TransformationMatrix& base_pose) override;
 
-  void setOriginOffset(XRRigidTransform*) override;
-
   HeapVector<Member<DOMPointReadOnly>> boundsGeometry();
 
   void Trace(blink::Visitor*) override;
@@ -31,6 +30,9 @@ class XRBoundedReferenceSpace final : public XRReferenceSpace {
   void OnReset() override;
 
  private:
+  XRBoundedReferenceSpace* cloneWithOriginOffset(
+      XRRigidTransform* origin_offset) override;
+
   void EnsureUpdated();
 
   HeapVector<Member<DOMPointReadOnly>> bounds_geometry_;

third_party/blink/renderer/modules/xr/xr_reference_space.cc

@@ -13,9 +13,13 @@ namespace blink {
 
 // origin offset starts as identity transform
 XRReferenceSpace::XRReferenceSpace(XRSession* session)
-    : XRSpace(session),
-      origin_offset_(MakeGarbageCollected<XRRigidTransform>(nullptr, nullptr)) {
-}
+    : XRReferenceSpace(
+          session,
+          MakeGarbageCollected<XRRigidTransform>(nullptr, nullptr)) {}
+
+XRReferenceSpace::XRReferenceSpace(XRSession* session,
+                                   XRRigidTransform* origin_offset)
+    : XRSpace(session), origin_offset_(origin_offset) {}
 
 XRReferenceSpace::~XRReferenceSpace() = default;
 
@@ -63,14 +67,28 @@ XRReferenceSpace::GetTransformToMojoSpace() {
   return transform_matrix;
 }
 
-void XRReferenceSpace::setOriginOffset(XRRigidTransform* transform) {
-  origin_offset_ = transform;
+TransformationMatrix XRReferenceSpace::OriginOffsetMatrix() {
+  return origin_offset_->TransformMatrix();
 }
 
 TransformationMatrix XRReferenceSpace::InverseOriginOffsetMatrix() {
   return origin_offset_->InverseTransformMatrix();
 }
 
+XRReferenceSpace* XRReferenceSpace::getOffsetReferenceSpace(
+    XRRigidTransform* additional_offset) {
+  auto matrix =
+      OriginOffsetMatrix().Multiply(additional_offset->TransformMatrix());
+
+  auto* result_transform = MakeGarbageCollected<XRRigidTransform>(matrix);
+  return cloneWithOriginOffset(result_transform);
+}
+
+XRReferenceSpace* XRReferenceSpace::cloneWithOriginOffset(
+    XRRigidTransform* origin_offset) {
+  return MakeGarbageCollected<XRReferenceSpace>(this->session(), origin_offset);
+}
+
 void XRReferenceSpace::Trace(blink::Visitor* visitor) {
   visitor->Trace(origin_offset_);
   XRSpace::Trace(visitor);

third_party/blink/renderer/modules/xr/xr_reference_space.h

@@ -19,6 +19,7 @@ class XRReferenceSpace : public XRSpace {
 
  public:
   explicit XRReferenceSpace(XRSession*);
+  XRReferenceSpace(XRSession*, XRRigidTransform*);
   ~XRReferenceSpace() override;
 
   std::unique_ptr<TransformationMatrix> DefaultPose() override;
@@ -30,10 +31,11 @@ class XRReferenceSpace : public XRSpace {
 
   std::unique_ptr<TransformationMatrix> GetTransformToMojoSpace() override;
 
-  XRRigidTransform* originOffset() const { return origin_offset_; }
-  virtual void setOriginOffset(XRRigidTransform*);
+  TransformationMatrix OriginOffsetMatrix() override;
   TransformationMatrix InverseOriginOffsetMatrix() override;
 
+  XRReferenceSpace* getOffsetReferenceSpace(XRRigidTransform* transform);
+
   DEFINE_ATTRIBUTE_EVENT_LISTENER(reset, kReset)
 
   void Trace(blink::Visitor*) override;
@@ -41,6 +43,9 @@ class XRReferenceSpace : public XRSpace {
   virtual void OnReset();
 
  private:
+  virtual XRReferenceSpace* cloneWithOriginOffset(
+      XRRigidTransform* origin_offset);
+
   Member<XRRigidTransform> origin_offset_;
 };
 

third_party/blink/renderer/modules/xr/xr_reference_space.idl

@@ -16,6 +16,6 @@ enum XRReferenceSpaceType {
     Exposed=Window,
     RuntimeEnabled=WebXR
 ] interface XRReferenceSpace : XRSpace {
-  attribute XRRigidTransform originOffset;
   attribute EventHandler onreset;
+  XRReferenceSpace getOffsetReferenceSpace(XRRigidTransform originOffset);
 };

third_party/blink/renderer/modules/xr/xr_space.cc

@@ -37,6 +37,11 @@ std::unique_ptr<TransformationMatrix> XRSpace::TransformBaseInputPose(
   return nullptr;
 }
 
+TransformationMatrix XRSpace::OriginOffsetMatrix() {
+  TransformationMatrix identity;
+  return identity;
+}
+
 TransformationMatrix XRSpace::InverseOriginOffsetMatrix() {
   TransformationMatrix identity;
   return identity;

third_party/blink/renderer/modules/xr/xr_space.h

@@ -51,6 +51,7 @@ class XRSpace : public EventTargetWithInlineData {
   ExecutionContext* GetExecutionContext() const override;
   const AtomicString& InterfaceName() const override;
 
+  virtual TransformationMatrix OriginOffsetMatrix();
   virtual TransformationMatrix InverseOriginOffsetMatrix();
 
   void Trace(blink::Visitor*) override;

third_party/blink/renderer/modules/xr/xr_stationary_reference_space.cc

@@ -17,6 +17,12 @@ XRStationaryReferenceSpace::XRStationaryReferenceSpace(XRSession* session,
                                                        Subtype subtype)
     : XRReferenceSpace(session), subtype_(subtype) {}
 
+XRStationaryReferenceSpace::XRStationaryReferenceSpace(
+    XRSession* session,
+    XRRigidTransform* transform,
+    Subtype subtype)
+    : XRReferenceSpace(session, transform), subtype_(subtype) {}
+
 XRStationaryReferenceSpace::~XRStationaryReferenceSpace() = default;
 
 void XRStationaryReferenceSpace::UpdateFloorLevelTransform() {
@@ -67,8 +73,8 @@ XRStationaryReferenceSpace::TransformBasePose(
 
       // Apply the floor-level transform to the base pose.
       if (floor_level_transform_) {
-        std::unique_ptr<TransformationMatrix> pose(
-            std::make_unique<TransformationMatrix>(*floor_level_transform_));
+        auto pose =
+            std::make_unique<TransformationMatrix>(*floor_level_transform_);
         pose->Multiply(base_pose);
         return pose;
       }
@@ -77,8 +83,7 @@ XRStationaryReferenceSpace::TransformBasePose(
       // 'position-disabled' poses must not contain any translation components,
       // and as a result the space the base pose is originally in doesn't matter
       // much. Strip out translation component and return.
-      std::unique_ptr<TransformationMatrix> pose(
-          std::make_unique<TransformationMatrix>(base_pose));
+      auto pose = std::make_unique<TransformationMatrix>(base_pose);
       pose->SetM41(0.0);
       pose->SetM42(0.0);
       pose->SetM43(0.0);
@@ -98,8 +103,7 @@ XRStationaryReferenceSpace::TransformBaseInputPose(
     const TransformationMatrix& base_pose) {
   switch (subtype_) {
     case kSubtypePositionDisabled: {
-      std::unique_ptr<TransformationMatrix> head_model_pose(
-          TransformBasePose(base_pose));
+      auto head_model_pose = TransformBasePose(base_pose);
 
       // Get the positional delta between the base pose and the head model pose.
       float dx = head_model_pose->M41() - base_pose.M41();
@@ -108,8 +112,7 @@ XRStationaryReferenceSpace::TransformBaseInputPose(
 
       // Translate the controller by the same delta so that it shows up in the
       // right relative position.
-      std::unique_ptr<TransformationMatrix> pose(
-          std::make_unique<TransformationMatrix>(base_input_pose));
+      auto pose = std::make_unique<TransformationMatrix>(base_input_pose);
       pose->SetM41(pose->M41() + dx);
       pose->SetM42(pose->M42() + dy);
       pose->SetM43(pose->M43() + dz);
@@ -133,4 +136,10 @@ void XRStationaryReferenceSpace::OnReset() {
   DispatchEvent(*XRReferenceSpaceEvent::Create(event_type_names::kReset, this));
 }
 
+XRStationaryReferenceSpace* XRStationaryReferenceSpace::cloneWithOriginOffset(
+    XRRigidTransform* origin_offset) {
+  return MakeGarbageCollected<XRStationaryReferenceSpace>(
+      this->session(), origin_offset, subtype_);
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/xr/xr_stationary_reference_space.h

@@ -21,6 +21,7 @@ class XRStationaryReferenceSpace final : public XRReferenceSpace {
   };
 
   XRStationaryReferenceSpace(XRSession*, Subtype);
+  XRStationaryReferenceSpace(XRSession*, XRRigidTransform*, Subtype);
   ~XRStationaryReferenceSpace() override;
 
   std::unique_ptr<TransformationMatrix> DefaultPose() override;
@@ -35,6 +36,9 @@ class XRStationaryReferenceSpace final : public XRReferenceSpace {
   void OnReset() override;
 
  private:
+  XRStationaryReferenceSpace* cloneWithOriginOffset(
+      XRRigidTransform* origin_offset) override;
+
   void UpdateFloorLevelTransform();
 
   unsigned int display_info_id_ = 0;

third_party/blink/renderer/modules/xr/xr_unbounded_reference_space.cc

@@ -13,6 +13,11 @@ namespace blink {
 XRUnboundedReferenceSpace::XRUnboundedReferenceSpace(XRSession* session)
     : XRReferenceSpace(session) {}
 
+XRUnboundedReferenceSpace::XRUnboundedReferenceSpace(
+    XRSession* session,
+    XRRigidTransform* origin_offset)
+    : XRReferenceSpace(session, origin_offset) {}
+
 XRUnboundedReferenceSpace::~XRUnboundedReferenceSpace() = default;
 
 // No default pose for unbounded reference spaces.
@@ -36,4 +41,10 @@ void XRUnboundedReferenceSpace::OnReset() {
   DispatchEvent(*XRReferenceSpaceEvent::Create(event_type_names::kReset, this));
 }
 
+XRUnboundedReferenceSpace* XRUnboundedReferenceSpace::cloneWithOriginOffset(
+    XRRigidTransform* origin_offset) {
+  return MakeGarbageCollected<XRUnboundedReferenceSpace>(this->session(),
+                                                         origin_offset);
+}
+
 }  // namespace blink

third_party/blink/renderer/modules/xr/xr_unbounded_reference_space.h

@@ -14,7 +14,8 @@ class XRUnboundedReferenceSpace final : public XRReferenceSpace {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  XRUnboundedReferenceSpace(XRSession*);
+  explicit XRUnboundedReferenceSpace(XRSession*);
+  XRUnboundedReferenceSpace(XRSession*, XRRigidTransform*);
   ~XRUnboundedReferenceSpace() override;
 
   std::unique_ptr<TransformationMatrix> DefaultPose() override;
@@ -26,6 +27,9 @@ class XRUnboundedReferenceSpace final : public XRReferenceSpace {
   void OnReset() override;
 
  private:
+  XRUnboundedReferenceSpace* cloneWithOriginOffset(
+      XRRigidTransform* origin_offset) override;
+
   std::unique_ptr<TransformationMatrix> pose_transform_;
 };
 

third_party/blink/web_tests/external/wpt/webxr/idlharness.https.window-expected.txt

 This is a testharness.js-based test.
-Found 202 tests; 200 PASS, 2 FAIL, 0 TIMEOUT, 0 NOTRUN.
+Found 202 tests; 201 PASS, 1 FAIL, 0 TIMEOUT, 0 NOTRUN.
 PASS idl_test setup
 PASS Partial interface Navigator: original interface defined
 PASS Partial dictionary WebGLContextAttributes: original dictionary defined
@@ -74,7 +74,7 @@ PASS XRReferenceSpace interface object name
 PASS XRReferenceSpace interface: existence and properties of interface prototype object
 PASS XRReferenceSpace interface: existence and properties of interface prototype object's "constructor" property
 PASS XRReferenceSpace interface: existence and properties of interface prototype object's @@unscopables property
-FAIL XRReferenceSpace interface: operation getOffsetReferenceSpace(XRRigidTransform) assert_own_property: interface prototype object missing non-static operation expected property "getOffsetReferenceSpace" missing
+PASS XRReferenceSpace interface: operation getOffsetReferenceSpace(XRRigidTransform)
 PASS XRReferenceSpace interface: attribute onreset
 PASS XRBoundedReferenceSpace interface: existence and properties of interface object
 PASS XRBoundedReferenceSpace interface object length

third_party/blink/web_tests/external/wpt/webxr/xrFrame_getPose.https.html

@@ -37,7 +37,7 @@ let testFunction = function(session, fakeDeviceController, t) {
       let space2 = spaces[1];
 
       // Rotate 90 degrees about x axis, then move 1 meter along y axis.
-      space1.originOffset = new XRRigidTransform(
+      space1 = space1.getOffsetReferenceSpace(new XRRigidTransform(
         DOMPointReadOnly.fromPoint({
           x : 0,
           y : 1,
@@ -50,10 +50,10 @@ let testFunction = function(session, fakeDeviceController, t) {
           z : 0,
           w : Math.cos(radians / 2)
         })
-      );
+      ));
 
       // Rotate 90 degrees about z axis, then move 1 meter along x axis.
-      space2.originOffset = new XRRigidTransform(
+      space2 = space2.getOffsetReferenceSpace(new XRRigidTransform(
         DOMPointReadOnly.fromPoint({
           x : 1,
           y : 0,
@@ -66,7 +66,7 @@ let testFunction = function(session, fakeDeviceController, t) {
           z : Math.sin(radians / 2),
           w : Math.cos(radians / 2)
         })
-      );
+      ));
 
       let space1_from_space2 = xrFrame.getPose(space1, space2);
       const EXPECTED_POSE_MATRIX = [

third_party/blink/web_tests/webexposed/global-interface-listing-expected.txt

@@ -10626,10 +10626,9 @@ interface XRRay
 interface XRReferenceSpace : XRSpace
     attribute @@toStringTag
     getter onreset
-    getter originOffset
     method constructor
+    method getOffsetReferenceSpace
     setter onreset
-    setter originOffset
 interface XRReferenceSpaceEvent : Event
     attribute @@toStringTag
     getter referenceSpace

third_party/blink/web_tests/xr/xrReferenceSpace_originOffset.html

@@ -63,13 +63,19 @@ let testFunction =
     input_source.pointerOffset = POINTER_OFFSET_WITH_ROTATION;
     fakeDeviceController.addInputSource(input_source);
 
+    const RADIANS_90D = Math.PI / 2;
+
     const EXPECTED_VIEW_MATRIX_1 = [0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, -1, -1, -1, 1];
     const EXPECTED_GRIP_MATRIX_1 = [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 2, 3, 1];
     const EXPECTED_RAY_MATRIX_1 = [0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 2, 2, 1, 1];
 
-    const EXPECTED_VIEW_MATRIX_2 = [0.7419161200523376, 0.6434604525566101, -0.1884651929140091, 0, -0.1884651929140091, -0.06961867958307266, -0.9796091318130493, 0, -0.6434604525566101, 0.7623069882392883, 0.06961867958307266, 0, -4, 4, 9, 1];
-    const EXPECTED_GRIP_MATRIX_2 = [-0.6434604525566101, 0.06961867958307266, -0.7623069882392883, 0, 0.7419161200523376, -0.1884651929140091, -0.6434604525566101, 0, -0.1884651929140091, -0.9796091318130493, 0.06961867958307266, 0, 4.118846416473389, 8.01339340209961, -5.368484020233154, 1];
-    const EXPECTED_RAY_MATRIX_2 = [0.7419161200523376, -0.1884651929140091, -0.6434604525566101, 0, 0.6434604525566101, -0.06961867958307266, 0.7623069882392883, 0, -0.1884651929140091, -0.9796091318130493, 0.06961867958307266, 0, 2.643460512161255, 7.1730217933654785, -6.823479652404785, 1];
+    const EXPECTED_VIEW_MATRIX_2 = [0, 0, 1, 0, 0, 1, 0, 0, -1, 0, 0, 0, -4, 4, 9, 1];
+    const EXPECTED_GRIP_MATRIX_2 = [0, -1, 0, 0, 0, 0, -1, 0, 1, 0, 0, 0, -9, -2, -5, 1];
+    const EXPECTED_RAY_MATRIX_2 = [0, 0, -1, 0, 0, 1, 0, 0, 1, 0, 0, 0, -8, -4, -5, 1];
+
+    const EXPECTED_VIEW_MATRIX_3 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, -4, 6, 14, 1];
+    const EXPECTED_GRIP_MATRIX_3 = [0, -1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 5, -4, -14, 1];
+    const EXPECTED_RAY_MATRIX_3 = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 5, -6, -13, 1];
 
     // Must have a reference space to get input poses. eye-level doesn't apply
     // any transforms to the given matrix.
@@ -77,7 +83,7 @@ let testFunction =
       function OnFrame(time, frame) {
         let source = session.getInputSources()[0];
 
-        function CheckState(expected_view_matrix, expected_grip_matrix, expected_ray_matrix) {
+        function CheckState(referenceSpace, expected_view_matrix, expected_grip_matrix, expected_ray_matrix) {
           let pose = frame.getViewerPose(referenceSpace);
           let grip_pose = frame.getPose(source.gripSpace, referenceSpace);
           let input_pose = frame.getPose(source.targetRaySpace, referenceSpace);
@@ -91,25 +97,38 @@ let testFunction =
           assert_matrices_approx_equal(ray_matrix, expected_ray_matrix);
         }
 
-        CheckState(EXPECTED_VIEW_MATRIX_1, EXPECTED_GRIP_MATRIX_1, EXPECTED_RAY_MATRIX_1);
+        CheckState(referenceSpace, EXPECTED_VIEW_MATRIX_1, EXPECTED_GRIP_MATRIX_1, EXPECTED_RAY_MATRIX_1);
 
-        const new_position = {
-          x : 10,
-          y : -3,
-          z : 5
+        const new_position1 = {
+          x: 10,
+          y: -3,
+          z: 5,
+        };
+        const new_orientation1 = {
+          x: Math.sin(RADIANS_90D / 2),
+          y: 0,
+          z: 0,
+          w: Math.cos(RADIANS_90D / 2),
         };
 
-        const degrees_45 = Math.PI / 4;
-        const rotation = Math.sin(degrees_45 / 2);
-        const new_orientation = {
-          x : rotation,
-          y : rotation * -1,
-          z : rotation * 3,
-          w : Math.cos(degrees_45 / 2)
+        referenceSpace = referenceSpace.getOffsetReferenceSpace(new XRRigidTransform(new_position1, new_orientation1));
+        CheckState(referenceSpace, EXPECTED_VIEW_MATRIX_2, EXPECTED_GRIP_MATRIX_2, EXPECTED_RAY_MATRIX_2);
+
+        const new_position2 = {
+          x: 5,
+          y: 2,
+          z: 0,
+        };
+        const new_orientation2 = {
+          x: 0,
+          y: Math.sin(RADIANS_90D / 2),
+          z: 0,
+          w: Math.cos(RADIANS_90D / 2),
         };
 
-        referenceSpace.originOffset = new XRRigidTransform(new_position, new_orientation);
-        CheckState(EXPECTED_VIEW_MATRIX_2, EXPECTED_GRIP_MATRIX_2, EXPECTED_RAY_MATRIX_2);
+        referenceSpace = referenceSpace.getOffsetReferenceSpace(new XRRigidTransform(new_position2, new_orientation2));
+        CheckState(referenceSpace, EXPECTED_VIEW_MATRIX_3, EXPECTED_GRIP_MATRIX_3, EXPECTED_RAY_MATRIX_3);
+
         resolve();
       }
 

third_party/webxr_test_pages/webxr-samples/input-selection.html

@@ -429,8 +429,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
           {x: invPosition[0], y: invPosition[1], z: invPosition[2]},
           {x: invOrientation[0], y: invOrientation[1], z: invOrientation[2], w: invOrientation[3]});
 
-        // Update originOffset to use the teleported player position and orientation
-        refSpace.originOffset = xform;
+        // Update refSpace to use a new originOffset with the teleported player position and orientation
+        refSpace = refSpace.getOffsetReferenceSpace(xform);
 
         console.log('teleport to', trackingSpaceOriginInWorldSpace);
       }

third_party/webxr_test_pages/webxr-samples/room-scale.html

@@ -173,8 +173,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
                 // right level. (Here we're moving it 1.6 meters, which should
                 // *very* roughly align us with the eye height of an "average"
                 // adult human.)
-                refSpace.originOffset = new XRRigidTransform({y: -1.6});
-                return refSpace;
+                return refSpace.getOffsetReferenceSpace(new XRRigidTransform({y: -1.6}));
               });
             } else {
               throw e;