mirror of
https://github.com/servo/servo.git
synced 2025-08-06 22:15:33 +01:00
Filter out webidl files based on special comments, and feature-gate webxr interfaces. (#34348)
* Filter out webidl files based on skip-if directives. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * script: Don't build XR functionality without webxr feature. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * Fix tidy. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * script: Adjust imports for file movement. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * Fix clippy. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * Formatting. Signed-off-by: Josh Matthews <josh@joshmatthews.net> * Clean up webxr module import. Co-authored-by: Samson <16504129+sagudev@users.noreply.github.com> Signed-off-by: Josh Matthews <josh@joshmatthews.net> --------- Signed-off-by: Josh Matthews <josh@joshmatthews.net> Co-authored-by: Samson <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
Josh Matthews
GitHub
parent
e956f3124c
commit
3faed9b921
94 changed files with 206 additions and 53 deletions
367
components/script/dom/webxr/xrwebgllayer.rs
Normal file
367
components/script/dom/webxr/xrwebgllayer.rs
Normal file
|
|
@ -0,0 +1,367 @@
|
|||
/* 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 std::convert::TryInto;
|
||||
|
||||
use canvas_traits::webgl::{WebGLCommand, WebGLContextId, WebGLTextureId};
|
||||
use dom_struct::dom_struct;
|
||||
use euclid::{Rect, Size2D};
|
||||
use js::rust::HandleObject;
|
||||
use webxr_api::{ContextId as WebXRContextId, LayerId, LayerInit, Viewport};
|
||||
|
||||
use crate::dom::bindings::codegen::Bindings::WebGL2RenderingContextBinding::WebGL2RenderingContextConstants as constants;
|
||||
use crate::dom::bindings::codegen::Bindings::WebGLRenderingContextBinding::WebGLRenderingContextMethods;
|
||||
use crate::dom::bindings::codegen::Bindings::XRWebGLLayerBinding::{
|
||||
XRWebGLLayerInit, XRWebGLLayerMethods, XRWebGLRenderingContext,
|
||||
};
|
||||
use crate::dom::bindings::codegen::UnionTypes::HTMLCanvasElementOrOffscreenCanvas;
|
||||
use crate::dom::bindings::error::{Error, Fallible};
|
||||
use crate::dom::bindings::inheritance::Castable;
|
||||
use crate::dom::bindings::num::Finite;
|
||||
use crate::dom::bindings::reflector::{reflect_dom_object_with_proto, DomObject};
|
||||
use crate::dom::bindings::root::{Dom, DomRoot};
|
||||
use crate::dom::globalscope::GlobalScope;
|
||||
use crate::dom::webglframebuffer::WebGLFramebuffer;
|
||||
use crate::dom::webglobject::WebGLObject;
|
||||
use crate::dom::webglrenderingcontext::WebGLRenderingContext;
|
||||
use crate::dom::webgltexture::WebGLTexture;
|
||||
use crate::dom::window::Window;
|
||||
use crate::dom::xrframe::XRFrame;
|
||||
use crate::dom::xrlayer::XRLayer;
|
||||
use crate::dom::xrsession::XRSession;
|
||||
use crate::dom::xrview::XRView;
|
||||
use crate::dom::xrviewport::XRViewport;
|
||||
use crate::script_runtime::CanGc;
|
||||
|
||||
impl<'a> From<&'a XRWebGLLayerInit> for LayerInit {
|
||||
fn from(init: &'a XRWebGLLayerInit) -> LayerInit {
|
||||
LayerInit::WebGLLayer {
|
||||
alpha: init.alpha,
|
||||
antialias: init.antialias,
|
||||
depth: init.depth,
|
||||
stencil: init.stencil,
|
||||
framebuffer_scale_factor: *init.framebufferScaleFactor as f32,
|
||||
ignore_depth_values: init.ignoreDepthValues,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[dom_struct]
|
||||
pub struct XRWebGLLayer {
|
||||
xr_layer: XRLayer,
|
||||
antialias: bool,
|
||||
depth: bool,
|
||||
stencil: bool,
|
||||
alpha: bool,
|
||||
ignore_depth_values: bool,
|
||||
/// If none, this is an inline session (the composition disabled flag is true)
|
||||
framebuffer: Option<Dom<WebGLFramebuffer>>,
|
||||
}
|
||||
|
||||
impl XRWebGLLayer {
|
||||
pub fn new_inherited(
|
||||
session: &XRSession,
|
||||
context: &WebGLRenderingContext,
|
||||
init: &XRWebGLLayerInit,
|
||||
framebuffer: Option<&WebGLFramebuffer>,
|
||||
layer_id: Option<LayerId>,
|
||||
) -> XRWebGLLayer {
|
||||
XRWebGLLayer {
|
||||
xr_layer: XRLayer::new_inherited(session, context, layer_id),
|
||||
antialias: init.antialias,
|
||||
depth: init.depth,
|
||||
stencil: init.stencil,
|
||||
alpha: init.alpha,
|
||||
ignore_depth_values: init.ignoreDepthValues,
|
||||
framebuffer: framebuffer.map(Dom::from_ref),
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(clippy::too_many_arguments)]
|
||||
fn new(
|
||||
global: &GlobalScope,
|
||||
proto: Option<HandleObject>,
|
||||
session: &XRSession,
|
||||
context: &WebGLRenderingContext,
|
||||
init: &XRWebGLLayerInit,
|
||||
framebuffer: Option<&WebGLFramebuffer>,
|
||||
layer_id: Option<LayerId>,
|
||||
can_gc: CanGc,
|
||||
) -> DomRoot<XRWebGLLayer> {
|
||||
reflect_dom_object_with_proto(
|
||||
Box::new(XRWebGLLayer::new_inherited(
|
||||
session,
|
||||
context,
|
||||
init,
|
||||
framebuffer,
|
||||
layer_id,
|
||||
)),
|
||||
global,
|
||||
proto,
|
||||
can_gc,
|
||||
)
|
||||
}
|
||||
|
||||
pub fn layer_id(&self) -> Option<LayerId> {
|
||||
self.xr_layer.layer_id()
|
||||
}
|
||||
|
||||
pub fn context_id(&self) -> WebGLContextId {
|
||||
self.xr_layer.context_id()
|
||||
}
|
||||
|
||||
pub fn session(&self) -> &XRSession {
|
||||
self.xr_layer.session()
|
||||
}
|
||||
|
||||
pub fn size(&self) -> Size2D<u32, Viewport> {
|
||||
if let Some(framebuffer) = self.framebuffer.as_ref() {
|
||||
let size = framebuffer.size().unwrap_or((0, 0));
|
||||
Size2D::new(
|
||||
size.0.try_into().unwrap_or(0),
|
||||
size.1.try_into().unwrap_or(0),
|
||||
)
|
||||
} else {
|
||||
let size = match self.context().Canvas() {
|
||||
HTMLCanvasElementOrOffscreenCanvas::HTMLCanvasElement(canvas) => canvas.get_size(),
|
||||
HTMLCanvasElementOrOffscreenCanvas::OffscreenCanvas(canvas) => {
|
||||
let size = canvas.get_size();
|
||||
Size2D::new(
|
||||
size.width.try_into().unwrap_or(0),
|
||||
size.height.try_into().unwrap_or(0),
|
||||
)
|
||||
},
|
||||
};
|
||||
Size2D::from_untyped(size)
|
||||
}
|
||||
}
|
||||
|
||||
fn texture_target(&self) -> u32 {
|
||||
if cfg!(target_os = "macos") {
|
||||
glow::TEXTURE_RECTANGLE
|
||||
} else {
|
||||
glow::TEXTURE_2D
|
||||
}
|
||||
}
|
||||
|
||||
pub fn begin_frame(&self, frame: &XRFrame) -> Option<()> {
|
||||
debug!("XRWebGLLayer begin frame");
|
||||
let framebuffer = self.framebuffer.as_ref()?;
|
||||
let context = framebuffer.upcast::<WebGLObject>().context();
|
||||
let sub_images = frame.get_sub_images(self.layer_id()?)?;
|
||||
let session = self.session();
|
||||
// TODO: Cache this texture
|
||||
let color_texture_id =
|
||||
WebGLTextureId::maybe_new(sub_images.sub_image.as_ref()?.color_texture)?;
|
||||
let color_texture = WebGLTexture::new_webxr(context, color_texture_id, session);
|
||||
let target = self.texture_target();
|
||||
|
||||
// Save the current bindings
|
||||
let saved_framebuffer = context.get_draw_framebuffer_slot().get();
|
||||
let saved_framebuffer_target = framebuffer.target();
|
||||
let saved_texture_id = context
|
||||
.textures()
|
||||
.active_texture_slot(target, context.webgl_version())
|
||||
.ok()
|
||||
.and_then(|slot| slot.get().map(|texture| texture.id()));
|
||||
|
||||
// We have to pick a framebuffer target.
|
||||
// If there is a draw framebuffer, we use its target,
|
||||
// otherwise we just use DRAW_FRAMEBUFFER.
|
||||
let framebuffer_target = saved_framebuffer
|
||||
.as_ref()
|
||||
.and_then(|fb| fb.target())
|
||||
.unwrap_or(constants::DRAW_FRAMEBUFFER);
|
||||
|
||||
// Update the attachments
|
||||
context.send_command(WebGLCommand::BindTexture(target, Some(color_texture_id)));
|
||||
framebuffer.bind(framebuffer_target);
|
||||
framebuffer
|
||||
.texture2d_even_if_opaque(
|
||||
constants::COLOR_ATTACHMENT0,
|
||||
self.texture_target(),
|
||||
Some(&color_texture),
|
||||
0,
|
||||
)
|
||||
.ok()?;
|
||||
if let Some(id) = sub_images.sub_image.as_ref()?.depth_stencil_texture {
|
||||
// TODO: Cache this texture
|
||||
let depth_stencil_texture_id = WebGLTextureId::maybe_new(id)?;
|
||||
let depth_stencil_texture =
|
||||
WebGLTexture::new_webxr(context, depth_stencil_texture_id, session);
|
||||
framebuffer
|
||||
.texture2d_even_if_opaque(
|
||||
constants::DEPTH_STENCIL_ATTACHMENT,
|
||||
constants::TEXTURE_2D,
|
||||
Some(&depth_stencil_texture),
|
||||
0,
|
||||
)
|
||||
.ok()?;
|
||||
}
|
||||
|
||||
// Restore the old bindings
|
||||
context.send_command(WebGLCommand::BindTexture(target, saved_texture_id));
|
||||
if let Some(framebuffer_target) = saved_framebuffer_target {
|
||||
framebuffer.bind(framebuffer_target);
|
||||
}
|
||||
if let Some(framebuffer) = saved_framebuffer {
|
||||
framebuffer.bind(framebuffer_target);
|
||||
}
|
||||
Some(())
|
||||
}
|
||||
|
||||
pub fn end_frame(&self, _frame: &XRFrame) -> Option<()> {
|
||||
debug!("XRWebGLLayer end frame");
|
||||
// TODO: invalidate the old texture
|
||||
let framebuffer = self.framebuffer.as_ref()?;
|
||||
// TODO: rebind the current bindings
|
||||
framebuffer.bind(constants::FRAMEBUFFER);
|
||||
framebuffer
|
||||
.texture2d_even_if_opaque(constants::COLOR_ATTACHMENT0, self.texture_target(), None, 0)
|
||||
.ok()?;
|
||||
framebuffer
|
||||
.texture2d_even_if_opaque(
|
||||
constants::DEPTH_STENCIL_ATTACHMENT,
|
||||
constants::DEPTH_STENCIL_ATTACHMENT,
|
||||
None,
|
||||
0,
|
||||
)
|
||||
.ok()?;
|
||||
framebuffer.upcast::<WebGLObject>().context().Flush();
|
||||
Some(())
|
||||
}
|
||||
|
||||
pub(crate) fn context(&self) -> &WebGLRenderingContext {
|
||||
self.xr_layer.context()
|
||||
}
|
||||
}
|
||||
|
||||
impl XRWebGLLayerMethods<crate::DomTypeHolder> for XRWebGLLayer {
|
||||
/// <https://immersive-web.github.io/webxr/#dom-xrwebgllayer-xrwebgllayer>
|
||||
fn Constructor(
|
||||
global: &Window,
|
||||
proto: Option<HandleObject>,
|
||||
can_gc: CanGc,
|
||||
session: &XRSession,
|
||||
context: XRWebGLRenderingContext,
|
||||
init: &XRWebGLLayerInit,
|
||||
) -> Fallible<DomRoot<Self>> {
|
||||
let context = match context {
|
||||
XRWebGLRenderingContext::WebGLRenderingContext(ctx) => ctx,
|
||||
XRWebGLRenderingContext::WebGL2RenderingContext(ctx) => ctx.base_context(),
|
||||
};
|
||||
|
||||
// Step 2
|
||||
if session.is_ended() {
|
||||
return Err(Error::InvalidState);
|
||||
}
|
||||
// XXXManishearth step 3: throw error if context is lost
|
||||
// XXXManishearth step 4: check XR compat flag for immersive sessions
|
||||
|
||||
let (framebuffer, layer_id) = if session.is_immersive() {
|
||||
// Step 9.2. "Initialize layer’s framebuffer to a new opaque framebuffer created with context."
|
||||
let size = session
|
||||
.with_session(|session| session.recommended_framebuffer_resolution())
|
||||
.ok_or(Error::Operation)?;
|
||||
let framebuffer = WebGLFramebuffer::maybe_new_webxr(session, &context, size)
|
||||
.ok_or(Error::Operation)?;
|
||||
|
||||
// Step 9.3. "Allocate and initialize resources compatible with session’s XR device,
|
||||
// including GPU accessible memory buffers, as required to support the compositing of layer."
|
||||
let context_id = WebXRContextId::from(context.context_id());
|
||||
let layer_init = LayerInit::from(init);
|
||||
let layer_id = session
|
||||
.with_session(|session| session.create_layer(context_id, layer_init))
|
||||
.map_err(|_| Error::Operation)?;
|
||||
|
||||
// Step 9.4: "If layer’s resources were unable to be created for any reason,
|
||||
// throw an OperationError and abort these steps."
|
||||
(Some(framebuffer), Some(layer_id))
|
||||
} else {
|
||||
(None, None)
|
||||
};
|
||||
|
||||
// Ensure that we finish setting up this layer before continuing.
|
||||
context.Finish();
|
||||
|
||||
// Step 10. "Return layer."
|
||||
Ok(XRWebGLLayer::new(
|
||||
&global.global(),
|
||||
proto,
|
||||
session,
|
||||
&context,
|
||||
init,
|
||||
framebuffer.as_deref(),
|
||||
layer_id,
|
||||
can_gc,
|
||||
))
|
||||
}
|
||||
|
||||
/// <https://www.w3.org/TR/webxr/#dom-xrwebgllayer-getnativeframebufferscalefactor>
|
||||
fn GetNativeFramebufferScaleFactor(_window: &Window, session: &XRSession) -> Finite<f64> {
|
||||
let value: f64 = if session.is_ended() { 0.0 } else { 1.0 };
|
||||
Finite::wrap(value)
|
||||
}
|
||||
|
||||
/// <https://immersive-web.github.io/webxr/#dom-xrwebgllayer-antialias>
|
||||
fn Antialias(&self) -> bool {
|
||||
self.antialias
|
||||
}
|
||||
|
||||
/// <https://immersive-web.github.io/webxr/#dom-xrwebgllayer-ignoredepthvalues>
|
||||
fn IgnoreDepthValues(&self) -> bool {
|
||||
self.ignore_depth_values
|
||||
}
|
||||
|
||||
/// <https://www.w3.org/TR/webxr/#dom-xrwebgllayer-fixedfoveation>
|
||||
fn GetFixedFoveation(&self) -> Option<Finite<f32>> {
|
||||
// Fixed foveation is only available on Quest/Pico headset runtimes
|
||||
None
|
||||
}
|
||||
|
||||
/// <https://www.w3.org/TR/webxr/#dom-xrwebgllayer-fixedfoveation>
|
||||
fn SetFixedFoveation(&self, _value: Option<Finite<f32>>) {
|
||||
// no-op until fixed foveation is supported
|
||||
}
|
||||
|
||||
/// <https://immersive-web.github.io/webxr/#dom-xrwebgllayer-framebuffer>
|
||||
fn GetFramebuffer(&self) -> Option<DomRoot<WebGLFramebuffer>> {
|
||||
self.framebuffer.as_ref().map(|x| DomRoot::from_ref(&**x))
|
||||
}
|
||||
|
||||
/// <https://immersive-web.github.io/webxr/#dom-xrwebgllayer-framebufferwidth>
|
||||
fn FramebufferWidth(&self) -> u32 {
|
||||
self.size().width
|
||||
}
|
||||
|
||||
/// <https://immersive-web.github.io/webxr/#dom-xrwebgllayer-framebufferheight>
|
||||
fn FramebufferHeight(&self) -> u32 {
|
||||
self.size().height
|
||||
}
|
||||
|
||||
/// <https://immersive-web.github.io/webxr/#dom-xrwebgllayer-getviewport>
|
||||
fn GetViewport(&self, view: &XRView) -> Option<DomRoot<XRViewport>> {
|
||||
if self.session() != view.session() {
|
||||
return None;
|
||||
}
|
||||
|
||||
let index = view.viewport_index();
|
||||
|
||||
let viewport = self.session().with_session(|s| {
|
||||
// Inline sessions
|
||||
if s.viewports().is_empty() {
|
||||
Rect::from_size(self.size().to_i32())
|
||||
} else {
|
||||
s.viewports()[index]
|
||||
}
|
||||
});
|
||||
|
||||
// NOTE: According to spec, viewport sizes should be recalculated here if the
|
||||
// requested viewport scale has changed. However, existing browser implementations
|
||||
// don't seem to do this for stereoscopic immersive sessions.
|
||||
// Revisit if Servo gets support for handheld AR/VR via ARCore/ARKit
|
||||
|
||||
Some(XRViewport::new(&self.global(), viewport))
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue