Auto merge of #23547 - Manishearth:reference-spaces, r=asajeffrey

Update to latest WebXR spec, add tests

This pulls in a bunch of the newer stuff. I think with this PR we're spec-compatible for the things we support.

<s>For testing I'm likely going to write custom tests rather than adapting the existing ones, as a first pass, but when I start adapting the existing ones these changes will make it smoother.</s>

This PR also adds some pretty simple tests that deal with core functionality.

r? @jdm @asajeffrey

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/23547)
<!-- Reviewable:end -->

components/script/dom/fakexrdevicecontroller.rs

@@ -62,8 +62,8 @@ impl FakeXRDeviceControllerMethods for FakeXRDeviceController {
 
         if left.projectionMatrix.len() != 16 ||
             right.projectionMatrix.len() != 16 ||
-            left.viewOffset.position.len() != 4 ||
-            right.viewOffset.position.len() != 4
+            left.viewOffset.position.len() != 3 ||
+            right.viewOffset.position.len() != 3
         {
             return Err(Error::Type("Incorrectly sized array".into()));
         }

components/script/dom/mod.rs

@@ -552,7 +552,6 @@ pub mod xrrenderstate;
 pub mod xrrigidtransform;
 pub mod xrsession;
 pub mod xrspace;
-pub mod xrstationaryreferencespace;
 pub mod xrtest;
 pub mod xrview;
 pub mod xrviewerpose;

components/script/dom/webglrenderingcontext.rs

@@ -24,6 +24,7 @@ use crate::dom::htmlcanvaselement::utils as canvas_utils;
 use crate::dom::htmlcanvaselement::HTMLCanvasElement;
 use crate::dom::htmliframeelement::HTMLIFrameElement;
 use crate::dom::node::{document_from_node, window_from_node, Node, NodeDamage};
+use crate::dom::promise::Promise;
 use crate::dom::webgl_extensions::WebGLExtensions;
 use crate::dom::webgl_validations::tex_image_2d::{
     CommonCompressedTexImage2DValidatorResult, CommonTexImage2DValidator,
@@ -76,6 +77,7 @@ use servo_config::pref;
 use std::cell::Cell;
 use std::cmp;
 use std::ptr::{self, NonNull};
+use std::rc::Rc;
 
 // From the GLES 2.0.25 spec, page 85:
 //
@@ -4090,6 +4092,14 @@ impl WebGLRenderingContextMethods for WebGLRenderingContext {
         handle_potential_webgl_error!(self, self.validate_ownership(program), return None);
         handle_potential_webgl_error!(self, program.attached_shaders().map(Some), None)
     }
+
+    /// https://immersive-web.github.io/webxr/#dom-webglrenderingcontextbase-makexrcompatible
+    fn MakeXRCompatible(&self) -> Rc<Promise> {
+        // XXXManishearth Fill in with compatibility checks when rust-webxr supports this
+        let p = Promise::new(&self.global());
+        p.resolve_native(&());
+        p
+    }
 }
 
 pub trait LayoutCanvasWebGLRenderingContextHelpers {

components/script/dom/webidls/XRReferenceSpace.webidl

@@ -4,8 +4,16 @@
 
 // https://immersive-web.github.io/webxr/#xrreferencespace-interface
 
+enum XRReferenceSpaceType {
+  "viewer",
+  "local",
+  "local-floor",
+  "bounded-floor",
+  "unbounded"
+};
+
 [SecureContext, Exposed=Window, Pref="dom.webxr.enabled"]
 interface XRReferenceSpace : XRSpace {
-  attribute XRRigidTransform originOffset;
+  XRReferenceSpace getOffsetReferenceSpace(XRRigidTransform originOffset);
   // attribute EventHandler onreset;
 };

components/script/dom/webidls/XRSession.webidl

@@ -20,10 +20,9 @@ interface XRSession : EventTarget {
   readonly attribute XREnvironmentBlendMode environmentBlendMode;
 
   readonly attribute XRRenderState renderState;
-  [SameObject] readonly attribute XRSpace viewerSpace;
 
   // // Methods
-  Promise<XRReferenceSpace> requestReferenceSpace(XRReferenceSpaceOptions options);
+  Promise<XRReferenceSpace> requestReferenceSpace(XRReferenceSpaceType type);
 
   // workaround until we have FrozenArray
   // see https://github.com/servo/servo/issues/10427#issuecomment-449593626
@@ -45,15 +44,3 @@ interface XRSession : EventTarget {
   // attribute EventHandler onselectstart;
   // attribute EventHandler onselectend;
 };
-
-enum XRReferenceSpaceType {
-  "identity",
-  "stationary",
-  "bounded",
-  "unbounded"
-};
-
-dictionary XRReferenceSpaceOptions {
-  required XRReferenceSpaceType type;
-  XRStationaryReferenceSpaceSubtype subtype;
-};

components/script/dom/webidls/XRStationaryReferenceSpace.webidl

@@ -1,16 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-
-// https://immersive-web.github.io/webxr/#xrstationaryreferencespace-interface
-
-enum XRStationaryReferenceSpaceSubtype {
-  "eye-level",
-  "floor-level",
-  "position-disabled"
-};
-
-[SecureContext, Exposed=Window, Pref="dom.webxr.enabled"]
-interface XRStationaryReferenceSpace: XRReferenceSpace {
-  // readonly attribute XRStationaryReferenceSpaceSubtype subtype;
-};

components/script/dom/webidls/XRWebGLLayer.webidl

@@ -41,3 +41,7 @@ interface XRWebGLLayer : XRLayer {
   // // Static Methods
   // static double getNativeFramebufferScaleFactor(XRSession session);
 };
+
+partial interface WebGLRenderingContext {
+    [Pref="dom.webxr.enabled"] Promise<void> makeXRCompatible();
+};

components/script/dom/xrreferencespace.rs

@@ -4,37 +4,57 @@
 
 use crate::dom::bindings::codegen::Bindings::XRReferenceSpaceBinding;
 use crate::dom::bindings::codegen::Bindings::XRReferenceSpaceBinding::XRReferenceSpaceMethods;
+use crate::dom::bindings::codegen::Bindings::XRReferenceSpaceBinding::XRReferenceSpaceType;
 use crate::dom::bindings::inheritance::Castable;
-use crate::dom::bindings::reflector::reflect_dom_object;
-use crate::dom::bindings::root::{DomRoot, MutDom};
+use crate::dom::bindings::reflector::{reflect_dom_object, DomObject};
+use crate::dom::bindings::root::{Dom, DomRoot};
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::xrrigidtransform::XRRigidTransform;
 use crate::dom::xrsession::XRSession;
 use crate::dom::xrspace::XRSpace;
-use crate::dom::xrstationaryreferencespace::XRStationaryReferenceSpace;
 use dom_struct::dom_struct;
-use euclid::RigidTransform3D;
+use euclid::{RigidTransform3D, Vector3D};
 use webvr_traits::WebVRFrameData;
 
 #[dom_struct]
 pub struct XRReferenceSpace {
     xrspace: XRSpace,
-    transform: MutDom<XRRigidTransform>,
+    offset: Dom<XRRigidTransform>,
+    ty: XRReferenceSpaceType,
 }
 
 impl XRReferenceSpace {
-    pub fn new_inherited(session: &XRSession, transform: &XRRigidTransform) -> XRReferenceSpace {
+    pub fn new_inherited(
+        session: &XRSession,
+        offset: &XRRigidTransform,
+        ty: XRReferenceSpaceType,
+    ) -> XRReferenceSpace {
         XRReferenceSpace {
             xrspace: XRSpace::new_inherited(session),
-            transform: MutDom::new(transform),
+            offset: Dom::from_ref(offset),
+            ty,
         }
     }
 
     #[allow(unused)]
-    pub fn identity(global: &GlobalScope, session: &XRSession) -> DomRoot<XRReferenceSpace> {
-        let transform = XRRigidTransform::identity(global);
+    pub fn new(
+        global: &GlobalScope,
+        session: &XRSession,
+        ty: XRReferenceSpaceType,
+    ) -> DomRoot<XRReferenceSpace> {
+        let offset = XRRigidTransform::identity(global);
+        Self::new_offset(global, session, ty, &offset)
+    }
+
+    #[allow(unused)]
+    pub fn new_offset(
+        global: &GlobalScope,
+        session: &XRSession,
+        ty: XRReferenceSpaceType,
+        offset: &XRRigidTransform,
+    ) -> DomRoot<XRReferenceSpace> {
         reflect_dom_object(
-            Box::new(XRReferenceSpace::new_inherited(session, &transform)),
+            Box::new(XRReferenceSpace::new_inherited(session, &offset, ty)),
             global,
             XRReferenceSpaceBinding::Wrap,
         )
@@ -42,14 +62,16 @@ impl XRReferenceSpace {
 }
 
 impl XRReferenceSpaceMethods for XRReferenceSpace {
-    /// https://immersive-web.github.io/webxr/#dom-xrreferencespace-originoffset
-    fn SetOriginOffset(&self, transform: &XRRigidTransform) {
-        self.transform.set(transform);
-    }
-
-    /// https://immersive-web.github.io/webxr/#dom-xrreferencespace-originoffset
-    fn OriginOffset(&self) -> DomRoot<XRRigidTransform> {
-        self.transform.get()
+    /// https://immersive-web.github.io/webxr/#dom-xrreferencespace-getoffsetreferencespace
+    fn GetOffsetReferenceSpace(&self, new: &XRRigidTransform) -> DomRoot<Self> {
+        let offset = new.transform().pre_mul(&self.offset.transform());
+        let offset = XRRigidTransform::new(&self.global(), offset);
+        Self::new_offset(
+            &self.global(),
+            self.upcast::<XRSpace>().session(),
+            self.ty,
+            &offset,
+        )
     }
 }
 
@@ -68,7 +90,7 @@ impl XRReferenceSpace {
         //                        = (get_unoffset_pose(space) * offset).inverse() * get_pose(viewer_space)
         //                        = offset.inverse() * get_unoffset_pose(space).inverse() * get_pose(viewer_space)
         //                        = offset.inverse() * get_unoffset_viewer_pose(space)
-        let offset = self.transform.get().transform();
+        let offset = self.offset.transform();
         let inverse = offset.inverse();
         inverse.pre_mul(&pose)
     }
@@ -77,13 +99,36 @@ impl XRReferenceSpace {
     ///
     /// Does not apply originOffset, use get_viewer_pose instead if you need it
     pub fn get_unoffset_viewer_pose(&self, base_pose: &WebVRFrameData) -> RigidTransform3D<f64> {
-        if let Some(stationary) = self.downcast::<XRStationaryReferenceSpace>() {
-            stationary.get_unoffset_viewer_pose(base_pose)
-        } else {
-            // non-subclassed XRReferenceSpaces exist, obtained via the "identity"
-            // type. These poses are equivalent to the viewer pose and follow the headset
-            // around, so the viewer is always at an identity transform with respect to them
+        let viewer_pose = XRSpace::pose_to_transform(&base_pose.pose);
+        // all math is in column-vector notation
+        // we use the following equation to verify correctness here:
+        // get_viewer_pose(space) = get_pose(space).inverse() * get_pose(viewer_space)
+        match self.ty {
+            XRReferenceSpaceType::Local => {
+                // get_viewer_pose(eye_level) = get_pose(eye_level).inverse() * get_pose(viewer_space)
+                //                            = I * viewer_pose
+                //                            = viewer_pose
+
+                // we get viewer poses in eye-level space by default
+                viewer_pose
+            },
+            XRReferenceSpaceType::Local_floor => {
+                // XXXManishearth support getting floor info from stage parameters
+
+                // get_viewer_pose(floor_level) = get_pose(floor_level).inverse() * get_pose(viewer_space)
+                //                            = Translate(-2).inverse() * viewer_pose
+                //                            = Translate(2) * viewer_pose
+
+                // assume approximate user height of 2 meters
+                let floor_to_eye: RigidTransform3D<f64> = Vector3D::new(0., 2., 0.).into();
+                floor_to_eye.pre_mul(&viewer_pose)
+            },
+            XRReferenceSpaceType::Viewer => {
+                // This reference space follows the viewer around, so the viewer is
+                // always at an identity transform with respect to it
                 RigidTransform3D::identity()
+            },
+            _ => unimplemented!(),
         }
     }
 
@@ -96,7 +141,7 @@ impl XRReferenceSpace {
         let pose = self.get_unoffset_pose(base_pose);
 
         // This may change, see https://github.com/immersive-web/webxr/issues/567
-        let offset = self.transform.get().transform();
+        let offset = self.offset.transform();
         offset.post_mul(&pose)
     }
 
@@ -104,13 +149,21 @@ impl XRReferenceSpace {
     ///
     /// Does not apply originOffset, use get_viewer_pose instead if you need it
     pub fn get_unoffset_pose(&self, base_pose: &WebVRFrameData) -> RigidTransform3D<f64> {
-        if let Some(stationary) = self.downcast::<XRStationaryReferenceSpace>() {
-            stationary.get_unoffset_pose(base_pose)
-        } else {
-            // non-subclassed XRReferenceSpaces exist, obtained via the "identity"
-            // type. These are equivalent to the viewer pose and follow the headset
-            // around
-            XRSpace::pose_to_transform(&base_pose.pose)
+        match self.ty {
+            XRReferenceSpaceType::Local => {
+                // The eye-level pose is basically whatever the headset pose was at t=0, which
+                // for most devices is (0, 0, 0)
+                RigidTransform3D::identity()
+            },
+            XRReferenceSpaceType::Local_floor => {
+                // XXXManishearth support getting floor info from stage parameters
+
+                // Assume approximate height of 2m
+                // the floor-level space is 2m below the eye-level space, which is (0, 0, 0)
+                Vector3D::new(0., -2., 0.).into()
+            },
+            XRReferenceSpaceType::Viewer => XRSpace::pose_to_transform(&base_pose.pose),
+            _ => unimplemented!(),
         }
     }
 }

components/script/dom/xrsession.rs

@@ -5,12 +5,11 @@
 use crate::compartments::InCompartment;
 use crate::dom::bindings::codegen::Bindings::VRDisplayBinding::VRDisplayMethods;
 use crate::dom::bindings::codegen::Bindings::XRBinding::XRSessionMode;
+use crate::dom::bindings::codegen::Bindings::XRReferenceSpaceBinding::XRReferenceSpaceType;
 use crate::dom::bindings::codegen::Bindings::XRRenderStateBinding::XRRenderStateInit;
 use crate::dom::bindings::codegen::Bindings::XRSessionBinding;
 use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XREnvironmentBlendMode;
 use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XRFrameRequestCallback;
-use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XRReferenceSpaceOptions;
-use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XRReferenceSpaceType;
 use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XRSessionMethods;
 use crate::dom::bindings::error::Error;
 use crate::dom::bindings::reflector::{reflect_dom_object, DomObject};
@@ -24,7 +23,6 @@ use crate::dom::xrlayer::XRLayer;
 use crate::dom::xrreferencespace::XRReferenceSpace;
 use crate::dom::xrrenderstate::XRRenderState;
 use crate::dom::xrspace::XRSpace;
-use crate::dom::xrstationaryreferencespace::XRStationaryReferenceSpace;
 use dom_struct::dom_struct;
 use std::rc::Rc;
 
@@ -87,12 +85,6 @@ impl XRSessionMethods for XRSession {
         )
     }
 
-    // https://immersive-web.github.io/webxr/#dom-xrsession-viewerspace
-    fn ViewerSpace(&self) -> DomRoot<XRSpace> {
-        self.viewer_space
-            .or_init(|| XRSpace::new_viewerspace(&self.global(), &self))
-    }
-
     /// https://immersive-web.github.io/webxr/#dom-xrsession-requestanimationframe
     fn UpdateRenderState(&self, init: &XRRenderStateInit, comp: InCompartment) -> Rc<Promise> {
         let p = Promise::new_in_current_compartment(&self.global(), comp);
@@ -116,11 +108,7 @@ impl XRSessionMethods for XRSession {
     }
 
     /// https://immersive-web.github.io/webxr/#dom-xrsession-requestreferencespace
-    fn RequestReferenceSpace(
-        &self,
-        options: &XRReferenceSpaceOptions,
-        comp: InCompartment,
-    ) -> Rc<Promise> {
+    fn RequestReferenceSpace(&self, ty: XRReferenceSpaceType, comp: InCompartment) -> Rc<Promise> {
         let p = Promise::new_in_current_compartment(&self.global(), comp);
 
         // https://immersive-web.github.io/webxr/#create-a-reference-space
@@ -128,27 +116,14 @@ impl XRSessionMethods for XRSession {
         // XXXManishearth reject based on session type
         // https://github.com/immersive-web/webxr/blob/master/spatial-tracking-explainer.md#practical-usage-guidelines
 
-        match options.type_ {
-            XRReferenceSpaceType::Identity => {
-                p.resolve_native(&XRReferenceSpace::identity(&self.global(), self));
-            },
-            XRReferenceSpaceType::Stationary => {
-                if let Some(subtype) = options.subtype {
-                    p.resolve_native(&XRStationaryReferenceSpace::new(
-                        &self.global(),
-                        self,
-                        subtype,
-                    ));
-                } else {
-                    p.reject_error(Error::Type(format!(
-                        "stationary XRReferenceSpaces must specify a subtype"
-                    )))
-                }
-            },
-            XRReferenceSpaceType::Bounded | XRReferenceSpaceType::Unbounded => {
+        match ty {
+            XRReferenceSpaceType::Bounded_floor | XRReferenceSpaceType::Unbounded => {
                 // XXXManishearth eventually support these
                 p.reject_error(Error::NotSupported)
             },
+            ty => {
+                p.resolve_native(&XRReferenceSpace::new(&self.global(), self, ty));
+            },
         }
 
         p

components/script/dom/xrspace.rs

@@ -19,7 +19,6 @@ use webvr_traits::{WebVRFrameData, WebVRPose};
 pub struct XRSpace {
     eventtarget: EventTarget,
     session: Dom<XRSession>,
-    is_viewerspace: bool,
     input_source: MutNullableDom<XRInputSource>,
 }
 
@@ -28,33 +27,14 @@ impl XRSpace {
         XRSpace {
             eventtarget: EventTarget::new_inherited(),
             session: Dom::from_ref(session),
-            is_viewerspace: false,
             input_source: Default::default(),
         }
     }
 
-    fn new_viewerspace_inner(session: &XRSession) -> XRSpace {
-        XRSpace {
-            eventtarget: EventTarget::new_inherited(),
-            session: Dom::from_ref(session),
-            is_viewerspace: true,
-            input_source: Default::default(),
-        }
-    }
-
-    pub fn new_viewerspace(global: &GlobalScope, session: &XRSession) -> DomRoot<XRSpace> {
-        reflect_dom_object(
-            Box::new(XRSpace::new_viewerspace_inner(session)),
-            global,
-            XRSpaceBinding::Wrap,
-        )
-    }
-
     fn new_inputspace_inner(session: &XRSession, input: &XRInputSource) -> XRSpace {
         XRSpace {
             eventtarget: EventTarget::new_inherited(),
             session: Dom::from_ref(session),
-            is_viewerspace: false,
             input_source: MutNullableDom::new(Some(input)),
         }
     }
@@ -81,8 +61,6 @@ impl XRSpace {
     pub fn get_pose(&self, base_pose: &WebVRFrameData) -> RigidTransform3D<f64> {
         if let Some(reference) = self.downcast::<XRReferenceSpace>() {
             reference.get_pose(base_pose)
-        } else if self.is_viewerspace {
-            XRSpace::pose_to_transform(&base_pose.pose)
         } else if let Some(source) = self.input_source.get() {
             XRSpace::pose_to_transform(&source.pose())
         } else {

components/script/dom/xrstationaryreferencespace.rs

@@ -1,121 +0,0 @@
-/* This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
-
-use crate::dom::bindings::codegen::Bindings::XRStationaryReferenceSpaceBinding;
-use crate::dom::bindings::codegen::Bindings::XRStationaryReferenceSpaceBinding::XRStationaryReferenceSpaceSubtype;
-use crate::dom::bindings::reflector::reflect_dom_object;
-use crate::dom::bindings::root::DomRoot;
-use crate::dom::globalscope::GlobalScope;
-use crate::dom::xrreferencespace::XRReferenceSpace;
-use crate::dom::xrrigidtransform::XRRigidTransform;
-use crate::dom::xrsession::XRSession;
-use crate::dom::xrspace::XRSpace;
-use dom_struct::dom_struct;
-use euclid::{RigidTransform3D, Vector3D};
-use webvr_traits::WebVRFrameData;
-
-#[dom_struct]
-pub struct XRStationaryReferenceSpace {
-    xrreferencespace: XRReferenceSpace,
-    ty: XRStationaryReferenceSpaceSubtype,
-}
-
-#[allow(unused)]
-impl XRStationaryReferenceSpace {
-    pub fn new_inherited(
-        session: &XRSession,
-        ty: XRStationaryReferenceSpaceSubtype,
-        transform: &XRRigidTransform,
-    ) -> XRStationaryReferenceSpace {
-        XRStationaryReferenceSpace {
-            xrreferencespace: XRReferenceSpace::new_inherited(session, transform),
-            ty,
-        }
-    }
-
-    pub fn new(
-        global: &GlobalScope,
-        session: &XRSession,
-        ty: XRStationaryReferenceSpaceSubtype,
-    ) -> DomRoot<XRStationaryReferenceSpace> {
-        let transform = XRRigidTransform::identity(global);
-        reflect_dom_object(
-            Box::new(XRStationaryReferenceSpace::new_inherited(
-                session, ty, &transform,
-            )),
-            global,
-            XRStationaryReferenceSpaceBinding::Wrap,
-        )
-    }
-}
-
-impl XRStationaryReferenceSpace {
-    /// Gets pose of the viewer with respect to this space
-    ///
-    /// Does not apply originOffset, use get_viewer_pose on XRReferenceSpace instead
-    pub fn get_unoffset_viewer_pose(&self, viewer_pose: &WebVRFrameData) -> RigidTransform3D<f64> {
-        let viewer_pose = XRSpace::pose_to_transform(&viewer_pose.pose);
-        // all math is in column-vector notation
-        // we use the following equation to verify correctness here:
-        // get_viewer_pose(space) = get_pose(space).inverse() * get_pose(viewer_space)
-        match self.ty {
-            XRStationaryReferenceSpaceSubtype::Eye_level => {
-                // get_viewer_pose(eye_level) = get_pose(eye_level).inverse() * get_pose(viewer_space)
-                //                            = I * viewer_pose
-                //                            = viewer_pose
-
-                // we get viewer poses in eye-level space by default
-                viewer_pose
-            },
-            XRStationaryReferenceSpaceSubtype::Floor_level => {
-                // XXXManishearth support getting floor info from stage parameters
-
-                // get_viewer_pose(floor_level) = get_pose(floor_level).inverse() * get_pose(viewer_space)
-                //                            = Translate(-2).inverse() * viewer_pose
-                //                            = Translate(2) * viewer_pose
-
-                // assume approximate user height of 2 meters
-                let floor_to_eye: RigidTransform3D<f64> = Vector3D::new(0., 2., 0.).into();
-                floor_to_eye.pre_mul(&viewer_pose)
-            },
-            XRStationaryReferenceSpaceSubtype::Position_disabled => {
-                // get_viewer_pose(pos_disabled) = get_pose(pos_disabled).inverse() * get_pose(viewer_space)
-                //                            = viewer_pose.translation.inverse() * viewer_pose
-                //                            = viewer_pose.translation.inverse() * viewer_pose.translation
-                //                                                                * viewer_pose.rotation
-                //                            = viewer_pose.rotation
-
-                // This space follows the user around, but does not mirror the user's orientation
-                // Thus, the viewer's pose relative to this space is simply their orientation
-                viewer_pose.rotation.into()
-            },
-        }
-    }
-
-    /// Gets pose represented by this space
-    ///
-    /// Does not apply originOffset, use get_pose on XRReferenceSpace instead
-    pub fn get_unoffset_pose(&self, viewer_pose: &WebVRFrameData) -> RigidTransform3D<f64> {
-        // XXXManishearth add floor-level transform for floor-level and disable position in position-disabled
-        match self.ty {
-            XRStationaryReferenceSpaceSubtype::Eye_level => {
-                // The eye-level pose is basically whatever the headset pose was at t=0, which
-                // for most devices is (0, 0, 0)
-                RigidTransform3D::identity()
-            },
-            XRStationaryReferenceSpaceSubtype::Floor_level => {
-                // XXXManishearth support getting floor info from stage parameters
-
-                // Assume approximate height of 2m
-                // the floor-level space is 2m below the eye-level space, which is (0, 0, 0)
-                Vector3D::new(0., -2., 0.).into()
-            },
-            XRStationaryReferenceSpaceSubtype::Position_disabled => {
-                // This space follows the user around, but does not mirror the user's orientation
-                let viewer_pose = XRSpace::pose_to_transform(&viewer_pose.pose);
-                viewer_pose.translation.into()
-            },
-        }
-    }
-}

tests/wpt/mozilla/meta/MANIFEST.json

@@ -11222,7 +11222,10 @@
      {}
     ]
    ],
-   "mozilla/xmlhttprequest_url.html": []
+   "mozilla/xmlhttprequest_url.html": [],
+   "webxr/resources/webxr-util.js": [
+    []
+   ]
   },
   "testharness": {
    "bluetooth/advertisingEvent/watchAdvertisements-succeeds.html": [
@@ -13927,6 +13930,18 @@
      "mozilla/xmlhttprequest_url.html",
      {}
     ]
+   ],
+   "webxr/create_session.html": [
+    [
+     "webxr/create_session.html",
+     {}
+    ]
+   ],
+   "webxr/obtain_frame.html": [
+    [
+     "webxr/obtain_frame.html",
+     {}
+    ]
    ]
   },
   "visual": {
@@ -21112,6 +21127,18 @@
   "mozilla/xmlhttprequest_url.html": [
    "e5d10f27c06e1febd3bb70f8f128194fc3f63861",
    "testharness"
+  ],
+  "webxr/create_session.html": [
+   "306ab85d3b1b914d2dd7c11a3b03dccd990148ae",
+   "testharness"
+  ],
+  "webxr/obtain_frame.html": [
+   "1089bb25c2f6b26db4e21b6bf07c28add3fee5ec",
+   "testharness"
+  ],
+  "webxr/resources/webxr-util.js": [
+   "505173c82998a80b1e543f1a18aefaf1891f8269",
+   "support"
   ]
  },
  "url_base": "/_mozilla/",

tests/wpt/mozilla/meta/webxr/__dir__.ini

@@ -0,0 +1,2 @@
+prefs: [dom.webxr.enabled:true, dom.webxr.test:true]
+

tests/wpt/mozilla/tests/webxr/create_session.html

@@ -0,0 +1,15 @@
+<html>
+    <head>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+    </head>
+    <body>
+        <script>
+          async_test(function(t) {
+              navigator.xr.test.simulateDeviceConnection({supportsImmersive: true}).then((m) => {
+                return navigator.xr.requestSession({mode: "immersive-vr"})
+              }).then(() => t.done());
+          });
+        </script>
+    </body>
+</html>

tests/wpt/mozilla/tests/webxr/obtain_frame.html

@@ -0,0 +1,62 @@
+<html>
+    <head>
+        <script src="/resources/testharness.js"></script>
+        <script src="/resources/testharnessreport.js"></script>
+        <script src="./resources/webxr-util.js"></script>
+    </head>
+    <body>
+          <canvas id="canvas" width="640" height="480"></canvas>
+
+        <script>
+          let session;
+          let mock;
+          let canvas = document.getElementById("canvas");
+          let gl = canvas.getContext('webgl');
+
+          promise_test(function() {
+              return navigator.xr.test.simulateDeviceConnection({supportsImmersive: true}).then((m) => {
+                mock = m;
+                mock.setViewerOrigin({position: [0.5, 0, 0, 1], orientation: [0, 0, 0, 1] });
+                mock.setViews(TEST_VIEWS);
+                return navigator.xr.requestSession({mode: "immersive-vr"});
+              })
+              .then((s) => {
+                session = s;
+                return session.updateRenderState({"baseLayer": new XRWebGLLayer(session, gl, {})})
+              })
+              .then(() => {
+                return new Promise(function(resolve, reject) {
+                  session.requestAnimationFrame(function(time, frame) {
+                      session.requestReferenceSpace("local").then((space) => {
+                      let pose = frame.getViewerPose(space);
+                      for (view of pose.views) {
+                        assert_matrix_approx_equals(view.projectionMatrix, VALID_PROJECTION_MATRIX, 0.001, "left projection matrix");
+
+                        if (view.eye == "left") {
+                          assert_matrix_approx_equals(view.transform.matrix, [1,0,0,0, 0,1,0,0, 0,0,1,0, 0.4,0,0,1], 0.001, "left transform");
+                          let position = view.transform.position;
+                          assert_approx_equals(position.x, 0.4, 0.001, "left x value");
+                          assert_approx_equals(position.y, 0, 0.001, "left y value");
+                          assert_approx_equals(position.z, 0, 0.001, "left z value");
+                          assert_approx_equals(position.w, 1, 0.001, "left w value");
+                        } else if (view.eye == "right") {
+                          assert_matrix_approx_equals(view.transform.matrix, [1,0,0,0, 0,1,0,0, 0,0,1,0, 0.6,0,0,1], 0.001, "right transform");
+                          let position = view.transform.position;
+                          assert_approx_equals(position.x, 0.6, 0.001, "left x value");
+                          assert_approx_equals(position.y, 0, 0.001, "left y value");
+                          assert_approx_equals(position.z, 0, 0.001, "left z value");
+                          assert_approx_equals(position.w, 1, 0.001, "left w value");
+                        } else {
+                          reject("got unknown view");
+                        }
+                      }
+                      resolve();
+                    }).catch((e) => reject(e));
+                  });
+                });
+
+              });
+          });
+        </script>
+    </body>
+</html>

tests/wpt/mozilla/tests/webxr/resources/webxr-util.js

@@ -0,0 +1,17 @@
+// pieced together from various things in wpt/webxr/resources
+
+const VALID_PROJECTION_MATRIX = [1, 0, 0, 0, 0, 1, 0, 0, 3, 2, -1, -1, 0, 0, -0.2, 0];
+const LEFT_OFFSET = {position: [-0.1, 0, 0], orientation: [0,0,0,0]};
+const RIGHT_OFFSET = {position: [0.1, 0, 0], orientation: [0,0,0,0]};
+
+let assert_matrix_approx_equals = function(m1, m2, epsilon, prefix = "") {
+  assert_equals(m1.length, m2.length, prefix + "Matrix lengths should match");
+  for(var i = 0; i < m1.length; ++i) {
+    assert_approx_equals(m1[i], m2[i], epsilon, m1 + prefix + "Component number " + i + " should match");
+  }
+}
+
+const TEST_VIEWS = [
+    {eye: "left", projectionMatrix: VALID_PROJECTION_MATRIX, viewOffset: LEFT_OFFSET},
+    {eye: "right", projectionMatrix: VALID_PROJECTION_MATRIX, viewOffset: RIGHT_OFFSET}
+];