gecko-dev/dom/webidl/VRDisplay.webidl
Daosheng Mu 7168326772 Bug 1299932 - Part 1: Implement gamepadPose attribute in Gamepad API; r=kip,qdot
MozReview-Commit-ID: DiJadVc2TyE

--HG--
extra : rebase_source : f4571090518a084b6d4b1e6fccf951510b227fbd
2016-10-24 18:04:41 +08:00

274 lines
9.0 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* -*- Mode: IDL; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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 http://mozilla.org/MPL/2.0/. */
enum VREye {
"left",
"right"
};
[Pref="dom.vr.enabled",
HeaderFile="mozilla/dom/VRDisplay.h"]
interface VRFieldOfView {
readonly attribute double upDegrees;
readonly attribute double rightDegrees;
readonly attribute double downDegrees;
readonly attribute double leftDegrees;
};
typedef (HTMLCanvasElement or OffscreenCanvas) VRSource;
dictionary VRLayer {
/**
* XXX - When WebVR in WebWorkers is implemented, HTMLCanvasElement below
* should be replaced with VRSource.
*/
HTMLCanvasElement? source = null;
/**
* The left and right viewports contain 4 values defining the viewport
* rectangles within the canvas to present to the eye in UV space.
* [0] left offset of the viewport (0.0 - 1.0)
* [1] top offset of the viewport (0.0 - 1.0)
* [2] width of the viewport (0.0 - 1.0)
* [3] height of the viewport (0.0 - 1.0)
*
* When no values are passed, they will be processed as though the left
* and right sides of the viewport were passed:
*
* leftBounds: [0.0, 0.0, 0.5, 1.0]
* rightBounds: [0.5, 0.0, 0.5, 1.0]
*/
sequence<float> leftBounds = [];
sequence<float> rightBounds = [];
};
/**
* Values describing the capabilities of a VRDisplay.
* These are expected to be static per-device/per-user.
*/
[Pref="dom.vr.enabled",
HeaderFile="mozilla/dom/VRDisplay.h"]
interface VRDisplayCapabilities {
/**
* hasPosition is true if the VRDisplay is capable of tracking its position.
*/
readonly attribute boolean hasPosition;
/**
* hasOrientation is true if the VRDisplay is capable of tracking its orientation.
*/
readonly attribute boolean hasOrientation;
/**
* Whether the VRDisplay is separate from the devices
* primary display. If presenting VR content will obscure
* other content on the device, this should be false. When
* false, the application should not attempt to mirror VR content
* or update non-VR UI because that content will not be visible.
*/
readonly attribute boolean hasExternalDisplay;
/**
* Whether the VRDisplay is capable of presenting content to an HMD or similar device.
* Can be used to indicate “magic window” devices that are capable of 6DoF tracking but for
* which requestPresent is not meaningful. If false then calls to requestPresent should
* always fail, and getEyeParameters should return null.
*/
readonly attribute boolean canPresent;
/**
* Indicates the maximum length of the array that requestPresent() will accept. MUST be 1 if
canPresent is true, 0 otherwise.
*/
readonly attribute unsigned long maxLayers;
};
/**
* Values describing the the stage / play area for devices
* that support room-scale experiences.
*/
[Pref="dom.vr.enabled",
HeaderFile="mozilla/dom/VRDisplay.h"]
interface VRStageParameters {
/**
* A 16-element array containing the components of a column-major 4x4
* affine transform matrix. This matrix transforms the sitting-space position
* returned by get{Immediate}Pose() to a standing-space position.
*/
[Throws] readonly attribute Float32Array sittingToStandingTransform;
/**
* Dimensions of the play-area bounds. The bounds are defined
* as an axis-aligned rectangle on the floor.
* The center of the rectangle is at (0,0,0) in standing-space
* coordinates.
* These bounds are defined for safety purposes.
* Content should not require the user to move beyond these
* bounds; however, it is possible for the user to ignore
* the bounds resulting in position values outside of
* this rectangle.
*/
readonly attribute float sizeX;
readonly attribute float sizeZ;
};
[Pref="dom.vr.enabled",
HeaderFile="mozilla/dom/VRDisplay.h"]
interface VRPose : Pose
{
};
[Constructor,
Pref="dom.vr.enabled",
HeaderFile="mozilla/dom/VRDisplay.h"]
interface VRFrameData {
readonly attribute DOMHighResTimeStamp timestamp;
[Throws, Pure] readonly attribute Float32Array leftProjectionMatrix;
[Throws, Pure] readonly attribute Float32Array leftViewMatrix;
[Throws, Pure] readonly attribute Float32Array rightProjectionMatrix;
[Throws, Pure] readonly attribute Float32Array rightViewMatrix;
[Pure] readonly attribute VRPose pose;
};
[Pref="dom.vr.enabled",
HeaderFile="mozilla/dom/VRDisplay.h"]
interface VREyeParameters {
/**
* offset is a 3-component vector representing an offset to
* translate the eye. This value may vary from frame
* to frame if the user adjusts their headset ipd.
*/
[Constant, Throws] readonly attribute Float32Array offset;
/* These values may vary as the user adjusts their headset ipd. */
[Constant] readonly attribute VRFieldOfView fieldOfView;
/**
* renderWidth and renderHeight specify the recommended render target
* size of each eye viewport, in pixels. If multiple eyes are rendered
* in a single render target, then the render target should be made large
* enough to fit both viewports.
*/
[Constant] readonly attribute unsigned long renderWidth;
[Constant] readonly attribute unsigned long renderHeight;
};
[Pref="dom.vr.enabled",
HeaderFile="mozilla/dom/VRDisplay.h"]
interface VRDisplay : EventTarget {
readonly attribute boolean isConnected;
readonly attribute boolean isPresenting;
/**
* Dictionary of capabilities describing the VRDisplay.
*/
[Constant] readonly attribute VRDisplayCapabilities capabilities;
/**
* If this VRDisplay supports room-scale experiences, the optional
* stage attribute contains details on the room-scale parameters.
*/
readonly attribute VRStageParameters? stageParameters;
/* Return the current VREyeParameters for the given eye. */
VREyeParameters getEyeParameters(VREye whichEye);
/**
* An identifier for this distinct VRDisplay. Used as an
* association point in the Gamepad API.
*/
[Constant] readonly attribute unsigned long displayId;
/**
* A display name, a user-readable name identifying it.
*/
[Constant] readonly attribute DOMString displayName;
/**
* Populates the passed VRFrameData with the information required to render
* the current frame.
*/
boolean getFrameData(VRFrameData frameData);
/**
* Return a VRPose containing the future predicted pose of the VRDisplay
* when the current frame will be presented. Subsequent calls to getPose()
* MUST return a VRPose with the same values until the next call to
* submitFrame().
*
* The VRPose will contain the position, orientation, velocity,
* and acceleration of each of these properties.
*/
[NewObject] VRPose getPose();
/**
* Reset the pose for this display, treating its current position and
* orientation as the "origin/zero" values. VRPose.position,
* VRPose.orientation, and VRStageParameters.sittingToStandingTransform may be
* updated when calling resetPose(). This should be called in only
* sitting-space experiences.
*/
void resetPose();
/**
* z-depth defining the near plane of the eye view frustum
* enables mapping of values in the render target depth
* attachment to scene coordinates. Initially set to 0.01.
*/
attribute double depthNear;
/**
* z-depth defining the far plane of the eye view frustum
* enables mapping of values in the render target depth
* attachment to scene coordinates. Initially set to 10000.0.
*/
attribute double depthFar;
/**
* The callback passed to `requestAnimationFrame` will be called
* any time a new frame should be rendered. When the VRDisplay is
* presenting the callback will be called at the native refresh
* rate of the HMD. When not presenting this function acts
* identically to how window.requestAnimationFrame acts. Content should
* make no assumptions of frame rate or vsync behavior as the HMD runs
* asynchronously from other displays and at differing refresh rates.
*/
[Throws] long requestAnimationFrame(FrameRequestCallback callback);
/**
* Passing the value returned by `requestAnimationFrame` to
* `cancelAnimationFrame` will unregister the callback.
*/
[Throws] void cancelAnimationFrame(long handle);
/**
* Begin presenting to the VRDisplay. Must be called in response to a user gesture.
* Repeat calls while already presenting will update the VRLayers being displayed.
*/
[Throws] Promise<void> requestPresent(sequence<VRLayer> layers);
/**
* Stops presenting to the VRDisplay.
*/
[Throws] Promise<void> exitPresent();
/**
* Get the layers currently being presented.
*/
sequence<VRLayer> getLayers();
/**
* The VRLayer provided to the VRDisplay will be captured and presented
* in the HMD. Calling this function has the same effect on the source
* canvas as any other operation that uses its source image, and canvases
* created without preserveDrawingBuffer set to true will be cleared.
*/
void submitFrame();
};