Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-03 12:40:06 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update test API, hook it up to webxr mocking

Browse source
This commit is contained in:
Manish Goregaokar 2019-07-10 11:33:11 -07:00
parent b818af794a
commit 0d5d1a3dc4
11 changed files with 158 additions and 79 deletions
Download patch file Download diff file Expand all files Collapse all files

81
components/script/dom/fakexrdevice.rs
View file

@ -7,43 +7,39 @@ use crate::dom::bindings::codegen::Bindings::FakeXRDeviceBinding::{
};
use crate::dom::bindings::codegen::Bindings::XRViewBinding::XREye;
use crate::dom::bindings::error::{Error, Fallible};
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
use crate::dom::bindings::reflector::{reflect_dom_object, Reflector};
use crate::dom::bindings::root::DomRoot;
use crate::dom::globalscope::GlobalScope;
use dom_struct::dom_struct;
use webvr_traits::{MockVRControlMsg, MockVRView, WebVRMsg};
use euclid::{TypedRigidTransform3D, TypedRotation3D, TypedTransform3D, TypedVector3D};
use ipc_channel::ipc::IpcSender;
use webxr_api::{MockDeviceMsg, View, Views};
#[dom_struct]
pub struct FakeXRDevice {
reflector: Reflector,
#[ignore_malloc_size_of = "defined in ipc-channel"]
sender: IpcSender<MockDeviceMsg>,
}
impl FakeXRDevice {
pub fn new_inherited() -> FakeXRDevice {
pub fn new_inherited(sender: IpcSender<MockDeviceMsg>) -> FakeXRDevice {
FakeXRDevice {
reflector: Reflector::new(),
sender,
}
}
pub fn new(global: &GlobalScope) -> DomRoot<FakeXRDevice> {
pub fn new(global: &GlobalScope, sender: IpcSender<MockDeviceMsg>) -> DomRoot<FakeXRDevice> {
reflect_dom_object(
Box::new(FakeXRDevice::new_inherited()),
Box::new(FakeXRDevice::new_inherited(sender)),
global,
FakeXRDeviceBinding::Wrap,
)
}
fn send_msg(&self, msg: MockVRControlMsg) {
self.global()
.as_window()
.webvr_thread()
.unwrap()
.send(WebVRMsg::MessageMockDisplay(msg))
.unwrap();
}
}
pub fn get_views(views: &[FakeXRViewInit]) -> Fallible<(MockVRView, MockVRView)> {
pub fn get_views(views: &[FakeXRViewInit]) -> Fallible<Views> {
if views.len() != 2 {
return Err(Error::NotSupported);
}
@ -66,45 +62,53 @@ pub fn get_views(views: &[FakeXRViewInit]) -> Fallible<(MockVRView, MockVRView)>
let mut proj_r = [0.; 16];
let v: Vec<_> = left.projectionMatrix.iter().map(|x| **x).collect();
proj_l.copy_from_slice(&v);
let proj_l = TypedTransform3D::from_array(proj_l);
let v: Vec<_> = right.projectionMatrix.iter().map(|x| **x).collect();
proj_r.copy_from_slice(&v);
let proj_r = TypedTransform3D::from_array(proj_r);
let mut offset_l = [0.; 3];
let mut offset_r = [0.; 3];
let v: Vec<_> = left.viewOffset.position.iter().map(|x| **x).collect();
offset_l.copy_from_slice(&v);
let v: Vec<_> = right.viewOffset.position.iter().map(|x| **x).collect();
offset_r.copy_from_slice(&v);
let left = MockVRView {
// spec defines offsets as origins, but mock API expects the inverse transform
let offset_l = get_origin(&left.viewOffset)?.inverse();
let offset_r = get_origin(&right.viewOffset)?.inverse();
let left = View {
projection: proj_l,
offset: offset_l,
transform: offset_l,
};
let right = MockVRView {
let right = View {
projection: proj_r,
offset: offset_r,
transform: offset_r,
};
Ok((left, right))
Ok(Views::Stereo(left, right))
}
pub fn get_origin(origin: &FakeXRRigidTransformInit) -> Fallible<([f32; 3], [f32; 4])> {
pub fn get_origin<T, U>(
origin: &FakeXRRigidTransformInit,
) -> Fallible<TypedRigidTransform3D<f32, T, U>> {
if origin.position.len() != 3 || origin.orientation.len() != 4 {
return Err(Error::Type("Incorrectly sized array".into()));
}
let mut p = [0.; 3];
let mut o = [0.; 4];
let v: Vec<_> = origin.position.iter().map(|x| **x).collect();
p.copy_from_slice(&v[0..3]);
let v: Vec<_> = origin.orientation.iter().map(|x| **x).collect();
o.copy_from_slice(&v);
let p = TypedVector3D::new(
*origin.position[0],
*origin.position[1],
*origin.position[2],
);
let o = TypedRotation3D::unit_quaternion(
*origin.orientation[0],
*origin.orientation[1],
*origin.orientation[2],
*origin.orientation[3],
);
Ok((p, o))
Ok(TypedRigidTransform3D::new(o, p))
}
impl FakeXRDeviceMethods for FakeXRDevice {
/// https://github.com/immersive-web/webxr-test-api/blob/master/explainer.md
fn SetViews(&self, views: Vec<FakeXRViewInit>) -> Fallible<()> {
let (left, right) = get_views(&views)?;
self.send_msg(MockVRControlMsg::SetViews(left, right));
let _ = self
.sender
.send(MockDeviceMsg::SetViews(get_views(&views)?));
Ok(())
}
@ -114,8 +118,9 @@ impl FakeXRDeviceMethods for FakeXRDevice {
origin: &FakeXRRigidTransformInit,
_emulated_position: bool,
) -> Fallible<()> {
let (position, orientation) = get_origin(origin)?;
self.send_msg(MockVRControlMsg::SetViewerPose(position, orientation));
let _ = self
.sender
.send(MockDeviceMsg::SetViewerOrigin(get_origin(origin)?));
Ok(())
}
}

6
components/script/dom/webidls/FakeXRDevice.webidl
View file

@ -36,13 +36,11 @@ dictionary FakeXRViewInit {
// https://immersive-web.github.io/webxr/#view-offset
required FakeXRRigidTransformInit viewOffset;
// https://immersive-web.github.io/webxr/#dom-xrwebgllayer-getviewport
required FakeXRViewportInit viewport;
required FakeXRDeviceResolution resolution;
};
// https://immersive-web.github.io/webxr/#xrviewport
dictionary FakeXRViewportInit {
required long x;
required long y;
dictionary FakeXRDeviceResolution {
required long width;
required long height;
};

2
components/script/dom/webidls/XRTest.webidl
View file

@ -29,7 +29,7 @@ dictionary FakeXRDeviceInit {
// The bounds coordinates. If null, bounded reference spaces are not supported.
sequence<FakeXRBoundsPoint> boundsCoodinates;
// Eye level used for calculating floor-level spaces
float eyeLevel = 1.5;
FakeXRRigidTransformInit floorOrigin;
FakeXRRigidTransformInit viewerOrigin;
};

99
components/script/dom/xrtest.rs
View file

@ -9,15 +9,21 @@
use crate::dom::bindings::codegen::Bindings::XRTestBinding::{
self, FakeXRDeviceInit, XRTestMethods,
};
use crate::dom::bindings::refcounted::{Trusted, TrustedPromise};
use crate::dom::bindings::reflector::{reflect_dom_object, DomObject, Reflector};
use crate::dom::bindings::root::DomRoot;
use crate::dom::fakexrdevice::{get_origin, get_views, FakeXRDevice};
use crate::dom::globalscope::GlobalScope;
use crate::dom::promise::Promise;
use crate::task_source::TaskSource;
use dom_struct::dom_struct;
use euclid::TypedRigidTransform3D;
use ipc_channel::ipc::IpcSender;
use ipc_channel::router::ROUTER;
use profile_traits::ipc;
use std::cell::Cell;
use std::rc::Rc;
use webvr_traits::{MockVRInit, WebVRMsg};
use webxr_api::{self, Error as XRError, MockDeviceInit, MockDeviceMsg};
#[dom_struct]
pub struct XRTest {
@ -40,11 +46,39 @@ impl XRTest {
XRTestBinding::Wrap,
)
}
fn device_obtained(
&self,
response: Result<IpcSender<MockDeviceMsg>, XRError>,
trusted: TrustedPromise,
) {
let promise = trusted.root();
if let Ok(sender) = response {
let device = FakeXRDevice::new(&self.global(), sender);
promise.resolve_native(&device);
} else {
promise.reject_native(&());
}
}
}
impl XRTestMethods for XRTest {
/// https://github.com/immersive-web/webxr-test-api/blob/master/explainer.md
fn SimulateDeviceConnection(&self, init: &FakeXRDeviceInit) -> Rc<Promise> {
#[derive(serde::Serialize, serde::Deserialize)]
pub struct MockDevice {
sender: IpcSender<Result<IpcSender<MockDeviceMsg>, XRError>>,
}
#[typetag::serde]
impl webxr_api::MockDeviceCallback for MockDevice {
fn callback(&mut self, result: Result<IpcSender<MockDeviceMsg>, XRError>) {
self.sender
.send(result)
.expect("mock device callback failed");
}
}
let p = Promise::new(&self.global());
if !init.supportsImmersive || self.session_started.get() {
@ -61,7 +95,19 @@ impl XRTestMethods for XRTest {
},
}
} else {
Default::default()
TypedRigidTransform3D::identity()
};
let floor_origin = if let Some(ref o) = init.floorOrigin {
match get_origin(&o) {
Ok(origin) => origin,
Err(e) => {
p.reject_error(e);
return p;
},
}
} else {
TypedRigidTransform3D::identity()
};
let views = match get_views(&init.views) {
@ -72,20 +118,47 @@ impl XRTestMethods for XRTest {
},
};
let init = MockVRInit {
viewer_origin: Some(origin),
views: Some(views),
eye_level: None,
let init = MockDeviceInit {
viewer_origin: origin,
views,
supports_immersive: init.supportsImmersive,
supports_unbounded: init.supportsUnbounded,
floor_origin,
};
self.session_started.set(true);
self.global()
.as_window()
.webvr_thread()
.unwrap()
.send(WebVRMsg::CreateMockDisplay(init))
.unwrap();
p.resolve_native(&FakeXRDevice::new(&self.global()));
let global = self.global();
let window = global.as_window();
let this = Trusted::new(self);
let mut trusted = Some(TrustedPromise::new(p.clone()));
let (task_source, canceller) = window
.task_manager()
.dom_manipulation_task_source_with_canceller();
let (sender, receiver) = ipc::channel(global.time_profiler_chan().clone()).unwrap();
ROUTER.add_route(
receiver.to_opaque(),
Box::new(move |message| {
let trusted = trusted
.take()
.expect("SimulateDeviceConnection callback called twice");
let this = this.clone();
let message = message
.to()
.expect("SimulateDeviceConnection callback given incorrect payload");
let _ = task_source.queue_with_canceller(
task!(request_session: move || {
this.root().device_obtained(message, trusted);
}),
&canceller,
);
}),
);
window
.webxr_registry()
.simulate_device_connection(init, MockDevice { sender });
p
}