Add VRCompositor commands for WebVR

Author: MortimerGoro

webrender/src/render_backend.rs

@@ -19,6 +19,7 @@ use webrender_traits::{ApiMsg, AuxiliaryLists, BuiltDisplayList, IdNamespace, Im
 use webrender_traits::{FlushNotifier, RenderNotifier, RenderDispatcher, WebGLCommand, WebGLContextId};
 use webrender_traits::{DeviceIntSize};
 use webrender_traits::channel::{PayloadHelperMethods, PayloadReceiver, PayloadSender, MsgReceiver};
+use webrender_traits::{VRCompositorCommand, VRCompositor, VRCompositorCreator, VRCompositorId};
 use record;
 use tiling::FrameBuilderConfig;
 use offscreen_gl_context::GLContextDispatcher;
@@ -50,6 +51,9 @@ pub struct RenderBackend {
     main_thread_dispatcher: Arc<Mutex<Option<Box<RenderDispatcher>>>>,
 
     next_webgl_id: usize,
+
+    vr_compositor_creator: Arc<Mutex<Option<Box<VRCompositorCreator>>>>,
+    vr_compositors: HashMap<VRCompositorId, Box<VRCompositor>>
 }
 
 impl RenderBackend {
@@ -66,7 +70,8 @@ impl RenderBackend {
                config: FrameBuilderConfig,
                debug: bool,
                enable_recording:bool,
-               main_thread_dispatcher:  Arc<Mutex<Option<Box<RenderDispatcher>>>>) -> RenderBackend {
+               main_thread_dispatcher: Arc<Mutex<Option<Box<RenderDispatcher>>>>,
+               vr_compositor_creator: Arc<Mutex<Option<Box<VRCompositorCreator>>>>) -> RenderBackend {
 
         let resource_cache = ResourceCache::new(texture_cache,
                                                 device_pixel_ratio,
@@ -90,6 +95,8 @@ impl RenderBackend {
             enable_recording:enable_recording,
             main_thread_dispatcher: main_thread_dispatcher,
             next_webgl_id: 0,
+            vr_compositor_creator: vr_compositor_creator,
+            vr_compositors: HashMap::new(),
         }
     }
 
@@ -337,6 +344,10 @@ impl RenderBackend {
                             ctx.make_current();
                             ctx.apply_command(command);
                             self.current_bound_webgl_context_id = Some(context_id);
+                        },
+
+                        ApiMsg::VRCompositorCommand(context_id, command) => {
+                            self.handle_vr_compositor_command(context_id, command);
                         }
                         ApiMsg::GenerateFrame => {
                             let frame = profile_counters.total_time.profile(|| {
@@ -470,6 +481,38 @@ impl RenderBackend {
         let mut notifier = self.notifier.lock();
         notifier.as_mut().unwrap().as_mut().unwrap().new_scroll_frame_ready(composite_needed);
     }
+
+    fn handle_vr_compositor_command(&mut self, ctx_id: WebGLContextId, cmd: VRCompositorCommand) {
+        match cmd {
+            VRCompositorCommand::Create(compositor_id) => {
+                let mut creator = self.vr_compositor_creator.lock();
+                let compositor = creator.as_mut().unwrap().as_mut().unwrap().create_compositor(compositor_id);
+                if let Some(compositor) = compositor {
+                    self.vr_compositors.insert(compositor_id, compositor);
+                }
+            }
+            VRCompositorCommand::SyncPoses(compositor_id, near, far, sender) => {
+                if let Some(ref compositor) = self.vr_compositors.get(&compositor_id) {
+                    let pose = compositor.sync_poses(near, far);
+                    let _result = sender.send(Ok(pose));
+                } else {
+                    let _result = sender.send(Err(()));
+                }
+            }
+            VRCompositorCommand::SubmitFrame(compositor_id, left_bounds, right_bounds) => {
+                if let Some(ref compositor) = self.vr_compositors.get(&compositor_id) {
+                    let texture = self.resource_cache.get_webgl_texture(&ctx_id);
+                    if let SourceTexture::WebGL(texture_id) = texture.texture_id {
+                        compositor.submit_frame(texture_id, left_bounds, right_bounds);
+                    }
+                }
+            }
+            VRCompositorCommand::Release(compositor_id) => {
+                self.vr_compositors.remove(&compositor_id);
+            }
+        }
+
+    }
 }
 
 struct WebRenderGLDispatcher {

webrender/src/renderer.rs

@@ -40,6 +40,7 @@ use webrender_traits::{ColorF, Epoch, FlushNotifier, PipelineId, RenderNotifier,
 use webrender_traits::{ExternalImageId, ImageFormat, RenderApiSender, RendererKind};
 use webrender_traits::{DeviceSize, DevicePoint, DeviceIntPoint, DeviceIntSize, DeviceUintSize};
 use webrender_traits::channel;
+use webrender_traits::VRCompositorCreator;
 
 pub const MAX_VERTEX_TEXTURE_WIDTH: usize = 1024;
 
@@ -414,6 +415,10 @@ pub struct Renderer {
 
     /// Map of external image IDs to native textures.
     external_images: HashMap<ExternalImageId, TextureId, BuildHasherDefault<FnvHasher>>,
+
+    // Optional trait object that allows to create a VRCompositor instance to handle WebVR commands.
+    // Some WebVR commands such as Vsync and SubmitFrame must be called in the WebGL render thread.
+    vr_compositor_creator: Arc<Mutex<Option<Box<VRCompositorCreator>>>>
 }
 
 impl Renderer {
@@ -668,6 +673,9 @@ impl Renderer {
         let backend_main_thread_dispatcher = main_thread_dispatcher.clone();
         let backend_flush_notifier = flush_notifier.clone();
 
+        let vr_compositor = Arc::new(Mutex::new(None));
+        let backend_vr_compositor = vr_compositor.clone();
+
         // We need a reference to the webrender context from the render backend in order to share
         // texture ids
         let context_handle = match options.renderer_kind {
@@ -696,7 +704,8 @@ impl Renderer {
                                                  config,
                                                  debug,
                                                  enable_recording,
-                                                 backend_main_thread_dispatcher);
+                                                 backend_main_thread_dispatcher,
+                                                 backend_vr_compositor);
             backend.run();
         });
 
@@ -756,6 +765,7 @@ impl Renderer {
             cache_texture_id_map: Vec::new(),
             external_image_handler: None,
             external_images: HashMap::with_hasher(Default::default()),
+            vr_compositor_creator: vr_compositor
         };
 
         let sender = RenderApiSender::new(api_tx, payload_tx);
@@ -789,6 +799,16 @@ impl Renderer {
         *dispatcher_arc = Some(dispatcher);
     }
 
+    /// Sets the VRCompositorCreator.
+    ///
+    /// Some WebVR commands such as Vsync and SubmitFrame must be called in the WebGL render thread.
+    /// VRCompositorCreator is used to create VRCompositor objects that are able to handle WebVR
+    /// commands that must be called in the render thread.
+    pub fn set_vr_compositor_creator(&self, creator: Box<VRCompositorCreator>) {
+        let mut creator_arc = self.vr_compositor_creator.lock().unwrap();
+        *creator_arc = Some(creator);
+    }
+
     /// Returns the Epoch of the current frame in a pipeline.
     pub fn current_epoch(&self, pipeline_id: PipelineId) -> Option<Epoch> {
         self.pipeline_epoch_map.get(&pipeline_id).map(|epoch| *epoch)

webrender_traits/src/api.rs

@@ -11,6 +11,7 @@ use {ApiMsg, ColorF, DisplayListBuilder, Epoch};
 use {FontKey, IdNamespace, ImageFormat, ImageKey, NativeFontHandle, PipelineId};
 use {RenderApiSender, ResourceId, ScrollEventPhase, ScrollLayerState, ServoScrollRootId};
 use {GlyphKey, GlyphDimensions, ImageData, WebGLContextId, WebGLCommand};
+use VRCompositorCommand;
 
 impl RenderApiSender {
     pub fn new(api_sender: MsgSender<ApiMsg>,
@@ -245,6 +246,11 @@ impl RenderApi {
         self.api_sender.send(msg).unwrap();
     }
 
+    pub fn send_vr_compositor_command(&self, context_id: WebGLContextId, command: VRCompositorCommand) {
+        let msg = ApiMsg::VRCompositorCommand(context_id, command);
+        self.api_sender.send(msg).unwrap();
+    }
+
     #[inline]
     fn next_unique_id(&self) -> (u32, u32) {
         let IdNamespace(namespace) = self.id_namespace;

webrender_traits/src/types.rs

@@ -57,6 +57,8 @@ pub enum ApiMsg {
     ResizeWebGLContext(WebGLContextId, Size2D<i32>),
     WebGLCommand(WebGLContextId, WebGLCommand),
     GenerateFrame,
+    // WebVR commands that must be called in the WebGL render thread.
+    VRCompositorCommand(WebGLContextId, VRCompositorCommand)
 }
 
 #[derive(Copy, Clone, Deserialize, Serialize, Debug)]
@@ -644,7 +646,16 @@ pub enum WebGLCommand {
     DrawingBufferHeight(MsgSender<i32>),
     Finish(MsgSender<()>),
     Flush,
-    GenerateMipmap(u32),
+    GenerateMipmap(u32)
+}
+
+// WebVR commands that must be called in the WebGL render thread.
+#[derive(Clone, Deserialize, Serialize)]
+pub enum VRCompositorCommand {
+    Create(VRCompositorId),
+    SyncPoses(VRCompositorId, f64, f64, MsgSender<Result<Vec<u8>,()>>),
+    SubmitFrame(VRCompositorId, [f32; 4], [f32; 4]),
+    Release(VRCompositorId)
 }
 
 #[cfg(feature = "nightly")]
@@ -784,3 +795,18 @@ pub enum WebGLShaderParameter {
     Bool(bool),
     Invalid,
 }
+
+pub type VRCompositorId = u64;
+
+// Trait object that runs WebVR commands that must be called in the WebGL render thread.
+pub trait VRCompositor {
+    // Synchronization point to keep in step with the HMD.
+    fn sync_poses(&self, f64, f64) -> Vec<u8>;
+    // Submits the frame to the display using the shared WebGLContext texture.
+    fn submit_frame(&self, u32, [f32; 4], [f32; 4]);
+}
+
+// Trait that allows to create VRCompositor instance using decoupled dependencies.
+pub trait VRCompositorCreator: Send {
+    fn create_compositor(&mut self, VRCompositorId) -> Option<Box<VRCompositor>>;
+}