servo/tests/wpt/web-platform-tests/interfaces/webxr.idl

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;
};