| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| module device.mojom; |
| |
| import "mojo/common/time.mojom"; |
| import "gpu/ipc/common/mailbox_holder.mojom"; |
| import "gpu/ipc/common/sync_token.mojom"; |
| import "ui/gfx/geometry/mojo/geometry.mojom"; |
| import "ui/gfx/mojo/gpu_fence_handle.mojom"; |
| |
| // A field of view, given by 4 degrees describing the view from a center point. |
| struct VRFieldOfView { |
| float upDegrees; |
| float downDegrees; |
| float leftDegrees; |
| float rightDegrees; |
| }; |
| |
| // A display's position, orientation, velocity, and acceleration state at the |
| // given timestamp. |
| struct VRPose { |
| array<float, 4>? orientation; |
| array<float, 3>? position; |
| array<float, 3>? angularVelocity; |
| array<float, 3>? linearVelocity; |
| array<float, 3>? angularAcceleration; |
| array<float, 3>? linearAcceleration; |
| }; |
| |
| struct VRDisplayCapabilities { |
| bool hasPosition; |
| bool hasExternalDisplay; |
| // Indicates whether the display can actively show imagery on a headset. |
| bool canPresent; |
| }; |
| |
| // Information about the optical properties for an eye in a VRDisplay. |
| struct VREyeParameters { |
| VRFieldOfView fieldOfView; |
| array<float, 3> offset; |
| uint32 renderWidth; |
| uint32 renderHeight; |
| }; |
| |
| struct VRStageParameters { |
| array<float, 16> standingTransform; |
| float sizeX; |
| float sizeZ; |
| }; |
| |
| struct VRDisplayInfo { |
| uint32 index; |
| string displayName; |
| VRDisplayCapabilities capabilities; |
| VRStageParameters? stageParameters; |
| // Parameters required to distort a scene for viewing in a VR headset. Only |
| // required for devices which have the canPresent capability. |
| VREyeParameters? leftEye; |
| VREyeParameters? rightEye; |
| }; |
| |
| // Options supplied by the Renderer when requesting presentation. |
| struct VRRequestPresentOptions { |
| // If true, must use a render path that can preserve drawing buffer |
| // contents across frames. If false, each frame is drawn independently. |
| bool preserve_drawing_buffer; |
| }; |
| |
| // Frame transport method from the Renderer's point of view. |
| enum VRDisplayFrameTransportMethod { |
| NONE = 0, |
| |
| // Renderer should create a new texture handle (Windows) or |
| // texture mailbox (Android Surface path) containing the |
| // frame's image and supply that as a submitFrame argument. |
| SUBMIT_AS_TEXTURE_HANDLE = 1, |
| SUBMIT_AS_MAILBOX_HOLDER = 2, |
| |
| // Not yet implemented: Renderer should draw directly into |
| // a texture mailbox provided for each frame in OnVSync. |
| // DRAW_INTO_TEXTURE_MAILBOX = 3, |
| }; |
| |
| struct VRDisplayFrameTransportOptions { |
| VRDisplayFrameTransportMethod transport_method; |
| |
| // Booleans indicating which of the VRSubmitFrameClient callbacks |
| // are in use. Default is false, the device implementation should set |
| // the ones to true that it needs and can ignore the rest. |
| bool wait_for_transfer_notification; |
| bool wait_for_render_notification; |
| bool wait_for_gpu_fence; |
| }; |
| |
| enum VRDisplayEventReason { |
| NONE = 0, |
| NAVIGATION = 1, |
| MOUNTED = 2, |
| UNMOUNTED = 3 |
| }; |
| |
| // TODO(shaobo.yan@intel.com) : Add comments to describe these interfaces about |
| // how to use and where they live. |
| interface VRService { |
| // TODO(shaobo.yan@intel.com, crbug/701027): Use a factory function which |
| // takes a VRServiceClient so we will never have a half-initialized VRService. |
| SetClient(VRServiceClient client) => (); |
| // Inform the service that the page is listening for vrdisplayactivate events. |
| // TODO(mthiesse): Move SetListeningForActivate onto VRDisplay. |
| SetListeningForActivate(bool listening); |
| }; |
| |
| interface VRServiceClient { |
| OnDisplayConnected(VRMagicWindowProvider magic_window_provider, |
| VRDisplayHost display, VRDisplayClient& request, |
| VRDisplayInfo display_info); |
| }; |
| |
| // After submitting a frame, the VRPresentationProvider will notify the client |
| // about several stages of the render pipeline. This allows pipelining |
| // efficiency. Following VRPresentationProvider::Submit*, the submitted frame |
| // will be transferred (read from, perhaps copied to another texture), and then |
| // rendered (submitted to the underlying VR API). |
| // The client lives in the render process, implemented by VRDisplay. |
| // |
| // See VRDisplayFrameTransportConfiguration which configures which of these |
| // callbacks are in use. |
| interface VRSubmitFrameClient { |
| // The VRPresentationProvider calls this to indicate that the submitted frame |
| // has been transferred, so the backing data (mailbox or GpuMemoryBuffer) can |
| // be reused or discarded. Note that this is a convenience/optimization |
| // feature, not a security feature - if a site discards the data early we may |
| // drop a frame, but nothing will otherwise misbehave. |
| // When the frame wasn't successfully transferred, the client should create a |
| // new mailbox/GpuMemoryBuffer rather than reusing an existing one to recover |
| // for subsequent frames. |
| OnSubmitFrameTransferred(bool success); |
| |
| // The VRPresentationProvider calls this after the frame was handed off to the |
| // underlying VR API. This allows some pipelining of CPU/GPU work, while |
| // delaying expensive tasks for a subsequent frame until the current frame has |
| // completed. |
| OnSubmitFrameRendered(); |
| |
| // This callback provides a GpuFence corresponding to the previous frame's |
| // rendering completion, intended for use with a server wait issued before |
| // the following wait to prevent its rendering work from competing with |
| // the previous frame. |
| OnSubmitFrameGpuFence(gfx.mojom.GpuFenceHandle gpu_fence_handle); |
| }; |
| |
| |
| // Provides a communication channel from the renderer to the browser-side host |
| // of a (device/) VrDisplayImpl. |
| interface VRDisplayHost { |
| // The returned transport_options is marked optional: it's null for |
| // a failure result but must be non-null for a success result. |
| RequestPresent(VRSubmitFrameClient client, |
| VRPresentationProvider& request, |
| VRRequestPresentOptions options) => ( |
| bool success, |
| VRDisplayFrameTransportOptions? transport_options); |
| ExitPresent(); |
| }; |
| |
| // Provides the necessary functionality for a non-presenting WebVR page to draw |
| // magic window content. |
| interface VRMagicWindowProvider { |
| GetPose() => (VRPose? pose); |
| }; |
| |
| // Provides the necessary functionality for a presenting WebVR page to draw |
| // frames for a VrDisplay. |
| // This interface is hosted in the Browser process, but will move to a sandboxed |
| // utility process on Windows. The render process communicates with it. |
| interface VRPresentationProvider { |
| enum VSyncStatus { SUCCESS, CLOSING }; |
| |
| // The frameId maps a VSync to a frame arriving from the compositor. IDs will |
| // be reused after the frame arrives from the compositor. Negative IDs imply |
| // no mapping. |
| GetVSync() => (VRPose? pose, mojo.common.mojom.TimeDelta time, int16 frame_id, |
| VSyncStatus status); |
| |
| UpdateLayerBounds(int16 frame_id, gfx.mojom.RectF left_bounds, |
| gfx.mojom.RectF right_bounds, gfx.mojom.Size source_size); |
| |
| // VRDisplayFrameTransportMethod SUBMIT_AS_MAILBOX_HOLDER |
| SubmitFrame(int16 frame_id, gpu.mojom.MailboxHolder mailbox_holder, |
| mojo.common.mojom.TimeDelta time_waited); |
| |
| // VRDisplayFrameTransportMethod SUBMIT_AS_TEXTURE_HANDLE |
| // TODO(https://crbug.com/676224): Support preprocessing of mojom files, since |
| // this is Windows only. |
| SubmitFrameWithTextureHandle(int16 frameId, handle texture); |
| }; |
| |
| interface VRDisplayClient { |
| OnChanged(VRDisplayInfo display); |
| OnExitPresent(); |
| OnBlur(); |
| OnFocus(); |
| OnActivate(VRDisplayEventReason reason) => (bool will_not_present); |
| OnDeactivate(VRDisplayEventReason reason); |
| }; |