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

Allow VR RAF loop to handle changes in the layer, support pending renderstates

Browse source
This commit is contained in:
Manish Goregaokar 2019-01-15 00:22:20 -08:00
parent 401b470e90
commit e20909cf43
4 changed files with 170 additions and 44 deletions
Download patch file Download diff file Expand all files Collapse all files

144
components/script/dom/vrdisplay.rs
View file

@ -13,7 +13,9 @@ use crate::dom::bindings::codegen::Bindings::VRLayerBinding::VRLayer;
use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextMethods;
use crate::dom::bindings::codegen::Bindings::WindowBinding::FrameRequestCallback;
use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use crate::dom::bindings::codegen::Bindings::XRRenderStateBinding::XRRenderStateInit;
use crate::dom::bindings::codegen::Bindings::XRSessionBinding::XRFrameRequestCallback;
use crate::dom::bindings::codegen::Bindings::XRWebGLLayerBinding::XRWebGLLayerMethods;
use crate::dom::bindings::error::Error;
use crate::dom::bindings::inheritance::Castable;
use crate::dom::bindings::num::Finite;
@ -34,10 +36,11 @@ use crate::dom::vrstageparameters::VRStageParameters;
use crate::dom::webglrenderingcontext::WebGLRenderingContext;
use crate::dom::xrframe::XRFrame;
use crate::dom::xrsession::XRSession;
use crate::dom::xrwebgllayer::XRWebGLLayer;
use crate::script_runtime::CommonScriptMsg;
use crate::script_runtime::ScriptThreadEventCategory::WebVREvent;
use crate::task_source::{TaskSource, TaskSourceName};
use canvas_traits::webgl::{webgl_channel, WebGLReceiver, WebVRCommand};
use canvas_traits::webgl::{webgl_channel, WebGLMsgSender, WebGLReceiver, WebVRCommand};
use crossbeam_channel::{unbounded, Sender};
use dom_struct::dom_struct;
use ipc_channel::ipc::IpcSender;
@ -74,6 +77,10 @@ pub struct VRDisplay {
raf_callback_list: DomRefCell<Vec<(u32, Option<Rc<FrameRequestCallback>>)>>,
#[ignore_malloc_size_of = "closures are hard"]
xr_raf_callback_list: DomRefCell<Vec<(u32, Option<Rc<XRFrameRequestCallback>>)>>,
/// When there isn't any layer_ctx the RAF thread needs to be "woken up"
raf_wakeup_sender: DomRefCell<Option<Sender<()>>>,
#[ignore_malloc_size_of = "Rc is hard"]
pending_renderstate_updates: DomRefCell<Vec<(XRRenderStateInit, Rc<Promise>)>>,
// Compositor VRFrameData synchonization
frame_data_status: Cell<VRFrameDataStatus>,
#[ignore_malloc_size_of = "closures are hard"]
@ -88,6 +95,7 @@ pub struct VRDisplay {
unsafe_no_jsmanaged_fields!(WebVRDisplayData);
unsafe_no_jsmanaged_fields!(WebVRFrameData);
unsafe_no_jsmanaged_fields!(WebVRLayer);
unsafe_no_jsmanaged_fields!(VRFrameDataStatus);
#[derive(Clone, Copy, Eq, MallocSizeOf, PartialEq)]
enum VRFrameDataStatus {
@ -96,7 +104,18 @@ enum VRFrameDataStatus {
Exit,
}
unsafe_no_jsmanaged_fields!(VRFrameDataStatus);
#[derive(Clone, MallocSizeOf)]
struct VRRAFUpdate {
depth_near: f64,
depth_far: f64,
/// WebGL API sender
api_sender: Option<WebGLMsgSender>,
/// Number uniquely identifying the WebGL context
/// so that we may setup/tear down VR compositors as things change
context_id: usize,
}
type VRRAFUpdateSender = Sender<Result<VRRAFUpdate, ()>>;
impl VRDisplay {
fn new_inherited(global: &GlobalScope, display: WebVRDisplayData) -> VRDisplay {
@ -130,6 +149,8 @@ impl VRDisplay {
next_raf_id: Cell::new(1),
raf_callback_list: DomRefCell::new(vec![]),
xr_raf_callback_list: DomRefCell::new(vec![]),
raf_wakeup_sender: DomRefCell::new(None),
pending_renderstate_updates: DomRefCell::new(vec![]),
frame_data_status: Cell::new(VRFrameDataStatus::Waiting),
frame_data_receiver: DomRefCell::new(None),
running_display_raf: Cell::new(false),
@ -567,6 +588,63 @@ impl VRDisplay {
.fire(self.global().upcast::<EventTarget>());
}
fn api_sender(&self) -> Option<WebGLMsgSender> {
self.layer_ctx.get().map(|c| c.webgl_sender())
}
fn context_id(&self) -> usize {
self.layer_ctx
.get()
.map(|c| &*c as *const WebGLRenderingContext as usize)
.unwrap_or(0)
}
fn vr_raf_update(&self) -> VRRAFUpdate {
VRRAFUpdate {
depth_near: self.depth_near.get(),
depth_far: self.depth_far.get(),
api_sender: self.api_sender(),
context_id: self.context_id(),
}
}
pub fn queue_renderstate(&self, state: &XRRenderStateInit, promise: Rc<Promise>) {
// can't clone dictionaries
let new_state = XRRenderStateInit {
depthNear: state.depthNear,
depthFar: state.depthFar,
baseLayer: state.baseLayer.clone(),
};
self.pending_renderstate_updates.borrow_mut().push((new_state, promise))
}
fn process_renderstate_queue(&self) {
let mut updates = self.pending_renderstate_updates.borrow_mut();
if updates.is_empty() {
return;
}
debug_assert!(self.xr_session.get().is_some());
for update in updates.drain(..) {
if let Some(near) = update.0.depthNear {
self.depth_near.set(*near);
}
if let Some(far) = update.0.depthFar {
self.depth_far.set(*far);
}
if let Some(ref layer) = update.0.baseLayer {
self.xr_session.get().unwrap().set_layer(&layer);
let layer = layer.downcast::<XRWebGLLayer>().unwrap();
self.layer_ctx.set(Some(&layer.Context()));
}
update.1.resolve_native(&());
}
if let Some(ref wakeup) = *self.raf_wakeup_sender.borrow() {
let _ = wakeup.send(());
}
}
fn init_present(&self) {
self.presenting.set(true);
let xr = self.global().as_window().Navigator().Xr();
@ -575,13 +653,18 @@ impl VRDisplay {
*self.frame_data_receiver.borrow_mut() = Some(sync_receiver);
let display_id = self.display.borrow().display_id;
let api_sender = self.layer_ctx.get().unwrap().webgl_sender();
let mut api_sender = self.api_sender();
let mut context_id = self.context_id();
let js_sender = self.global().script_chan();
let address = Trusted::new(&*self);
let near_init = self.depth_near.get();
let far_init = self.depth_far.get();
let mut near = self.depth_near.get();
let mut far = self.depth_far.get();
let pipeline_id = self.global().pipeline_id();
let (raf_sender, raf_receiver) = unbounded();
let (wakeup_sender, wakeup_receiver) = unbounded();
*self.raf_wakeup_sender.borrow_mut() = Some(wakeup_sender);
// The render loop at native headset frame rate is implemented using a dedicated thread.
// Every loop iteration syncs pose data with the HMD, submits the pixels to the display and waits for Vsync.
// Both the requestAnimationFrame call of a VRDisplay in the JavaScript thread and the VRSyncPoses call
@ -591,15 +674,14 @@ impl VRDisplay {
thread::Builder::new()
.name("WebVR_RAF".into())
.spawn(move || {
let (raf_sender, raf_receiver) = unbounded();
let mut near = near_init;
let mut far = far_init;
// Initialize compositor
if let Some(ref api_sender) = api_sender {
api_sender
.send_vr(WebVRCommand::Create(display_id))
.unwrap();
}
loop {
if let Some(ref api_sender) = api_sender {
// Run RAF callbacks on JavaScript thread
let this = address.clone();
let sender = raf_sender.clone();
@ -618,13 +700,42 @@ impl VRDisplay {
.unwrap();
// Run Sync Poses in parallell on Render thread
let msg = WebVRCommand::SyncPoses(display_id, near, far, sync_sender.clone());
let msg =
WebVRCommand::SyncPoses(display_id, near, far, sync_sender.clone());
api_sender.send_vr(msg).unwrap();
} else {
let _ = wakeup_receiver.recv();
let sender = raf_sender.clone();
let this = address.clone();
let task = Box::new(task!(flush_renderstate_queue: move || {
let this = this.root();
this.process_renderstate_queue();
sender.send(Ok(this.vr_raf_update())).unwrap();
}));
js_sender
.send(CommonScriptMsg::Task(
WebVREvent,
task,
Some(pipeline_id),
TaskSourceName::DOMManipulation,
))
.unwrap();
}
// Wait until both SyncPoses & RAF ends
if let Ok(depth) = raf_receiver.recv().unwrap() {
near = depth.0;
far = depth.1;
if let Ok(update) = raf_receiver.recv().unwrap() {
near = update.depth_near;
far = update.depth_far;
if update.context_id != context_id {
if let Some(ref api_sender) = update.api_sender {
api_sender
.send_vr(WebVRCommand::Create(display_id))
.unwrap();
}
context_id = update.context_id;
}
api_sender = update.api_sender;
} else {
// Stop thread
// ExitPresent called or some error happened
@ -677,7 +788,7 @@ impl VRDisplay {
self.frame_data_status.set(status);
}
fn handle_raf(&self, end_sender: &Sender<Result<(f64, f64), ()>>) {
fn handle_raf(&self, end_sender: &VRRAFUpdateSender) {
self.frame_data_status.set(VRFrameDataStatus::Waiting);
let now = self.global().as_window().Performance().Now();
@ -717,12 +828,11 @@ impl VRDisplay {
}
}
self.process_renderstate_queue();
match self.frame_data_status.get() {
VRFrameDataStatus::Synced => {
// Sync succeeded. Notify RAF thread.
end_sender
.send(Ok((self.depth_near.get(), self.depth_far.get())))
.unwrap();
end_sender.send(Ok(self.vr_raf_update())).unwrap();
},
VRFrameDataStatus::Exit | VRFrameDataStatus::Waiting => {
// ExitPresent called or some error ocurred.

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

@ -5,9 +5,9 @@
// https://immersive-web.github.io/webxr/#xrrenderstate-interface
dictionary XRRenderStateInit {
double depthNear = 0.1;
double depthFar = 1000.0;
XRLayer? baseLayer = null;
double depthNear;
double depthFar;
XRLayer baseLayer;
};
[SecureContext, Exposed=Window] interface XRRenderState {

1
components/script/dom/webidls/XRSession.webidl
View file

@ -26,6 +26,7 @@ interface XRSession : EventTarget {
// FrozenArray<XRInputSource> getInputSources();
Promise<void> updateRenderState(optional XRRenderStateInit state);
long requestAnimationFrame(XRFrameRequestCallback callback);
void cancelAnimationFrame(long handle);

21
components/script/dom/xrsession.rs
View file

@ -4,6 +4,7 @@
use crate::dom::bindings::codegen::Bindings::VRDisplayBinding::VRDisplayMethods;
use crate::dom::bindings::codegen::Bindings::XRBinding::XRSessionMode;
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;
@ -23,7 +24,6 @@ use crate::dom::vrdisplay::VRDisplay;
use crate::dom::xrlayer::XRLayer;
use crate::dom::xrreferencespace::XRReferenceSpace;
use crate::dom::xrstationaryreferencespace::XRStationaryReferenceSpace;
use crate::dom::xrwebgllayer::XRWebGLLayer;
use crate::dom::xrrenderstate::XRRenderState;
use dom_struct::dom_struct;
use std::rc::Rc;
@ -58,6 +58,10 @@ impl XRSession {
pub fn xr_present(&self, p: Rc<Promise>) {
self.display.xr_present(self, None, Some(p));
}
pub fn set_layer(&self, layer: &XRLayer) {
self.base_layer.set(Some(layer))
}
}
impl XRSessionMethods for XRSession {
@ -69,8 +73,19 @@ impl XRSessionMethods for XRSession {
// https://immersive-web.github.io/webxr/#dom-xrsession-renderstate
fn RenderState(&self) -> DomRoot<XRRenderState> {
// XXXManishearth maybe cache this
XRRenderState::new(&self.global(), *self.display.DepthNear(), *self.display.DepthFar(),
self.base_layer.get().as_ref().map(|l| &**l))
XRRenderState::new(
&self.global(),
*self.display.DepthNear(),
*self.display.DepthFar(),
self.base_layer.get().as_ref().map(|l| &**l),
)
}
/// https://immersive-web.github.io/webxr/#dom-xrsession-requestanimationframe
fn UpdateRenderState(&self, init: &XRRenderStateInit) -> Rc<Promise> {
let p = Promise::new(&self.global());
self.display.queue_renderstate(init, p.clone());
p
}
/// https://immersive-web.github.io/webxr/#dom-xrsession-requestanimationframe