tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

webxr.idl (9621B)

      1 // GENERATED CONTENT - DO NOT EDIT
      2 // Content was automatically extracted by Reffy into webref
      3 // (https://github.com/w3c/webref)
      4 // Source: WebXR Device API (https://immersive-web.github.io/webxr/)
      5 
      6 partial interface Navigator {
      7  [SecureContext, SameObject] readonly attribute XRSystem xr;
      8 };
      9 
     10 [SecureContext, Exposed=Window] interface XRSystem : EventTarget {
     11  // Methods
     12  Promise<boolean> isSessionSupported(XRSessionMode mode);
     13  [NewObject] Promise<XRSession> requestSession(XRSessionMode mode, optional XRSessionInit options = {});
     14 
     15  // Events
     16  attribute EventHandler ondevicechange;
     17 };
     18 
     19 enum XRSessionMode {
     20  "inline",
     21  "immersive-vr",
     22  "immersive-ar"
     23 };
     24 
     25 dictionary XRSessionInit {
     26  sequence<DOMString> requiredFeatures;
     27  sequence<DOMString> optionalFeatures;
     28 };
     29 
     30 enum XRVisibilityState {
     31  "visible",
     32  "visible-blurred",
     33  "hidden",
     34 };
     35 
     36 [SecureContext, Exposed=Window] interface XRSession : EventTarget {
     37  // Attributes
     38  readonly attribute XRVisibilityState visibilityState;
     39  readonly attribute float? frameRate;
     40  readonly attribute Float32Array? supportedFrameRates;
     41  [SameObject] readonly attribute XRRenderState renderState;
     42  [SameObject] readonly attribute XRInputSourceArray inputSources;
     43  [SameObject] readonly attribute XRInputSourceArray trackedSources;
     44  readonly attribute FrozenArray<DOMString> enabledFeatures;
     45  readonly attribute boolean isSystemKeyboardSupported;
     46 
     47  // Methods
     48  undefined updateRenderState(optional XRRenderStateInit state = {});
     49  Promise<undefined> updateTargetFrameRate(float rate);
     50  [NewObject] Promise<XRReferenceSpace> requestReferenceSpace(XRReferenceSpaceType type);
     51 
     52  unsigned long requestAnimationFrame(XRFrameRequestCallback callback);
     53  undefined cancelAnimationFrame(unsigned long handle);
     54 
     55  Promise<undefined> end();
     56 
     57  // Events
     58  attribute EventHandler onend;
     59  attribute EventHandler oninputsourceschange;
     60  attribute EventHandler onselect;
     61  attribute EventHandler onselectstart;
     62  attribute EventHandler onselectend;
     63  attribute EventHandler onsqueeze;
     64  attribute EventHandler onsqueezestart;
     65  attribute EventHandler onsqueezeend;
     66  attribute EventHandler onvisibilitychange;
     67  attribute EventHandler onframeratechange;
     68 };
     69 
     70 dictionary XRRenderStateInit {
     71  double depthNear;
     72  double depthFar;
     73  boolean passthroughFullyObscured;
     74  double inlineVerticalFieldOfView;
     75  XRWebGLLayer? baseLayer;
     76  sequence<XRLayer>? layers;
     77 };
     78 
     79 [SecureContext, Exposed=Window] interface XRRenderState {
     80  readonly attribute double depthNear;
     81  readonly attribute double depthFar;
     82  readonly attribute boolean? passthroughFullyObscured;
     83  readonly attribute double? inlineVerticalFieldOfView;
     84  readonly attribute XRWebGLLayer? baseLayer;
     85 };
     86 
     87 callback XRFrameRequestCallback = undefined (DOMHighResTimeStamp time, XRFrame frame);
     88 
     89 [SecureContext, Exposed=Window] interface XRFrame {
     90  [SameObject] readonly attribute XRSession session;
     91  readonly attribute DOMHighResTimeStamp predictedDisplayTime;
     92 
     93  XRViewerPose? getViewerPose(XRReferenceSpace referenceSpace);
     94  XRPose? getPose(XRSpace space, XRSpace baseSpace);
     95 };
     96 
     97 [SecureContext, Exposed=Window] interface XRSpace : EventTarget {
     98 
     99 };
    100 
    101 enum XRReferenceSpaceType {
    102  "viewer",
    103  "local",
    104  "local-floor",
    105  "bounded-floor",
    106  "unbounded"
    107 };
    108 
    109 [SecureContext, Exposed=Window]
    110 interface XRReferenceSpace : XRSpace {
    111  [NewObject] XRReferenceSpace getOffsetReferenceSpace(XRRigidTransform originOffset);
    112 
    113  attribute EventHandler onreset;
    114 };
    115 
    116 [SecureContext, Exposed=Window]
    117 interface XRBoundedReferenceSpace : XRReferenceSpace {
    118  readonly attribute FrozenArray<DOMPointReadOnly> boundsGeometry;
    119 };
    120 
    121 [SecureContext, Exposed=Window] interface mixin XRViewGeometry {
    122  readonly attribute Float32Array projectionMatrix;
    123  [SameObject] readonly attribute XRRigidTransform transform;
    124 };
    125 
    126 enum XREye {
    127  "none",
    128  "left",
    129  "right"
    130 };
    131 
    132 [SecureContext, Exposed=Window] interface XRView {
    133  readonly attribute XREye eye;
    134  readonly attribute unsigned long index;
    135  readonly attribute double? recommendedViewportScale;
    136 
    137  undefined requestViewportScale(double? scale);
    138 };
    139 
    140 XRView includes XRViewGeometry;
    141 
    142 [SecureContext, Exposed=Window] interface XRViewport {
    143  readonly attribute long x;
    144  readonly attribute long y;
    145  readonly attribute long width;
    146  readonly attribute long height;
    147 };
    148 
    149 [SecureContext, Exposed=Window]
    150 interface XRRigidTransform {
    151  constructor(optional DOMPointInit position = {}, optional DOMPointInit orientation = {});
    152  [SameObject] readonly attribute DOMPointReadOnly position;
    153  [SameObject] readonly attribute DOMPointReadOnly orientation;
    154  readonly attribute Float32Array matrix;
    155  [SameObject] readonly attribute XRRigidTransform inverse;
    156 };
    157 
    158 [SecureContext, Exposed=Window] interface XRPose {
    159  [SameObject] readonly attribute XRRigidTransform transform;
    160  [SameObject] readonly attribute DOMPointReadOnly? linearVelocity;
    161  [SameObject] readonly attribute DOMPointReadOnly? angularVelocity;
    162 
    163  readonly attribute boolean emulatedPosition;
    164 };
    165 
    166 [SecureContext, Exposed=Window] interface XRViewerPose : XRPose {
    167  [SameObject] readonly attribute FrozenArray<XRView> views;
    168 };
    169 
    170 enum XRHandedness {
    171  "none",
    172  "left",
    173  "right"
    174 };
    175 
    176 enum XRTargetRayMode {
    177  "gaze",
    178  "tracked-pointer",
    179  "screen",
    180  "transient-pointer"
    181 };
    182 
    183 [SecureContext, Exposed=Window]
    184 interface XRInputSource {
    185  readonly attribute XRHandedness handedness;
    186  readonly attribute XRTargetRayMode targetRayMode;
    187  [SameObject] readonly attribute XRSpace targetRaySpace;
    188  [SameObject] readonly attribute XRSpace? gripSpace;
    189  [SameObject] readonly attribute FrozenArray<DOMString> profiles;
    190  readonly attribute boolean skipRendering;
    191 };
    192 
    193 [SecureContext, Exposed=Window]
    194 interface XRInputSourceArray {
    195  iterable<XRInputSource>;
    196  readonly attribute unsigned long length;
    197  getter XRInputSource(unsigned long index);
    198 };
    199 
    200 [SecureContext, Exposed=Window]
    201 interface XRLayer : EventTarget {};
    202 
    203 typedef (WebGLRenderingContext or
    204         WebGL2RenderingContext) XRWebGLRenderingContext;
    205 
    206 dictionary XRWebGLLayerInit {
    207  boolean antialias = true;
    208  boolean depth = true;
    209  boolean stencil = false;
    210  boolean alpha = true;
    211  boolean ignoreDepthValues = false;
    212  double framebufferScaleFactor = 1.0;
    213 };
    214 
    215 [SecureContext, Exposed=Window]
    216 interface XRWebGLLayer: XRLayer {
    217  constructor(XRSession session,
    218             XRWebGLRenderingContext context,
    219             optional XRWebGLLayerInit layerInit = {});
    220  // Attributes
    221  readonly attribute boolean antialias;
    222  readonly attribute boolean ignoreDepthValues;
    223  attribute float? fixedFoveation;
    224 
    225  [SameObject] readonly attribute WebGLFramebuffer? framebuffer;
    226  readonly attribute unsigned long framebufferWidth;
    227  readonly attribute unsigned long framebufferHeight;
    228 
    229  // Methods
    230  XRViewport? getViewport(XRView view);
    231 
    232  // Static Methods
    233  static double getNativeFramebufferScaleFactor(XRSession session);
    234 };
    235 
    236 partial dictionary WebGLContextAttributes {
    237    boolean xrCompatible = false;
    238 };
    239 
    240 partial interface mixin WebGLRenderingContextBase {
    241    [NewObject] Promise<undefined> makeXRCompatible();
    242 };
    243 
    244 [SecureContext, Exposed=Window]
    245 interface XRSessionEvent : Event {
    246  constructor(DOMString type, XRSessionEventInit eventInitDict);
    247  [SameObject] readonly attribute XRSession session;
    248 };
    249 
    250 dictionary XRSessionEventInit : EventInit {
    251  required XRSession session;
    252 };
    253 
    254 [SecureContext, Exposed=Window]
    255 interface XRInputSourceEvent : Event {
    256  constructor(DOMString type, XRInputSourceEventInit eventInitDict);
    257  [SameObject] readonly attribute XRFrame frame;
    258  [SameObject] readonly attribute XRInputSource inputSource;
    259 };
    260 
    261 dictionary XRInputSourceEventInit : EventInit {
    262  required XRFrame frame;
    263  required XRInputSource inputSource;
    264 };
    265 
    266 [SecureContext, Exposed=Window]
    267 interface XRInputSourcesChangeEvent : Event {
    268  constructor(DOMString type, XRInputSourcesChangeEventInit eventInitDict);
    269  [SameObject] readonly attribute XRSession session;
    270  [SameObject] readonly attribute FrozenArray<XRInputSource> added;
    271  [SameObject] readonly attribute FrozenArray<XRInputSource> removed;
    272 };
    273 
    274 dictionary XRInputSourcesChangeEventInit : EventInit {
    275  required XRSession session;
    276  required sequence<XRInputSource> added;
    277  required sequence<XRInputSource> removed;
    278 
    279 };
    280 
    281 [SecureContext, Exposed=Window]
    282 interface XRReferenceSpaceEvent : Event {
    283  constructor(DOMString type, XRReferenceSpaceEventInit eventInitDict);
    284  [SameObject] readonly attribute XRReferenceSpace referenceSpace;
    285  [SameObject] readonly attribute XRRigidTransform? transform;
    286 };
    287 
    288 dictionary XRReferenceSpaceEventInit : EventInit {
    289  required XRReferenceSpace referenceSpace;
    290  XRRigidTransform? transform = null;
    291 };
    292 
    293 [SecureContext, Exposed=Window]
    294 interface XRVisibilityMaskChangeEvent : Event {
    295  constructor(DOMString type, XRVisibilityMaskChangeEventInit eventInitDict);
    296  [SameObject] readonly attribute XRSession session;
    297  readonly attribute XREye eye;
    298  readonly attribute unsigned long index;
    299  [SameObject] readonly attribute Float32Array vertices;
    300  [SameObject] readonly attribute Uint32Array indices;
    301 };
    302 
    303 dictionary XRVisibilityMaskChangeEventInit : EventInit {
    304  required XRSession session;
    305  required XREye eye;
    306  required unsigned long index;
    307  required Float32Array vertices;
    308  required Uint32Array indices;
    309 };
    310 
    311 dictionary XRSessionSupportedPermissionDescriptor: PermissionDescriptor {
    312  XRSessionMode mode;
    313 };
    314 
    315 dictionary XRPermissionDescriptor: PermissionDescriptor {
    316  XRSessionMode mode;
    317  sequence<DOMString> requiredFeatures;
    318  sequence<DOMString> optionalFeatures;
    319 };
    320 
    321 [Exposed=Window]
    322 interface XRPermissionStatus: PermissionStatus {
    323  attribute FrozenArray<DOMString> granted;
    324 };