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

Integrate swapchain surface provider changes into webgl and webxr implementations.

Browse source
This commit is contained in:
Josh Matthews 2020-02-27 16:41:35 -05:00
parent b062f51495
commit fbcf2bbc3e
17 changed files with 223 additions and 117 deletions
Download patch file Download diff file Expand all files Collapse all files

2
components/canvas/Cargo.toml
View file

@ -42,5 +42,5 @@ webrender_traits = {path = "../webrender_traits"}
webxr-api = {git = "https://github.com/servo/webxr", features = ["ipc"]}
# NOTE: the sm-angle feature only enables angle on windows, not other platforms!
surfman = { version = "0.1", features = ["sm-angle", "sm-osmesa"] }
surfman-chains = "0.2"
surfman-chains = "0.3"
surfman-chains-api = "0.2"

3
components/canvas/lib.rs
View file

@ -12,6 +12,9 @@ extern crate log;
mod raqote_backend;
pub use webgl_mode::WebGLComm;
pub use webgl_thread::SurfaceProvider;
pub use webgl_thread::SurfaceProviders;
pub use webgl_thread::WebGlExecutor;
pub mod canvas_data;
pub mod canvas_paint_thread;

11
components/canvas/webgl_mode/inprocess.rs
View file

@ -2,7 +2,7 @@
* 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::webgl_thread::{WebGLThread, WebGLThreadInit};
use crate::webgl_thread::{SurfaceProviders, WebGLThread, WebGLThreadInit, WebGlExecutor};
use canvas_traits::webgl::{webgl_channel, WebVRRenderHandler};
use canvas_traits::webgl::{WebGLContextId, WebGLMsg, WebGLThreads};
use euclid::default::Size2D;
@ -11,6 +11,7 @@ use gleam;
use servo_config::pref;
use sparkle::gl;
use sparkle::gl::GlType;
use std::collections::HashMap;
use std::default::Default;
use std::rc::Rc;
use std::sync::{Arc, Mutex};
@ -27,8 +28,10 @@ use webxr_api::SwapChainId as WebXRSwapChainId;
pub struct WebGLComm {
pub webgl_threads: WebGLThreads,
pub webxr_swap_chains: SwapChains<WebXRSwapChainId>,
pub webxr_surface_providers: SurfaceProviders,
pub image_handler: Box<dyn WebrenderExternalImageApi>,
pub output_handler: Option<Box<dyn webrender_api::OutputImageHandler>>,
pub webgl_executor: WebGlExecutor,
}
impl WebGLComm {
@ -46,6 +49,8 @@ impl WebGLComm {
let (sender, receiver) = webgl_channel::<WebGLMsg>().unwrap();
let webrender_swap_chains = SwapChains::new();
let webxr_swap_chains = SwapChains::new();
let webxr_surface_providers = Arc::new(Mutex::new(HashMap::new()));
let (runnable_sender, runnable_receiver) = crossbeam_channel::unbounded();
// This implementation creates a single `WebGLThread` for all the pipelines.
let init = WebGLThreadInit {
@ -56,9 +61,11 @@ impl WebGLComm {
receiver,
webrender_swap_chains: webrender_swap_chains.clone(),
webxr_swap_chains: webxr_swap_chains.clone(),
webxr_surface_providers: webxr_surface_providers.clone(),
connection: device.connection(),
adapter: device.adapter(),
api_type,
runnable_receiver,
};
let output_handler = if pref!(dom.webgl.dom_to_texture.enabled) {
@ -74,8 +81,10 @@ impl WebGLComm {
WebGLComm {
webgl_threads: WebGLThreads(sender),
webxr_swap_chains,
webxr_surface_providers,
image_handler: Box::new(external),
output_handler: output_handler.map(|b| b as Box<_>),
webgl_executor: runnable_sender,
}
}
}

107
components/canvas/webgl_thread.rs
View file

@ -54,7 +54,7 @@ use sparkle::gl::GLint;
use sparkle::gl::GLuint;
use sparkle::gl::Gl;
use std::borrow::Cow;
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::rc::Rc;
use std::slice;
use std::sync::{Arc, Mutex};
@ -70,9 +70,10 @@ use surfman::GLVersion;
use surfman::SurfaceAccess;
use surfman::SurfaceInfo;
use surfman::SurfaceType;
use surfman_chains::SwapChains;
use surfman_chains::{SurfmanProvider, SwapChains};
use surfman_chains_api::SwapChainsAPI;
use webrender_traits::{WebrenderExternalImageRegistry, WebrenderImageHandlerType};
use webxr_api::SessionId;
use webxr_api::SwapChainId as WebXRSwapChainId;
#[cfg(feature = "xr-profile")]
@ -138,25 +139,29 @@ pub(crate) struct WebGLThread {
/// We use it to get an unique ID for new WebGLContexts.
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
/// The receiver that will be used for processing WebGL messages.
receiver: WebGLReceiver<WebGLMsg>,
receiver: crossbeam_channel::Receiver<WebGLMsg>,
/// The receiver that should be used to send WebGL messages for processing.
sender: WebGLSender<WebGLMsg>,
/// The swap chains used by webrender
webrender_swap_chains: SwapChains<WebGLContextId>,
/// The swap chains used by webxr
webxr_swap_chains: SwapChains<WebXRSwapChainId>,
/// The set of all surface providers corresponding to WebXR sessions.
webxr_surface_providers: SurfaceProviders,
/// A channel to allow arbitrary threads to execute tasks that run in the WebGL thread.
runnable_receiver: crossbeam_channel::Receiver<WebGlRunnable>,
/// Whether this context is a GL or GLES context.
api_type: gl::GlType,
}
#[derive(PartialEq)]
enum EventLoop {
Blocking,
Nonblocking,
}
pub type WebGlExecutor = crossbeam_channel::Sender<WebGlRunnable>;
pub type WebGlRunnable = Box<dyn FnOnce() + Send>;
pub type SurfaceProviders = Arc<Mutex<HashMap<SessionId, SurfaceProvider>>>;
pub type SurfaceProvider = Box<dyn surfman_chains::SurfaceProvider + Send>;
/// The data required to initialize an instance of the WebGLThread type.
pub(crate) struct WebGLThreadInit {
pub webxr_surface_providers: SurfaceProviders,
pub webrender_api_sender: webrender_api::RenderApiSender,
pub webvr_compositor: Option<Box<dyn WebVRRenderHandler>>,
pub external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
@ -167,37 +172,7 @@ pub(crate) struct WebGLThreadInit {
pub connection: Connection,
pub adapter: Adapter,
pub api_type: gl::GlType,
}
/// The extra data required to run an instance of WebGLThread when it is
/// not running in its own thread.
pub struct WebGLMainThread {
pub(crate) thread_data: RefCell<WebGLThread>,
shut_down: Cell<bool>,
}
impl WebGLMainThread {
/// Synchronously process all outstanding WebGL messages.
pub fn process(&self) {
if self.shut_down.get() {
return;
}
// Any context could be current when we start.
self.thread_data.borrow_mut().bound_context_id = None;
let result = self
.thread_data
.borrow_mut()
.process(EventLoop::Nonblocking);
if !result {
self.shut_down.set(true);
WEBGL_MAIN_THREAD.with(|thread_data| thread_data.borrow_mut().take());
}
}
}
thread_local! {
static WEBGL_MAIN_THREAD: RefCell<Option<Rc<WebGLMainThread>>> = RefCell::new(None);
pub runnable_receiver: crossbeam_channel::Receiver<WebGlRunnable>,
}
// A size at which it should be safe to create GL contexts
@ -214,9 +189,11 @@ impl WebGLThread {
receiver,
webrender_swap_chains,
webxr_swap_chains,
webxr_surface_providers,
connection,
adapter,
api_type,
runnable_receiver,
}: WebGLThreadInit,
) -> Self {
WebGLThread {
@ -229,9 +206,11 @@ impl WebGLThread {
dom_outputs: Default::default(),
external_images,
sender,
receiver,
receiver: receiver.into_inner(),
webrender_swap_chains,
webxr_swap_chains,
webxr_surface_providers,
runnable_receiver,
api_type,
}
}
@ -243,23 +222,35 @@ impl WebGLThread {
.name("WebGL thread".to_owned())
.spawn(move || {
let mut data = WebGLThread::new(init);
data.process(EventLoop::Blocking);
data.process();
})
.expect("Thread spawning failed");
}
fn process(&mut self, loop_type: EventLoop) -> bool {
fn process(&mut self) {
let webgl_chan = WebGLChan(self.sender.clone());
while let Ok(msg) = match loop_type {
EventLoop::Blocking => self.receiver.recv(),
EventLoop::Nonblocking => self.receiver.try_recv(),
} {
let exit = self.handle_msg(msg, &webgl_chan);
if exit {
return false;
loop {
crossbeam_channel::select! {
recv(self.receiver) -> msg => {
match msg {
Ok(msg) => {
let exit = self.handle_msg(msg, &webgl_chan);
if exit {
return;
}
}
_ => break,
}
}
recv(self.runnable_receiver) -> msg => {
if let Ok(msg) = msg {
msg();
} else {
self.runnable_receiver = crossbeam_channel::never();
}
}
}
}
true
}
/// Handles a generic WebGLMsg message
@ -331,8 +322,8 @@ impl WebGLThread {
WebGLMsg::WebVRCommand(ctx_id, command) => {
self.handle_webvr_command(ctx_id, command);
},
WebGLMsg::CreateWebXRSwapChain(ctx_id, size, sender) => {
let _ = sender.send(self.create_webxr_swap_chain(ctx_id, size));
WebGLMsg::CreateWebXRSwapChain(ctx_id, size, sender, id) => {
let _ = sender.send(self.create_webxr_swap_chain(ctx_id, size, id));
},
WebGLMsg::SwapBuffers(swap_ids, sender, sent_time) => {
self.handle_swap_buffers(swap_ids, sender, sent_time);
@ -443,6 +434,7 @@ impl WebGLThread {
size: safe_size.to_i32(),
};
let surface_access = self.surface_access();
let surface_provider = Box::new(SurfmanProvider::new(surface_access));
let mut ctx = self
.device
@ -469,7 +461,7 @@ impl WebGLThread {
);
self.webrender_swap_chains
.create_attached_swap_chain(id, &mut self.device, &mut ctx, surface_access)
.create_attached_swap_chain(id, &mut self.device, &mut ctx, surface_provider)
.expect("Failed to create the swap chain");
let swap_chain = self
@ -765,6 +757,7 @@ impl WebGLThread {
&mut self,
context_id: WebGLContextId,
size: Size2D<i32>,
session_id: SessionId,
) -> Option<WebXRSwapChainId> {
debug!("WebGLThread::create_webxr_swap_chain()");
let id = WebXRSwapChainId::new();
@ -775,8 +768,14 @@ impl WebGLThread {
&mut self.contexts,
&mut self.bound_context_id,
)?;
let surface_provider = self
.webxr_surface_providers
.lock()
.unwrap()
.remove(&session_id)
.unwrap_or_else(|| Box::new(SurfmanProvider::new(surface_access)));
self.webxr_swap_chains
.create_detached_swap_chain(id, size, &mut self.device, &mut data.ctx, surface_access)
.create_detached_swap_chain(id, size, &mut self.device, &mut data.ctx, surface_provider)
.ok()?;
debug!("Created swap chain {:?}", id);
Some(id)

11
components/canvas_traits/webgl.rs
View file

@ -14,6 +14,7 @@ use std::num::{NonZeroU32, NonZeroU64};
use std::ops::Deref;
use webrender_api::{DocumentId, ImageKey, PipelineId};
use webvr_traits::WebVRPoseInformation;
use webxr_api::SessionId;
use webxr_api::SwapChainId as WebXRSwapChainId;
/// Helper function that creates a WebGL channel (WebGLSender, WebGLReceiver) to be used in WebGLCommands.
@ -80,6 +81,7 @@ pub enum WebGLMsg {
WebGLContextId,
Size2D<i32>,
WebGLSender<Option<WebXRSwapChainId>>,
SessionId,
),
/// Performs a buffer swap.
///
@ -188,9 +190,14 @@ impl WebGLMsgSender {
&self,
size: Size2D<i32>,
sender: WebGLSender<Option<WebXRSwapChainId>>,
id: SessionId,
) -> WebGLSendResult {
self.sender
.send(WebGLMsg::CreateWebXRSwapChain(self.ctx_id, size, sender))
self.sender.send(WebGLMsg::CreateWebXRSwapChain(
self.ctx_id,
size,
sender,
id,
))
}
#[inline]

13
components/canvas_traits/webgl_channel/mod.rs
View file

@ -9,6 +9,7 @@ mod mpsc;
use crate::webgl::WebGLMsg;
use ipc_channel::ipc::IpcSender;
use ipc_channel::router::ROUTER;
use serde::{Deserialize, Serialize};
use servo_config::opts;
use std::fmt;
@ -78,6 +79,18 @@ where
WebGLReceiver::Mpsc(ref receiver) => receiver.try_recv().map_err(|_| ()),
}
}
pub fn into_inner(self) -> crossbeam_channel::Receiver<T>
where
T: Send + 'static,
{
match self {
WebGLReceiver::Ipc(receiver) => {
ROUTER.route_ipc_receiver_to_new_crossbeam_receiver(receiver)
},
WebGLReceiver::Mpsc(receiver) => receiver.into_inner(),
}
}
}
pub fn webgl_channel<T>() -> Result<(WebGLSender<T>, WebGLReceiver<T>), ()>

16
components/canvas_traits/webgl_channel/mpsc.rs
View file

@ -4,7 +4,6 @@
use serde::{Deserialize, Serialize};
use serde::{Deserializer, Serializer};
use std::sync::mpsc;
#[macro_use]
macro_rules! unreachable_serializable {
@ -26,8 +25,8 @@ macro_rules! unreachable_serializable {
};
}
pub struct WebGLSender<T>(mpsc::Sender<T>);
pub struct WebGLReceiver<T>(mpsc::Receiver<T>);
pub struct WebGLSender<T>(crossbeam_channel::Sender<T>);
pub struct WebGLReceiver<T>(crossbeam_channel::Receiver<T>);
impl<T> Clone for WebGLSender<T> {
fn clone(&self) -> Self {
@ -37,24 +36,27 @@ impl<T> Clone for WebGLSender<T> {
impl<T> WebGLSender<T> {
#[inline]
pub fn send(&self, data: T) -> Result<(), mpsc::SendError<T>> {
pub fn send(&self, data: T) -> Result<(), crossbeam_channel::SendError<T>> {
self.0.send(data)
}
}
impl<T> WebGLReceiver<T> {
#[inline]
pub fn recv(&self) -> Result<T, mpsc::RecvError> {
pub fn recv(&self) -> Result<T, crossbeam_channel::RecvError> {
self.0.recv()
}
#[inline]
pub fn try_recv(&self) -> Result<T, mpsc::TryRecvError> {
pub fn try_recv(&self) -> Result<T, crossbeam_channel::TryRecvError> {
self.0.try_recv()
}
pub fn into_inner(self) -> crossbeam_channel::Receiver<T> {
self.0
}
}
pub fn webgl_channel<T>() -> Result<(WebGLSender<T>, WebGLReceiver<T>), ()> {
let (sender, receiver) = mpsc::channel();
let (sender, receiver) = crossbeam_channel::unbounded();
Ok((WebGLSender(sender), WebGLReceiver(receiver)))
}

1
components/compositing/Cargo.toml
View file

@ -16,6 +16,7 @@ default = []
gl = ["gleam", "pixels"]
[dependencies]
canvas = { path = "../canvas" }
crossbeam-channel = "0.4"
embedder_traits = {path = "../embedder_traits"}
euclid = "0.20"

9
components/compositing/windowing.rs
View file

@ -4,6 +4,7 @@
//! Abstract windowing methods. The concrete implementations of these can be found in `platform/`.
use canvas::{SurfaceProviders, WebGlExecutor};
use embedder_traits::EventLoopWaker;
use euclid::Scale;
#[cfg(feature = "gl")]
@ -184,7 +185,13 @@ pub trait EmbedderMethods {
}
/// Register services with a WebXR Registry.
fn register_webxr(&mut self, _: &mut webxr::MainThreadRegistry) {}
fn register_webxr(
&mut self,
_: &mut webxr::MainThreadRegistry,
_: WebGlExecutor,
_: SurfaceProviders,
) {
}
}
#[derive(Clone, Copy, Debug)]

8
components/script/dom/webglframebuffer.rs
View file

@ -142,9 +142,11 @@ impl WebGLFramebuffer {
size: Size2D<i32, Viewport>,
) -> Option<(WebXRSwapChainId, DomRoot<Self>)> {
let (sender, receiver) = webgl_channel().unwrap();
let _ = context
.webgl_sender()
.send_create_webxr_swap_chain(size.to_untyped(), sender);
let _ = context.webgl_sender().send_create_webxr_swap_chain(
size.to_untyped(),
sender,
session.session_id(),
);
let swap_chain_id = receiver.recv().unwrap()?;
let framebuffer_id =
WebGLFramebufferId::Opaque(WebGLOpaqueFramebufferId::WebXR(swap_chain_id));

4
components/script/dom/webglrenderingcontext.rs
View file

@ -81,6 +81,7 @@ use std::cell::Cell;
use std::cmp;
use std::ptr::{self, NonNull};
use std::rc::Rc;
use webxr_api::SessionId;
use webxr_api::SwapChainId as WebXRSwapChainId;
// From the GLES 2.0.25 spec, page 85:
@ -4576,8 +4577,9 @@ impl WebGLMessageSender {
&self,
size: Size2D<i32>,
sender: WebGLSender<Option<WebXRSwapChainId>>,
id: SessionId,
) -> WebGLSendResult {
self.wake_after_send(|| self.sender.send_create_webxr_swap_chain(size, sender))
self.wake_after_send(|| self.sender.send_create_webxr_swap_chain(size, sender, id))
}
pub fn send_resize(

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

@ -51,7 +51,7 @@ use std::mem;
use std::rc::Rc;
use webxr_api::{
self, util, Display, EnvironmentBlendMode, Event as XREvent, Frame, SelectEvent, SelectKind,
Session, View, Viewer, Visibility,
Session, SessionId, View, Viewer, Visibility,
};
#[dom_struct]
@ -462,6 +462,10 @@ impl XRSession {
viewport: Rect::from_size(size.to_i32()),
}
}
pub fn session_id(&self) -> SessionId {
self.session.borrow().id()
}
}
impl XRSessionMethods for XRSession {

45
components/servo/lib.rs
View file

@ -65,7 +65,7 @@ fn webdriver(_port: u16, _constellation: Sender<ConstellationMsg>) {}
use bluetooth::BluetoothThreadFactory;
use bluetooth_traits::BluetoothRequest;
use canvas::WebGLComm;
use canvas::{SurfaceProviders, WebGLComm, WebGlExecutor};
use canvas_traits::webgl::WebGLThreads;
use compositing::compositor_thread::{
CompositorProxy, CompositorReceiver, InitialCompositorState, Msg,
@ -432,14 +432,6 @@ where
panic!("We don't currently support running both WebVR and WebXR");
}
// For the moment, we enable use both the webxr crate and the rust-webvr crate,
// but we are migrating over to just using webxr.
let mut webxr_main_thread = webxr::MainThreadRegistry::new(event_loop_waker)
.expect("Failed to create WebXR device registry");
if pref!(dom.webxr.enabled) {
embedder.register_webxr(&mut webxr_main_thread);
}
let mut webvr_heartbeats = Vec::new();
let webvr_services = if pref!(dom.webvr.enabled) {
let mut services = VRServiceManager::new();
@ -468,7 +460,12 @@ where
let (external_image_handlers, external_images) = WebrenderExternalImageHandlers::new();
let mut external_image_handlers = Box::new(external_image_handlers);
let webgl_threads = create_webgl_threads(
// For the moment, we enable use both the webxr crate and the rust-webvr crate,
// but we are migrating over to just using webxr.
let mut webxr_main_thread = webxr::MainThreadRegistry::new(event_loop_waker)
.expect("Failed to create WebXR device registry");
let (webgl_threads, webgl_extras) = create_webgl_threads(
&*window,
&mut webrender,
webrender_api_sender.clone(),
@ -478,6 +475,16 @@ where
external_images.clone(),
);
if pref!(dom.webxr.enabled) {
if let Some((webxr_surface_providers, webgl_executor)) = webgl_extras {
embedder.register_webxr(
&mut webxr_main_thread,
webgl_executor,
webxr_surface_providers,
);
}
}
let glplayer_threads = match window.get_gl_context() {
GlContext::Unknown => None,
_ => {
@ -1060,7 +1067,10 @@ fn create_webgl_threads<W>(
webxr_main_thread: &mut webxr::MainThreadRegistry,
external_image_handlers: &mut WebrenderExternalImageHandlers,
external_images: Arc<Mutex<WebrenderExternalImageRegistry>>,
) -> Option<WebGLThreads>
) -> (
Option<WebGLThreads>,
Option<(SurfaceProviders, WebGlExecutor)>,
)
where
W: WindowMethods + 'static + ?Sized,
{
@ -1074,7 +1084,7 @@ where
Ok(a) => a,
Err(e) => {
warn!("Failed to create software graphics context: {:?}", e);
return None;
return (None, None);
},
};
(Device::Software(device), Context::Software(context))
@ -1083,7 +1093,7 @@ where
Ok(a) => a,
Err(e) => {
warn!("Failed to create hardware graphics context: {:?}", e);
return None;
return (None, None);
},
};
(Device::Hardware(device), Context::Hardware(context))
@ -1094,7 +1104,7 @@ where
Ok(a) => a,
Err(e) => {
warn!("Failed to create graphics context: {:?}", e);
return None;
return (None, None);
},
};
@ -1106,8 +1116,10 @@ where
let WebGLComm {
webgl_threads,
webxr_swap_chains,
webxr_surface_providers,
image_handler,
output_handler,
webgl_executor,
} = WebGLComm::new(
device,
context,
@ -1129,5 +1141,8 @@ where
webrender.set_output_image_handler(output_handler);
}
Some(webgl_threads)
(
Some(webgl_threads),
Some((webxr_surface_providers, webgl_executor)),
)
}