mirror of
https://github.com/servo/servo.git
synced 2025-07-11 17:33:47 +01:00
275 lines
7.3 KiB
Text
275 lines
7.3 KiB
Text
// GENERATED CONTENT - DO NOT EDIT
|
|
// Content was automatically extracted by Reffy into reffy-reports
|
|
// (https://github.com/tidoust/reffy-reports)
|
|
// Source: WebXR Device API (https://immersive-web.github.io/webxr/)
|
|
|
|
partial interface Navigator {
|
|
[SecureContext, SameObject] readonly attribute XR xr;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XR : EventTarget {
|
|
// Methods
|
|
Promise<void> supportsSessionMode(XRSessionMode mode);
|
|
Promise<XRSession> requestSession(XRSessionMode mode);
|
|
|
|
// Events
|
|
attribute EventHandler ondevicechange;
|
|
};
|
|
|
|
enum XRSessionMode {
|
|
"inline",
|
|
"immersive-vr",
|
|
"immersive-ar"
|
|
};
|
|
|
|
enum XREnvironmentBlendMode {
|
|
"opaque",
|
|
"additive",
|
|
"alpha-blend",
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRSession : EventTarget {
|
|
// Attributes
|
|
readonly attribute XREnvironmentBlendMode environmentBlendMode;
|
|
readonly attribute XRRenderState renderState;
|
|
readonly attribute XRSpace viewerSpace;
|
|
|
|
// Methods
|
|
void updateRenderState(optional XRRenderStateInit state);
|
|
Promise<XRReferenceSpace> requestReferenceSpace(XRReferenceSpaceOptions options);
|
|
|
|
FrozenArray<XRInputSource> getInputSources();
|
|
|
|
long requestAnimationFrame(XRFrameRequestCallback callback);
|
|
void cancelAnimationFrame(long handle);
|
|
|
|
Promise<void> end();
|
|
|
|
// Events
|
|
attribute EventHandler onblur;
|
|
attribute EventHandler onfocus;
|
|
attribute EventHandler onend;
|
|
attribute EventHandler onselect;
|
|
attribute EventHandler oninputsourceschange;
|
|
attribute EventHandler onselectstart;
|
|
attribute EventHandler onselectend;
|
|
};
|
|
|
|
dictionary XRRenderStateInit {
|
|
double depthNear;
|
|
double depthFar;
|
|
double inlineVerticalFieldOfView;
|
|
XRLayer? baseLayer;
|
|
XRPresentationContext? outputContext;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRRenderState {
|
|
readonly attribute double depthNear;
|
|
readonly attribute double depthFar;
|
|
readonly attribute double? inlineVerticalFieldOfView;
|
|
readonly attribute XRLayer? baseLayer;
|
|
readonly attribute XRPresentationContext? outputContext;
|
|
};
|
|
|
|
callback XRFrameRequestCallback = void (DOMHighResTimeStamp time, XRFrame frame);
|
|
|
|
[SecureContext, Exposed=Window] interface XRFrame {
|
|
readonly attribute XRSession session;
|
|
|
|
XRViewerPose? getViewerPose(XRReferenceSpace referenceSpace);
|
|
XRPose? getPose(XRSpace space, XRSpace relativeTo);
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRSpace : EventTarget {
|
|
|
|
};
|
|
|
|
enum XRReferenceSpaceType {
|
|
"identity",
|
|
"stationary",
|
|
"bounded",
|
|
"unbounded"
|
|
};
|
|
|
|
enum XRStationaryReferenceSpaceSubtype {
|
|
"eye-level",
|
|
"floor-level",
|
|
"position-disabled"
|
|
};
|
|
|
|
dictionary XRReferenceSpaceOptions {
|
|
required XRReferenceSpaceType type;
|
|
XRStationaryReferenceSpaceSubtype subtype;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRReferenceSpace : XRSpace {
|
|
attribute XRRigidTransform originOffset;
|
|
attribute EventHandler onreset;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window]
|
|
interface XRStationaryReferenceSpace : XRReferenceSpace {
|
|
};
|
|
|
|
[SecureContext, Exposed=Window]
|
|
interface XRBoundedReferenceSpace : XRReferenceSpace {
|
|
readonly attribute FrozenArray<DOMPointReadOnly> boundsGeometry;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window]
|
|
|
|
interface XRUnboundedReferenceSpace : XRReferenceSpace {
|
|
};
|
|
|
|
enum XREye {
|
|
"left",
|
|
"right"
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRView {
|
|
readonly attribute XREye eye;
|
|
readonly attribute Float32Array projectionMatrix;
|
|
readonly attribute XRRigidTransform transform;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRViewport {
|
|
readonly attribute long x;
|
|
readonly attribute long y;
|
|
readonly attribute long width;
|
|
readonly attribute long height;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window,
|
|
Constructor(optional DOMPointInit position, optional DOMPointInit orientation)]
|
|
interface XRRigidTransform {
|
|
readonly attribute DOMPointReadOnly position;
|
|
readonly attribute DOMPointReadOnly orientation;
|
|
readonly attribute Float32Array matrix;
|
|
[SameObject] readonly attribute XRRigidTransform inverse;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window,
|
|
Constructor(optional DOMPointInit origin, optional DOMPointInit direction),
|
|
Constructor(XRRigidTransform transform)]
|
|
interface XRRay {
|
|
readonly attribute DOMPointReadOnly origin;
|
|
readonly attribute DOMPointReadOnly direction;
|
|
readonly attribute Float32Array matrix;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRPose {
|
|
readonly attribute XRRigidTransform transform;
|
|
readonly attribute boolean emulatedPosition;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRViewerPose : XRPose {
|
|
readonly attribute FrozenArray<XRView> views;
|
|
};
|
|
|
|
enum XRHandedness {
|
|
"none",
|
|
"left",
|
|
"right"
|
|
};
|
|
|
|
enum XRTargetRayMode {
|
|
"gaze",
|
|
"tracked-pointer",
|
|
"screen"
|
|
};
|
|
|
|
[SecureContext, Exposed=Window]
|
|
interface XRInputSource {
|
|
readonly attribute XRHandedness handedness;
|
|
readonly attribute XRTargetRayMode targetRayMode;
|
|
readonly attribute XRSpace targetRaySpace;
|
|
readonly attribute XRSpace? gripSpace;
|
|
readonly attribute Gamepad? gamepad;
|
|
};
|
|
|
|
enum GamepadMappingType {
|
|
"", // Defined in the Gamepad API
|
|
"standard", // Defined in the Gamepad API
|
|
"xr-standard",
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRLayer {};
|
|
|
|
typedef (WebGLRenderingContext or
|
|
WebGL2RenderingContext) XRWebGLRenderingContext;
|
|
|
|
dictionary XRWebGLLayerInit {
|
|
boolean antialias = true;
|
|
boolean depth = true;
|
|
boolean stencil = false;
|
|
boolean alpha = true;
|
|
boolean ignoreDepthValues = false;
|
|
double framebufferScaleFactor = 1.0;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window, Constructor(XRSession session,
|
|
XRWebGLRenderingContext context,
|
|
optional XRWebGLLayerInit layerInit)]
|
|
interface XRWebGLLayer : XRLayer {
|
|
// Attributes
|
|
readonly attribute XRWebGLRenderingContext context;
|
|
|
|
readonly attribute boolean antialias;
|
|
readonly attribute boolean ignoreDepthValues;
|
|
|
|
readonly attribute WebGLFramebuffer framebuffer;
|
|
readonly attribute unsigned long framebufferWidth;
|
|
readonly attribute unsigned long framebufferHeight;
|
|
|
|
// Methods
|
|
XRViewport? getViewport(XRView view);
|
|
void requestViewportScaling(double viewportScaleFactor);
|
|
|
|
// Static Methods
|
|
static double getNativeFramebufferScaleFactor(XRSession session);
|
|
};
|
|
|
|
partial dictionary WebGLContextAttributes {
|
|
boolean xrCompatible = null;
|
|
};
|
|
|
|
partial interface mixin WebGLRenderingContextBase {
|
|
Promise<void> makeXRCompatible();
|
|
};
|
|
|
|
[SecureContext, Exposed=Window] interface XRPresentationContext {
|
|
readonly attribute HTMLCanvasElement canvas;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window, Constructor(DOMString type, XRSessionEventInit eventInitDict)]
|
|
interface XRSessionEvent : Event {
|
|
readonly attribute XRSession session;
|
|
};
|
|
|
|
dictionary XRSessionEventInit : EventInit {
|
|
required XRSession session;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window, Constructor(DOMString type, XRInputSourceEventInit eventInitDict)]
|
|
interface XRInputSourceEvent : Event {
|
|
readonly attribute XRFrame frame;
|
|
readonly attribute XRInputSource inputSource;
|
|
readonly attribute long? buttonIndex;
|
|
};
|
|
|
|
dictionary XRInputSourceEventInit : EventInit {
|
|
required XRFrame frame;
|
|
required XRInputSource inputSource;
|
|
long? buttonIndex = null;
|
|
};
|
|
|
|
[SecureContext, Exposed=Window, Constructor(DOMString type, XRReferenceSpaceEventInit eventInitDict)]
|
|
interface XRReferenceSpaceEvent : Event {
|
|
readonly attribute XRReferenceSpace referenceSpace;
|
|
readonly attribute XRRigidTransform? transform;
|
|
};
|
|
|
|
dictionary XRReferenceSpaceEventInit : EventInit {
|
|
required XRReferenceSpace referenceSpace;
|
|
XRRigidTransform transform;
|
|
};
|