summaryrefslogtreecommitdiffstats
path: root/gfx/vr/service/OculusSession.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/vr/service/OculusSession.cpp')
-rw-r--r--gfx/vr/service/OculusSession.cpp1525
1 files changed, 1525 insertions, 0 deletions
diff --git a/gfx/vr/service/OculusSession.cpp b/gfx/vr/service/OculusSession.cpp
new file mode 100644
index 0000000000..07b0f208e3
--- /dev/null
+++ b/gfx/vr/service/OculusSession.cpp
@@ -0,0 +1,1525 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* 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/. */
+
+#ifndef XP_WIN
+# error "Oculus support only available for Windows"
+#endif
+
+#include <math.h>
+#include <d3d11.h>
+
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/dom/GamepadEventTypes.h"
+#include "mozilla/dom/GamepadBinding.h"
+#include "mozilla/gfx/DeviceManagerDx.h"
+#include "mozilla/gfx/Logging.h"
+#include "mozilla/SharedLibrary.h"
+#include "OculusSession.h"
+
+/** XXX The DX11 objects and quad blitting could be encapsulated
+ * into a separate object if either Oculus starts supporting
+ * non-Windows platforms or the blit is needed by other HMD\
+ * drivers.
+ * Alternately, we could remove the extra blit for
+ * Oculus as well with some more refactoring.
+ */
+
+// See CompositorD3D11Shaders.h
+namespace mozilla {
+namespace layers {
+struct ShaderBytes {
+ const void* mData;
+ size_t mLength;
+};
+extern ShaderBytes sRGBShader;
+extern ShaderBytes sLayerQuadVS;
+} // namespace layers
+} // namespace mozilla
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+using namespace mozilla::layers;
+
+namespace {
+
+static pfn_ovr_Initialize ovr_Initialize = nullptr;
+static pfn_ovr_Shutdown ovr_Shutdown = nullptr;
+static pfn_ovr_GetLastErrorInfo ovr_GetLastErrorInfo = nullptr;
+static pfn_ovr_GetVersionString ovr_GetVersionString = nullptr;
+static pfn_ovr_TraceMessage ovr_TraceMessage = nullptr;
+static pfn_ovr_IdentifyClient ovr_IdentifyClient = nullptr;
+static pfn_ovr_GetHmdDesc ovr_GetHmdDesc = nullptr;
+static pfn_ovr_GetTrackerCount ovr_GetTrackerCount = nullptr;
+static pfn_ovr_GetTrackerDesc ovr_GetTrackerDesc = nullptr;
+static pfn_ovr_Create ovr_Create = nullptr;
+static pfn_ovr_Destroy ovr_Destroy = nullptr;
+static pfn_ovr_GetSessionStatus ovr_GetSessionStatus = nullptr;
+static pfn_ovr_IsExtensionSupported ovr_IsExtensionSupported = nullptr;
+static pfn_ovr_EnableExtension ovr_EnableExtension = nullptr;
+static pfn_ovr_SetTrackingOriginType ovr_SetTrackingOriginType = nullptr;
+static pfn_ovr_GetTrackingOriginType ovr_GetTrackingOriginType = nullptr;
+static pfn_ovr_RecenterTrackingOrigin ovr_RecenterTrackingOrigin = nullptr;
+static pfn_ovr_SpecifyTrackingOrigin ovr_SpecifyTrackingOrigin = nullptr;
+static pfn_ovr_ClearShouldRecenterFlag ovr_ClearShouldRecenterFlag = nullptr;
+static pfn_ovr_GetTrackingState ovr_GetTrackingState = nullptr;
+static pfn_ovr_GetDevicePoses ovr_GetDevicePoses = nullptr;
+static pfn_ovr_GetTrackerPose ovr_GetTrackerPose = nullptr;
+static pfn_ovr_GetInputState ovr_GetInputState = nullptr;
+static pfn_ovr_GetConnectedControllerTypes ovr_GetConnectedControllerTypes =
+ nullptr;
+static pfn_ovr_GetTouchHapticsDesc ovr_GetTouchHapticsDesc = nullptr;
+static pfn_ovr_SetControllerVibration ovr_SetControllerVibration = nullptr;
+static pfn_ovr_SubmitControllerVibration ovr_SubmitControllerVibration =
+ nullptr;
+static pfn_ovr_GetControllerVibrationState ovr_GetControllerVibrationState =
+ nullptr;
+static pfn_ovr_TestBoundary ovr_TestBoundary = nullptr;
+static pfn_ovr_TestBoundaryPoint ovr_TestBoundaryPoint = nullptr;
+static pfn_ovr_SetBoundaryLookAndFeel ovr_SetBoundaryLookAndFeel = nullptr;
+static pfn_ovr_ResetBoundaryLookAndFeel ovr_ResetBoundaryLookAndFeel = nullptr;
+static pfn_ovr_GetBoundaryGeometry ovr_GetBoundaryGeometry = nullptr;
+static pfn_ovr_GetBoundaryDimensions ovr_GetBoundaryDimensions = nullptr;
+static pfn_ovr_GetBoundaryVisible ovr_GetBoundaryVisible = nullptr;
+static pfn_ovr_RequestBoundaryVisible ovr_RequestBoundaryVisible = nullptr;
+static pfn_ovr_GetTextureSwapChainLength ovr_GetTextureSwapChainLength =
+ nullptr;
+static pfn_ovr_GetTextureSwapChainCurrentIndex
+ ovr_GetTextureSwapChainCurrentIndex = nullptr;
+static pfn_ovr_GetTextureSwapChainDesc ovr_GetTextureSwapChainDesc = nullptr;
+static pfn_ovr_CommitTextureSwapChain ovr_CommitTextureSwapChain = nullptr;
+static pfn_ovr_DestroyTextureSwapChain ovr_DestroyTextureSwapChain = nullptr;
+static pfn_ovr_DestroyMirrorTexture ovr_DestroyMirrorTexture = nullptr;
+static pfn_ovr_GetFovTextureSize ovr_GetFovTextureSize = nullptr;
+static pfn_ovr_GetRenderDesc2 ovr_GetRenderDesc2 = nullptr;
+static pfn_ovr_WaitToBeginFrame ovr_WaitToBeginFrame = nullptr;
+static pfn_ovr_BeginFrame ovr_BeginFrame = nullptr;
+static pfn_ovr_EndFrame ovr_EndFrame = nullptr;
+static pfn_ovr_SubmitFrame ovr_SubmitFrame = nullptr;
+static pfn_ovr_GetPerfStats ovr_GetPerfStats = nullptr;
+static pfn_ovr_ResetPerfStats ovr_ResetPerfStats = nullptr;
+static pfn_ovr_GetPredictedDisplayTime ovr_GetPredictedDisplayTime = nullptr;
+static pfn_ovr_GetTimeInSeconds ovr_GetTimeInSeconds = nullptr;
+static pfn_ovr_GetBool ovr_GetBool = nullptr;
+static pfn_ovr_SetBool ovr_SetBool = nullptr;
+static pfn_ovr_GetInt ovr_GetInt = nullptr;
+static pfn_ovr_SetInt ovr_SetInt = nullptr;
+static pfn_ovr_GetFloat ovr_GetFloat = nullptr;
+static pfn_ovr_SetFloat ovr_SetFloat = nullptr;
+static pfn_ovr_GetFloatArray ovr_GetFloatArray = nullptr;
+static pfn_ovr_SetFloatArray ovr_SetFloatArray = nullptr;
+static pfn_ovr_GetString ovr_GetString = nullptr;
+static pfn_ovr_SetString ovr_SetString = nullptr;
+static pfn_ovr_GetExternalCameras ovr_GetExternalCameras = nullptr;
+static pfn_ovr_SetExternalCameraProperties ovr_SetExternalCameraProperties =
+ nullptr;
+
+#ifdef XP_WIN
+static pfn_ovr_CreateTextureSwapChainDX ovr_CreateTextureSwapChainDX = nullptr;
+static pfn_ovr_GetTextureSwapChainBufferDX ovr_GetTextureSwapChainBufferDX =
+ nullptr;
+static pfn_ovr_CreateMirrorTextureDX ovr_CreateMirrorTextureDX = nullptr;
+static pfn_ovr_GetMirrorTextureBufferDX ovr_GetMirrorTextureBufferDX = nullptr;
+#endif
+
+static pfn_ovr_CreateTextureSwapChainGL ovr_CreateTextureSwapChainGL = nullptr;
+static pfn_ovr_GetTextureSwapChainBufferGL ovr_GetTextureSwapChainBufferGL =
+ nullptr;
+static pfn_ovr_CreateMirrorTextureGL ovr_CreateMirrorTextureGL = nullptr;
+static pfn_ovr_GetMirrorTextureBufferGL ovr_GetMirrorTextureBufferGL = nullptr;
+
+#ifdef HAVE_64BIT_BUILD
+# define BUILD_BITS 64
+#else
+# define BUILD_BITS 32
+#endif
+
+#define OVR_PRODUCT_VERSION 1
+#define OVR_MAJOR_VERSION 1
+#define OVR_MINOR_VERSION 19
+
+static const uint32_t kNumOculusButtons = 7;
+static const uint32_t kNumOculusHaptcs = 1;
+static const uint32_t kNumOculusAxes = 4;
+ovrControllerType OculusControllerTypes[2] = {ovrControllerType_LTouch,
+ ovrControllerType_RTouch};
+const char* OculusControllerNames[2] = {"Oculus Touch (Left)",
+ "Oculus Touch (Right)"};
+dom::GamepadHand OculusControllerHand[2] = {dom::GamepadHand::Left,
+ dom::GamepadHand::Right};
+
+ovrButton OculusControllerButtons[2][kNumOculusButtons] = {
+ {(ovrButton)0, (ovrButton)0, (ovrButton)0, ovrButton_LThumb, ovrButton_X,
+ ovrButton_Y, (ovrButton)0},
+ {(ovrButton)0, (ovrButton)0, (ovrButton)0, ovrButton_RThumb, ovrButton_A,
+ ovrButton_B, (ovrButton)0},
+};
+
+ovrTouch OculusControllerTouches[2][kNumOculusButtons] = {
+ {ovrTouch_LIndexTrigger, (ovrTouch)0, (ovrTouch)0, ovrTouch_LThumb,
+ ovrTouch_X, ovrTouch_Y, ovrTouch_LThumbRest},
+ {ovrTouch_RIndexTrigger, (ovrTouch)0, (ovrTouch)0, ovrTouch_RThumb,
+ ovrTouch_A, ovrTouch_B, ovrTouch_RThumbRest},
+};
+
+void UpdateButton(const ovrInputState& aInputState, uint32_t aHandIdx,
+ uint32_t aButtonIdx, VRControllerState& aControllerState) {
+ if (aInputState.Buttons & OculusControllerButtons[aHandIdx][aButtonIdx]) {
+ aControllerState.buttonPressed |= ((uint64_t)1 << aButtonIdx);
+ aControllerState.triggerValue[aButtonIdx] = 1.0f;
+ } else {
+ aControllerState.triggerValue[aButtonIdx] = 0.0f;
+ }
+ if (aInputState.Touches & OculusControllerTouches[aHandIdx][aButtonIdx]) {
+ aControllerState.buttonTouched |= ((uint64_t)1 << aButtonIdx);
+ }
+}
+
+VRFieldOfView FromFovPort(const ovrFovPort& aFOV) {
+ VRFieldOfView fovInfo;
+ fovInfo.leftDegrees = atan(aFOV.LeftTan) * 180.0 / M_PI;
+ fovInfo.rightDegrees = atan(aFOV.RightTan) * 180.0 / M_PI;
+ fovInfo.upDegrees = atan(aFOV.UpTan) * 180.0 / M_PI;
+ fovInfo.downDegrees = atan(aFOV.DownTan) * 180.0 / M_PI;
+ return fovInfo;
+}
+
+} // anonymous namespace
+
+namespace mozilla {
+namespace gfx {
+
+OculusSession::OculusSession()
+ : VRSession(),
+ mOvrLib(nullptr),
+ mSession(nullptr),
+ mInitFlags((ovrInitFlags)0),
+ mTextureSet(nullptr),
+ mQuadVS(nullptr),
+ mQuadPS(nullptr),
+ mLinearSamplerState(nullptr),
+ mVSConstantBuffer(nullptr),
+ mPSConstantBuffer(nullptr),
+ mVertexBuffer(nullptr),
+ mInputLayout(nullptr),
+ mRemainingVibrateTime{},
+ mHapticPulseIntensity{},
+ mIsPresenting(false) {}
+
+OculusSession::~OculusSession() { Shutdown(); }
+
+bool OculusSession::Initialize(mozilla::gfx::VRSystemState& aSystemState,
+ bool aDetectRuntimesOnly) {
+ if (StaticPrefs::dom_vr_puppet_enabled()) {
+ // Ensure that tests using the VR Puppet do not find real hardware
+ return false;
+ }
+ if (!StaticPrefs::dom_vr_enabled() || !StaticPrefs::dom_vr_oculus_enabled()) {
+ return false;
+ }
+
+ if (aDetectRuntimesOnly) {
+ if (LoadOvrLib()) {
+ aSystemState.displayState.capabilityFlags |=
+ VRDisplayCapabilityFlags::Cap_ImmersiveVR;
+ }
+ return false;
+ }
+
+ if (!CreateD3DObjects()) {
+ return false;
+ }
+ if (!CreateShaders()) {
+ return false;
+ }
+ // Ideally, we should move LoadOvrLib() up to the first line to avoid
+ // unnecessary D3D objects creation. But it will cause a WPT fail in Win 7
+ // debug.
+ if (!LoadOvrLib()) {
+ return false;
+ }
+ // We start off with an invisible session, then re-initialize
+ // with visible session once WebVR content starts rendering.
+ if (!ChangeVisibility(false)) {
+ return false;
+ }
+ if (!InitState(aSystemState)) {
+ return false;
+ }
+
+ mPresentationSize = IntSize(aSystemState.displayState.eyeResolution.width * 2,
+ aSystemState.displayState.eyeResolution.height);
+ return true;
+}
+
+void OculusSession::UpdateVisibility() {
+ // Do not immediately re-initialize with an invisible session after
+ // the end of a VR presentation. Waiting for the configured duraction
+ // ensures that the user will not drop to Oculus Home during VR link
+ // traversal.
+ if (mIsPresenting) {
+ // We are currently rendering immersive content.
+ // Avoid interrupting the session
+ return;
+ }
+ if (mInitFlags & ovrInit_Invisible) {
+ // We are already invisible
+ return;
+ }
+ if (mLastPresentationEnd.IsNull()) {
+ // There has been no presentation yet
+ return;
+ }
+
+ TimeDuration duration = TimeStamp::Now() - mLastPresentationEnd;
+ TimeDuration timeout = TimeDuration::FromMilliseconds(
+ StaticPrefs::dom_vr_oculus_present_timeout());
+ if (timeout <= TimeDuration(0) || duration >= timeout) {
+ if (!ChangeVisibility(false)) {
+ gfxWarning() << "OculusSession::ChangeVisibility(false) failed";
+ }
+ }
+}
+
+void OculusSession::CoverTransitions() {
+ // While content is loading or during immersive-mode link
+ // traversal, we need to prevent the user from seeing the
+ // last rendered frame.
+ // We render black frames to cover up the transition.
+ MOZ_ASSERT(mSession);
+ if (mIsPresenting) {
+ // We are currently rendering immersive content.
+ // Avoid interrupting the session
+ return;
+ }
+
+ if (mInitFlags & ovrInit_Invisible) {
+ // We are invisible, nothing to cover up
+ return;
+ }
+
+ // Render a black frame
+ ovrLayerEyeFov layer;
+ memset(&layer, 0, sizeof(layer));
+ layer.Header.Type = ovrLayerType_Disabled;
+ ovrLayerHeader* layers = &layer.Header;
+ ovr_SubmitFrame(mSession, 0, nullptr, &layers, 1);
+}
+
+bool OculusSession::ChangeVisibility(bool bVisible) {
+ ovrInitFlags flags =
+ (ovrInitFlags)(ovrInit_RequestVersion | ovrInit_MixedRendering);
+ if (StaticPrefs::dom_vr_oculus_invisible_enabled() && !bVisible) {
+ flags = (ovrInitFlags)(flags | ovrInit_Invisible);
+ }
+ if (mInitFlags == flags) {
+ // The new state is the same, nothing to do
+ return true;
+ }
+
+ // Tear everything down
+ StopRendering();
+ StopSession();
+ StopLib();
+
+ // Start it back up
+ if (!StartLib(flags)) {
+ return false;
+ }
+ if (!StartSession()) {
+ return false;
+ }
+ return true;
+}
+
+void OculusSession::Shutdown() {
+ StopRendering();
+ StopSession();
+ StopLib();
+ UnloadOvrLib();
+ DestroyShaders();
+}
+
+void OculusSession::ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) {
+ if (!mSession) {
+ return;
+ }
+
+ ovrSessionStatus status;
+ if (OVR_SUCCESS(ovr_GetSessionStatus(mSession, &status))) {
+ aSystemState.displayState.isConnected = status.HmdPresent;
+ aSystemState.displayState.isMounted = status.HmdMounted;
+ mShouldQuit = status.ShouldQuit;
+
+ } else {
+ aSystemState.displayState.isConnected = false;
+ aSystemState.displayState.isMounted = false;
+ }
+ UpdateHaptics();
+ UpdateVisibility();
+ CoverTransitions();
+}
+
+void OculusSession::StartFrame(mozilla::gfx::VRSystemState& aSystemState) {
+ UpdateHeadsetPose(aSystemState);
+ UpdateEyeParameters(aSystemState);
+ UpdateControllers(aSystemState);
+ UpdateTelemetry(aSystemState);
+ aSystemState.sensorState.inputFrameID++;
+}
+
+bool OculusSession::StartPresentation() {
+ /**
+ * XXX - We should resolve fail the promise returned by
+ * VRDisplay.requestPresent() when the DX11 resources fail allocation
+ * in VRDisplayOculus::StartPresentation().
+ * Bailing out here prevents the crash but content should be aware
+ * that frames are not being presented.
+ * See Bug 1299309.
+ **/
+ if (!ChangeVisibility(true)) {
+ return false;
+ }
+ if (!StartRendering()) {
+ StopRendering();
+ return false;
+ }
+ mIsPresenting = true;
+ return true;
+}
+
+void OculusSession::StopPresentation() {
+ mLastPresentationEnd = TimeStamp::Now();
+ mIsPresenting = false;
+}
+
+bool OculusSession::SubmitFrame(
+ const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+ ID3D11Texture2D* aTexture) {
+ if (!IsPresentationReady()) {
+ return false;
+ }
+
+ D3D11_TEXTURE2D_DESC textureDesc = {0};
+ aTexture->GetDesc(&textureDesc);
+
+ int currentRenderTarget = 0;
+ ovrResult orv = ovr_GetTextureSwapChainCurrentIndex(mSession, mTextureSet,
+ &currentRenderTarget);
+ if (orv != ovrSuccess) {
+ NS_WARNING("ovr_GetTextureSwapChainCurrentIndex failed.");
+ return false;
+ }
+
+ ID3D11RenderTargetView* view = mRTView[currentRenderTarget];
+
+ float clear[] = {0.0f, 0.0f, 0.0f, 1.0f};
+ mContext->ClearRenderTargetView(view, clear);
+ mContext->OMSetRenderTargets(1, &view, nullptr);
+
+ Matrix viewMatrix = Matrix::Translation(-1.0, 1.0);
+ viewMatrix.PreScale(2.0f / float(textureDesc.Width),
+ 2.0f / float(textureDesc.Height));
+ viewMatrix.PreScale(1.0f, -1.0f);
+ Matrix4x4 projection = Matrix4x4::From2D(viewMatrix);
+ projection._33 = 0.0f;
+
+ Matrix transform2d;
+ gfx::Matrix4x4 transform = gfx::Matrix4x4::From2D(transform2d);
+
+ D3D11_VIEWPORT viewport;
+ viewport.MinDepth = 0.0f;
+ viewport.MaxDepth = 1.0f;
+ viewport.Width = textureDesc.Width;
+ viewport.Height = textureDesc.Height;
+ viewport.TopLeftX = 0;
+ viewport.TopLeftY = 0;
+
+ D3D11_RECT scissor;
+ scissor.left = 0;
+ scissor.right = textureDesc.Width;
+ scissor.top = 0;
+ scissor.bottom = textureDesc.Height;
+
+ memcpy(&mVSConstants.layerTransform, &transform._11,
+ sizeof(mVSConstants.layerTransform));
+ memcpy(&mVSConstants.projection, &projection._11,
+ sizeof(mVSConstants.projection));
+ mVSConstants.renderTargetOffset[0] = 0.0f;
+ mVSConstants.renderTargetOffset[1] = 0.0f;
+ mVSConstants.layerQuad =
+ Rect(0.0f, 0.0f, textureDesc.Width, textureDesc.Height);
+ mVSConstants.textureCoords = Rect(0.0f, 1.0f, 1.0f, -1.0f);
+
+ mPSConstants.layerOpacity[0] = 1.0f;
+
+ ID3D11Buffer* vbuffer = mVertexBuffer;
+ UINT vsize = sizeof(Vertex);
+ UINT voffset = 0;
+ mContext->IASetVertexBuffers(0, 1, &vbuffer, &vsize, &voffset);
+ mContext->IASetIndexBuffer(nullptr, DXGI_FORMAT_R16_UINT, 0);
+ mContext->IASetInputLayout(mInputLayout);
+ mContext->RSSetViewports(1, &viewport);
+ mContext->RSSetScissorRects(1, &scissor);
+ mContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+ mContext->VSSetShader(mQuadVS, nullptr, 0);
+ mContext->PSSetShader(mQuadPS, nullptr, 0);
+
+ RefPtr<ID3D11ShaderResourceView> srView;
+ HRESULT hr = mDevice->CreateShaderResourceView(aTexture, nullptr,
+ getter_AddRefs(srView));
+ if (FAILED(hr)) {
+ gfxWarning() << "Could not create shader resource view for Oculus: "
+ << hexa(hr);
+ return false;
+ }
+ ID3D11ShaderResourceView* viewPtr = srView.get();
+ mContext->PSSetShaderResources(0 /* 0 == TexSlot::RGB */, 1, &viewPtr);
+ // XXX Use Constant from TexSlot in CompositorD3D11.cpp?
+
+ ID3D11SamplerState* sampler = mLinearSamplerState;
+ mContext->PSSetSamplers(0, 1, &sampler);
+
+ if (!UpdateConstantBuffers()) {
+ NS_WARNING("Failed to update constant buffers for Oculus");
+ return false;
+ }
+
+ mContext->Draw(4, 0);
+
+ orv = ovr_CommitTextureSwapChain(mSession, mTextureSet);
+ if (orv != ovrSuccess) {
+ NS_WARNING("ovr_CommitTextureSwapChain failed.");
+ return false;
+ }
+
+ ovrLayerEyeFov layer;
+ memset(&layer, 0, sizeof(layer));
+ layer.Header.Type = ovrLayerType_EyeFov;
+ layer.Header.Flags = 0;
+ layer.ColorTexture[0] = mTextureSet;
+ layer.ColorTexture[1] = nullptr;
+ layer.Fov[0] = mFOVPort[0];
+ layer.Fov[1] = mFOVPort[1];
+ layer.Viewport[0].Pos.x = textureDesc.Width * aLayer.leftEyeRect.x;
+ layer.Viewport[0].Pos.y = textureDesc.Height * aLayer.leftEyeRect.y;
+ layer.Viewport[0].Size.w = textureDesc.Width * aLayer.leftEyeRect.width;
+ layer.Viewport[0].Size.h = textureDesc.Height * aLayer.leftEyeRect.height;
+ layer.Viewport[1].Pos.x = textureDesc.Width * aLayer.rightEyeRect.x;
+ layer.Viewport[1].Pos.y = textureDesc.Height * aLayer.rightEyeRect.y;
+ layer.Viewport[1].Size.w = textureDesc.Width * aLayer.rightEyeRect.width;
+ layer.Viewport[1].Size.h = textureDesc.Height * aLayer.rightEyeRect.height;
+
+ for (uint32_t i = 0; i < 2; ++i) {
+ layer.RenderPose[i].Orientation.x = mFrameStartPose[i].Orientation.x;
+ layer.RenderPose[i].Orientation.y = mFrameStartPose[i].Orientation.y;
+ layer.RenderPose[i].Orientation.z = mFrameStartPose[i].Orientation.z;
+ layer.RenderPose[i].Orientation.w = mFrameStartPose[i].Orientation.w;
+ layer.RenderPose[i].Position.x = mFrameStartPose[i].Position.x;
+ layer.RenderPose[i].Position.y = mFrameStartPose[i].Position.y;
+ layer.RenderPose[i].Position.z = mFrameStartPose[i].Position.z;
+ }
+
+ ovrLayerHeader* layers = &layer.Header;
+ orv = ovr_SubmitFrame(mSession, 0, nullptr, &layers, 1);
+ // ovr_SubmitFrame will fail during the Oculus health and safety warning.
+ // and will start succeeding once the warning has been dismissed by the user.
+
+ if (!OVR_UNQUALIFIED_SUCCESS(orv)) {
+ /**
+ * We wish to throttle the framerate for any case that the rendered
+ * result is not visible. In some cases, such as during the Oculus
+ * "health and safety warning", orv will be > 0 (OVR_SUCCESS but not
+ * OVR_UNQUALIFIED_SUCCESS) and ovr_SubmitFrame will not block.
+ * In this case, returning true would have resulted in an unthrottled
+ * render loop hiting excessive frame rates and consuming resources.
+ */
+ return false;
+ }
+
+ return true;
+}
+
+bool OculusSession::LoadOvrLib() {
+ if (mOvrLib) {
+ // Already loaded, early exit
+ return true;
+ }
+#if defined(_WIN32)
+ nsTArray<nsString> libSearchPaths;
+ nsString libName;
+ nsString searchPath;
+
+ for (;;) {
+ UINT requiredLength = ::GetSystemDirectoryW(
+ char16ptr_t(searchPath.BeginWriting()), searchPath.Length());
+ if (!requiredLength) {
+ break;
+ }
+ if (requiredLength < searchPath.Length()) {
+ searchPath.Truncate(requiredLength);
+ libSearchPaths.AppendElement(searchPath);
+ break;
+ }
+ searchPath.SetLength(requiredLength);
+ }
+ libName.AppendPrintf("LibOVRRT%d_%d.dll", BUILD_BITS, OVR_PRODUCT_VERSION);
+
+ // search the path/module dir
+ libSearchPaths.InsertElementsAt(0, 1, u""_ns);
+
+ // If the env var is present, we override libName
+ if (_wgetenv(L"OVR_LIB_PATH")) {
+ searchPath = _wgetenv(L"OVR_LIB_PATH");
+ libSearchPaths.InsertElementsAt(0, 1, searchPath);
+ }
+
+ if (_wgetenv(L"OVR_LIB_NAME")) {
+ libName = _wgetenv(L"OVR_LIB_NAME");
+ }
+
+ if (libName.IsEmpty()) {
+ return false;
+ }
+
+ for (uint32_t i = 0; i < libSearchPaths.Length(); ++i) {
+ nsString& libPath = libSearchPaths[i];
+ nsString fullName;
+ if (libPath.Length() == 0) {
+ fullName.Assign(libName);
+ } else {
+ fullName.Assign(libPath + u"\\"_ns + libName);
+ }
+
+ mOvrLib = LoadLibraryWithFlags(fullName.get());
+ if (mOvrLib) {
+ break;
+ }
+ }
+#else
+# error "Unsupported platform!"
+#endif
+
+ if (!mOvrLib) {
+ return false;
+ }
+
+#define REQUIRE_FUNCTION(_x) \
+ do { \
+ *(void**)&_x = (void*)PR_FindSymbol(mOvrLib, #_x); \
+ if (!_x) { \
+ printf_stderr(#_x " symbol missing\n"); \
+ goto fail; \
+ } \
+ } while (0)
+
+ REQUIRE_FUNCTION(ovr_Initialize);
+ REQUIRE_FUNCTION(ovr_Shutdown);
+ REQUIRE_FUNCTION(ovr_GetLastErrorInfo);
+ REQUIRE_FUNCTION(ovr_GetVersionString);
+ REQUIRE_FUNCTION(ovr_TraceMessage);
+ REQUIRE_FUNCTION(ovr_IdentifyClient);
+ REQUIRE_FUNCTION(ovr_GetHmdDesc);
+ REQUIRE_FUNCTION(ovr_GetTrackerCount);
+ REQUIRE_FUNCTION(ovr_GetTrackerDesc);
+ REQUIRE_FUNCTION(ovr_Create);
+ REQUIRE_FUNCTION(ovr_Destroy);
+ REQUIRE_FUNCTION(ovr_GetSessionStatus);
+ REQUIRE_FUNCTION(ovr_IsExtensionSupported);
+ REQUIRE_FUNCTION(ovr_EnableExtension);
+ REQUIRE_FUNCTION(ovr_SetTrackingOriginType);
+ REQUIRE_FUNCTION(ovr_GetTrackingOriginType);
+ REQUIRE_FUNCTION(ovr_RecenterTrackingOrigin);
+ REQUIRE_FUNCTION(ovr_SpecifyTrackingOrigin);
+ REQUIRE_FUNCTION(ovr_ClearShouldRecenterFlag);
+ REQUIRE_FUNCTION(ovr_GetTrackingState);
+ REQUIRE_FUNCTION(ovr_GetDevicePoses);
+ REQUIRE_FUNCTION(ovr_GetTrackerPose);
+ REQUIRE_FUNCTION(ovr_GetInputState);
+ REQUIRE_FUNCTION(ovr_GetConnectedControllerTypes);
+ REQUIRE_FUNCTION(ovr_GetTouchHapticsDesc);
+ REQUIRE_FUNCTION(ovr_SetControllerVibration);
+ REQUIRE_FUNCTION(ovr_SubmitControllerVibration);
+ REQUIRE_FUNCTION(ovr_GetControllerVibrationState);
+ REQUIRE_FUNCTION(ovr_TestBoundary);
+ REQUIRE_FUNCTION(ovr_TestBoundaryPoint);
+ REQUIRE_FUNCTION(ovr_SetBoundaryLookAndFeel);
+ REQUIRE_FUNCTION(ovr_ResetBoundaryLookAndFeel);
+ REQUIRE_FUNCTION(ovr_GetBoundaryGeometry);
+ REQUIRE_FUNCTION(ovr_GetBoundaryDimensions);
+ REQUIRE_FUNCTION(ovr_GetBoundaryVisible);
+ REQUIRE_FUNCTION(ovr_RequestBoundaryVisible);
+ REQUIRE_FUNCTION(ovr_GetTextureSwapChainLength);
+ REQUIRE_FUNCTION(ovr_GetTextureSwapChainCurrentIndex);
+ REQUIRE_FUNCTION(ovr_GetTextureSwapChainDesc);
+ REQUIRE_FUNCTION(ovr_CommitTextureSwapChain);
+ REQUIRE_FUNCTION(ovr_DestroyTextureSwapChain);
+ REQUIRE_FUNCTION(ovr_DestroyMirrorTexture);
+ REQUIRE_FUNCTION(ovr_GetFovTextureSize);
+ REQUIRE_FUNCTION(ovr_GetRenderDesc2);
+ REQUIRE_FUNCTION(ovr_WaitToBeginFrame);
+ REQUIRE_FUNCTION(ovr_BeginFrame);
+ REQUIRE_FUNCTION(ovr_EndFrame);
+ REQUIRE_FUNCTION(ovr_SubmitFrame);
+ REQUIRE_FUNCTION(ovr_GetPerfStats);
+ REQUIRE_FUNCTION(ovr_ResetPerfStats);
+ REQUIRE_FUNCTION(ovr_GetPredictedDisplayTime);
+ REQUIRE_FUNCTION(ovr_GetTimeInSeconds);
+ REQUIRE_FUNCTION(ovr_GetBool);
+ REQUIRE_FUNCTION(ovr_SetBool);
+ REQUIRE_FUNCTION(ovr_GetInt);
+ REQUIRE_FUNCTION(ovr_SetInt);
+ REQUIRE_FUNCTION(ovr_GetFloat);
+ REQUIRE_FUNCTION(ovr_SetFloat);
+ REQUIRE_FUNCTION(ovr_GetFloatArray);
+ REQUIRE_FUNCTION(ovr_SetFloatArray);
+ REQUIRE_FUNCTION(ovr_GetString);
+ REQUIRE_FUNCTION(ovr_SetString);
+ REQUIRE_FUNCTION(ovr_GetExternalCameras);
+ REQUIRE_FUNCTION(ovr_SetExternalCameraProperties);
+
+#ifdef XP_WIN
+
+ REQUIRE_FUNCTION(ovr_CreateTextureSwapChainDX);
+ REQUIRE_FUNCTION(ovr_GetTextureSwapChainBufferDX);
+ REQUIRE_FUNCTION(ovr_CreateMirrorTextureDX);
+ REQUIRE_FUNCTION(ovr_GetMirrorTextureBufferDX);
+
+#endif
+
+ REQUIRE_FUNCTION(ovr_CreateTextureSwapChainGL);
+ REQUIRE_FUNCTION(ovr_GetTextureSwapChainBufferGL);
+ REQUIRE_FUNCTION(ovr_CreateMirrorTextureGL);
+ REQUIRE_FUNCTION(ovr_GetMirrorTextureBufferGL);
+
+#undef REQUIRE_FUNCTION
+
+ return true;
+
+fail:
+ ovr_Initialize = nullptr;
+ PR_UnloadLibrary(mOvrLib);
+ mOvrLib = nullptr;
+ return false;
+}
+
+void OculusSession::UnloadOvrLib() {
+ if (mOvrLib) {
+ PR_UnloadLibrary(mOvrLib);
+ mOvrLib = nullptr;
+ }
+}
+
+bool OculusSession::StartLib(ovrInitFlags aFlags) {
+ if (mInitFlags == 0) {
+ ovrInitParams params;
+ memset(&params, 0, sizeof(params));
+ params.Flags = aFlags;
+ params.RequestedMinorVersion = OVR_MINOR_VERSION;
+ params.LogCallback = nullptr;
+ params.ConnectionTimeoutMS = 0;
+
+ ovrResult orv = ovr_Initialize(&params);
+
+ if (orv == ovrSuccess) {
+ mInitFlags = aFlags;
+ } else {
+ return false;
+ }
+ }
+ MOZ_ASSERT(mInitFlags == aFlags);
+ return true;
+}
+
+void OculusSession::StopLib() {
+ if (mInitFlags) {
+ ovr_Shutdown();
+ mInitFlags = (ovrInitFlags)0;
+ }
+}
+
+bool OculusSession::StartSession() {
+ // ovr_Create can be slow when no HMD is present and we wish
+ // to keep the same oculus session when possible, so we detect
+ // presence of an HMD with ovr_GetHmdDesc before calling ovr_Create
+ ovrHmdDesc desc = ovr_GetHmdDesc(NULL);
+ if (desc.Type == ovrHmd_None) {
+ // No HMD connected, destroy any existing session
+ if (mSession) {
+ ovr_Destroy(mSession);
+ mSession = nullptr;
+ }
+ return false;
+ }
+ if (mSession != nullptr) {
+ // HMD Detected and we already have a session, let's keep using it.
+ return true;
+ }
+
+ // HMD Detected and we don't have a session yet,
+ // try to create a new session
+ ovrSession session;
+ ovrGraphicsLuid luid;
+ ovrResult orv = ovr_Create(&session, &luid);
+ if (orv == ovrSuccess) {
+ orv = ovr_SetTrackingOriginType(session, ovrTrackingOrigin_FloorLevel);
+ if (orv != ovrSuccess) {
+ NS_WARNING("ovr_SetTrackingOriginType failed.\n");
+ }
+ mSession = session;
+ return true;
+ }
+
+ // Failed to create a session for the HMD
+ return false;
+}
+
+void OculusSession::StopSession() {
+ if (mSession) {
+ ovr_Destroy(mSession);
+ mSession = nullptr;
+ }
+}
+
+bool OculusSession::CreateD3DObjects() {
+ RefPtr<ID3D11Device> device = gfx::DeviceManagerDx::Get()->GetVRDevice();
+ if (!device) {
+ return false;
+ }
+ if (!CreateD3DContext(device)) {
+ return false;
+ }
+ return true;
+}
+
+bool OculusSession::CreateShaders() {
+ if (!mQuadVS) {
+ if (FAILED(mDevice->CreateVertexShader(
+ sLayerQuadVS.mData, sLayerQuadVS.mLength, nullptr, &mQuadVS))) {
+ NS_WARNING("Failed to create vertex shader for Oculus");
+ return false;
+ }
+ }
+
+ if (!mQuadPS) {
+ if (FAILED(mDevice->CreatePixelShader(sRGBShader.mData, sRGBShader.mLength,
+ nullptr, &mQuadPS))) {
+ NS_WARNING("Failed to create pixel shader for Oculus");
+ return false;
+ }
+ }
+
+ CD3D11_BUFFER_DESC cBufferDesc(sizeof(layers::VertexShaderConstants),
+ D3D11_BIND_CONSTANT_BUFFER,
+ D3D11_USAGE_DYNAMIC, D3D11_CPU_ACCESS_WRITE);
+
+ if (!mVSConstantBuffer) {
+ if (FAILED(mDevice->CreateBuffer(&cBufferDesc, nullptr,
+ getter_AddRefs(mVSConstantBuffer)))) {
+ NS_WARNING("Failed to vertex shader constant buffer for Oculus");
+ return false;
+ }
+ }
+
+ if (!mPSConstantBuffer) {
+ cBufferDesc.ByteWidth = sizeof(layers::PixelShaderConstants);
+ if (FAILED(mDevice->CreateBuffer(&cBufferDesc, nullptr,
+ getter_AddRefs(mPSConstantBuffer)))) {
+ NS_WARNING("Failed to pixel shader constant buffer for Oculus");
+ return false;
+ }
+ }
+
+ if (!mLinearSamplerState) {
+ CD3D11_SAMPLER_DESC samplerDesc(D3D11_DEFAULT);
+ if (FAILED(mDevice->CreateSamplerState(
+ &samplerDesc, getter_AddRefs(mLinearSamplerState)))) {
+ NS_WARNING("Failed to create sampler state for Oculus");
+ return false;
+ }
+ }
+
+ if (!mInputLayout) {
+ D3D11_INPUT_ELEMENT_DESC layout[] = {
+ {"POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0,
+ D3D11_INPUT_PER_VERTEX_DATA, 0},
+ };
+
+ if (FAILED(mDevice->CreateInputLayout(
+ layout, sizeof(layout) / sizeof(D3D11_INPUT_ELEMENT_DESC),
+ sLayerQuadVS.mData, sLayerQuadVS.mLength,
+ getter_AddRefs(mInputLayout)))) {
+ NS_WARNING("Failed to create input layout for Oculus");
+ return false;
+ }
+ }
+
+ if (!mVertexBuffer) {
+ Vertex vertices[] = {
+ {{0.0, 0.0}}, {{1.0, 0.0}}, {{0.0, 1.0}}, {{1.0, 1.0}}};
+ CD3D11_BUFFER_DESC bufferDesc(sizeof(vertices), D3D11_BIND_VERTEX_BUFFER);
+ D3D11_SUBRESOURCE_DATA data;
+ data.pSysMem = (void*)vertices;
+
+ if (FAILED(mDevice->CreateBuffer(&bufferDesc, &data,
+ getter_AddRefs(mVertexBuffer)))) {
+ NS_WARNING("Failed to create vertex buffer for Oculus");
+ return false;
+ }
+ }
+
+ memset(&mVSConstants, 0, sizeof(mVSConstants));
+ memset(&mPSConstants, 0, sizeof(mPSConstants));
+ return true;
+}
+
+void OculusSession::DestroyShaders() {}
+
+bool OculusSession::UpdateConstantBuffers() {
+ HRESULT hr;
+ D3D11_MAPPED_SUBRESOURCE resource;
+ resource.pData = nullptr;
+
+ hr = mContext->Map(mVSConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0,
+ &resource);
+ if (FAILED(hr) || !resource.pData) {
+ return false;
+ }
+ *(VertexShaderConstants*)resource.pData = mVSConstants;
+ mContext->Unmap(mVSConstantBuffer, 0);
+ resource.pData = nullptr;
+
+ hr = mContext->Map(mPSConstantBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0,
+ &resource);
+ if (FAILED(hr) || !resource.pData) {
+ return false;
+ }
+ *(PixelShaderConstants*)resource.pData = mPSConstants;
+ mContext->Unmap(mPSConstantBuffer, 0);
+
+ ID3D11Buffer* buffer = mVSConstantBuffer;
+ mContext->VSSetConstantBuffers(0, 1, &buffer);
+ buffer = mPSConstantBuffer;
+ mContext->PSSetConstantBuffers(0, 1, &buffer);
+ return true;
+}
+
+bool OculusSession::StartRendering() {
+ if (!mTextureSet) {
+ /**
+ * The presentation format is determined by content, which describes the
+ * left and right eye rectangles in the VRLayer. The default, if no
+ * coordinates are passed is to place the left and right eye textures
+ * side-by-side within the buffer.
+ *
+ * XXX - An optimization would be to dynamically resize this buffer
+ * to accomodate sites that are choosing to render in a lower
+ * resolution or are using space outside of the left and right
+ * eye textures for other purposes. (Bug 1291443)
+ */
+
+ ovrTextureSwapChainDesc desc;
+ memset(&desc, 0, sizeof(desc));
+ desc.Type = ovrTexture_2D;
+ desc.ArraySize = 1;
+ desc.Format = OVR_FORMAT_B8G8R8A8_UNORM_SRGB;
+ desc.Width = mPresentationSize.width;
+ desc.Height = mPresentationSize.height;
+ desc.MipLevels = 1;
+ desc.SampleCount = 1;
+ desc.StaticImage = false;
+ desc.MiscFlags = ovrTextureMisc_DX_Typeless;
+ desc.BindFlags = ovrTextureBind_DX_RenderTarget;
+
+ ovrResult orv =
+ ovr_CreateTextureSwapChainDX(mSession, mDevice, &desc, &mTextureSet);
+ if (orv != ovrSuccess) {
+ NS_WARNING("ovr_CreateTextureSwapChainDX failed");
+ return false;
+ }
+
+ int textureCount = 0;
+ orv = ovr_GetTextureSwapChainLength(mSession, mTextureSet, &textureCount);
+ if (orv != ovrSuccess) {
+ NS_WARNING("ovr_GetTextureSwapChainLength failed");
+ return false;
+ }
+ mTexture.SetLength(textureCount);
+ mRTView.SetLength(textureCount);
+ mSRV.SetLength(textureCount);
+ for (int i = 0; i < textureCount; ++i) {
+ ID3D11Texture2D* texture = nullptr;
+ orv = ovr_GetTextureSwapChainBufferDX(mSession, mTextureSet, i,
+ IID_PPV_ARGS(&texture));
+ if (orv != ovrSuccess) {
+ NS_WARNING("Failed to create Oculus texture swap chain.");
+ return false;
+ }
+
+ RefPtr<ID3D11RenderTargetView> rtView;
+ CD3D11_RENDER_TARGET_VIEW_DESC rtvDesc(D3D11_RTV_DIMENSION_TEXTURE2D,
+ DXGI_FORMAT_B8G8R8A8_UNORM);
+ HRESULT hr = mDevice->CreateRenderTargetView(texture, &rtvDesc,
+ getter_AddRefs(rtView));
+ if (FAILED(hr)) {
+ NS_WARNING(
+ "Failed to create RenderTargetView for Oculus texture swap chain.");
+ texture->Release();
+ return false;
+ }
+
+ RefPtr<ID3D11ShaderResourceView> srv;
+ CD3D11_SHADER_RESOURCE_VIEW_DESC srvDesc(D3D11_SRV_DIMENSION_TEXTURE2D,
+ DXGI_FORMAT_B8G8R8A8_UNORM);
+ hr = mDevice->CreateShaderResourceView(texture, &srvDesc,
+ getter_AddRefs(srv));
+ if (FAILED(hr)) {
+ NS_WARNING(
+ "Failed to create ShaderResourceView for Oculus texture swap "
+ "chain.");
+ texture->Release();
+ return false;
+ }
+
+ mTexture[i] = texture;
+ mRTView[i] = rtView;
+ mSRV[i] = srv;
+ texture->Release();
+ }
+ }
+ return true;
+}
+
+bool OculusSession::IsPresentationReady() const {
+ return mTextureSet != nullptr;
+}
+
+void OculusSession::StopRendering() {
+ mSRV.Clear();
+ mRTView.Clear();
+ mTexture.Clear();
+
+ if (mTextureSet && mSession) {
+ ovr_DestroyTextureSwapChain(mSession, mTextureSet);
+ }
+ mTextureSet = nullptr;
+ mIsPresenting = false;
+}
+
+bool OculusSession::InitState(VRSystemState& aSystemState) {
+ VRDisplayState& state = aSystemState.displayState;
+ strncpy(state.displayName, "Oculus VR HMD", kVRDisplayNameMaxLen);
+ state.isConnected = true;
+ state.isMounted = false;
+
+ ovrHmdDesc desc = ovr_GetHmdDesc(mSession);
+
+ state.capabilityFlags = VRDisplayCapabilityFlags::Cap_None;
+ if (desc.AvailableTrackingCaps & ovrTrackingCap_Orientation) {
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_Orientation;
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_AngularAcceleration;
+ }
+ if (desc.AvailableTrackingCaps & ovrTrackingCap_Position) {
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_Position;
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_LinearAcceleration;
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_StageParameters;
+ }
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_External;
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_MountDetection;
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_Present;
+ state.capabilityFlags |= VRDisplayCapabilityFlags::Cap_ImmersiveVR;
+ state.blendMode = VRDisplayBlendMode::Opaque;
+ state.reportsDroppedFrames = true;
+
+ mFOVPort[VRDisplayState::Eye_Left] = desc.DefaultEyeFov[ovrEye_Left];
+ mFOVPort[VRDisplayState::Eye_Right] = desc.DefaultEyeFov[ovrEye_Right];
+
+ state.eyeFOV[VRDisplayState::Eye_Left] =
+ FromFovPort(mFOVPort[VRDisplayState::Eye_Left]);
+ state.eyeFOV[VRDisplayState::Eye_Right] =
+ FromFovPort(mFOVPort[VRDisplayState::Eye_Right]);
+
+ float pixelsPerDisplayPixel = 1.0;
+ ovrSizei texSize[2];
+
+ // get eye texture sizes
+ for (uint32_t eye = 0; eye < VRDisplayState::NumEyes; eye++) {
+ texSize[eye] = ovr_GetFovTextureSize(mSession, (ovrEyeType)eye,
+ mFOVPort[eye], pixelsPerDisplayPixel);
+ }
+
+ // take the max of both for eye resolution
+ state.eyeResolution.width = std::max(texSize[VRDisplayState::Eye_Left].w,
+ texSize[VRDisplayState::Eye_Right].w);
+ state.eyeResolution.height = std::max(texSize[VRDisplayState::Eye_Left].h,
+ texSize[VRDisplayState::Eye_Right].h);
+ state.nativeFramebufferScaleFactor = 1.0f;
+
+ // default to an identity quaternion
+ aSystemState.sensorState.pose.orientation[3] = 1.0f;
+
+ UpdateStageParameters(state);
+ UpdateEyeParameters(aSystemState);
+
+ VRHMDSensorState& sensorState = aSystemState.sensorState;
+ sensorState.flags =
+ (VRDisplayCapabilityFlags)((int)
+ VRDisplayCapabilityFlags::Cap_Orientation |
+ (int)VRDisplayCapabilityFlags::Cap_Position);
+ sensorState.pose.orientation[3] = 1.0f; // Default to an identity quaternion
+
+ return true;
+}
+
+void OculusSession::UpdateStageParameters(VRDisplayState& aState) {
+ ovrVector3f playArea;
+ ovrResult res =
+ ovr_GetBoundaryDimensions(mSession, ovrBoundary_PlayArea, &playArea);
+ if (res == ovrSuccess) {
+ aState.stageSize.width = playArea.x;
+ aState.stageSize.height = playArea.z;
+ } else {
+ // If we fail, fall back to reasonable defaults.
+ // 1m x 1m space
+ aState.stageSize.width = 1.0f;
+ aState.stageSize.height = 1.0f;
+ }
+
+ float eyeHeight =
+ ovr_GetFloat(mSession, OVR_KEY_EYE_HEIGHT, OVR_DEFAULT_EYE_HEIGHT);
+
+ aState.sittingToStandingTransform[0] = 1.0f;
+ aState.sittingToStandingTransform[1] = 0.0f;
+ aState.sittingToStandingTransform[2] = 0.0f;
+ aState.sittingToStandingTransform[3] = 0.0f;
+
+ aState.sittingToStandingTransform[4] = 0.0f;
+ aState.sittingToStandingTransform[5] = 1.0f;
+ aState.sittingToStandingTransform[6] = 0.0f;
+ aState.sittingToStandingTransform[7] = 0.0f;
+
+ aState.sittingToStandingTransform[8] = 0.0f;
+ aState.sittingToStandingTransform[9] = 0.0f;
+ aState.sittingToStandingTransform[10] = 1.0f;
+ aState.sittingToStandingTransform[11] = 0.0f;
+
+ aState.sittingToStandingTransform[12] = 0.0f;
+ aState.sittingToStandingTransform[13] = eyeHeight;
+ aState.sittingToStandingTransform[14] = 0.0f;
+ aState.sittingToStandingTransform[15] = 1.0f;
+}
+
+void OculusSession::UpdateEyeParameters(VRSystemState& aState) {
+ if (!mSession) {
+ return;
+ }
+ // This must be called every frame in order to
+ // account for continuous adjustments to ipd.
+ gfx::Matrix4x4 headToEyeTransforms[2];
+ for (uint32_t eye = 0; eye < VRDisplayState::NumEyes; eye++) {
+ // As of Oculus 1.17 SDK, we must use the ovr_GetRenderDesc2 function to
+ // return the updated version of ovrEyeRenderDesc. This is normally done by
+ // the Oculus static lib shim, but we need to do this explicitly as we are
+ // loading the Oculus runtime dll directly.
+ ovrEyeRenderDesc renderDesc =
+ ovr_GetRenderDesc2(mSession, (ovrEyeType)eye, mFOVPort[eye]);
+ aState.displayState.eyeTranslation[eye].x =
+ renderDesc.HmdToEyePose.Position.x;
+ aState.displayState.eyeTranslation[eye].y =
+ renderDesc.HmdToEyePose.Position.y;
+ aState.displayState.eyeTranslation[eye].z =
+ renderDesc.HmdToEyePose.Position.z;
+
+ Matrix4x4 pose;
+ pose.SetRotationFromQuaternion(
+ gfx::Quaternion(-renderDesc.HmdToEyePose.Orientation.x,
+ -renderDesc.HmdToEyePose.Orientation.y,
+ -renderDesc.HmdToEyePose.Orientation.z,
+ renderDesc.HmdToEyePose.Orientation.w));
+ pose.PreTranslate(renderDesc.HmdToEyePose.Position.x,
+ renderDesc.HmdToEyePose.Position.y,
+ renderDesc.HmdToEyePose.Position.z);
+ pose.Invert();
+ headToEyeTransforms[eye] = pose;
+ }
+ aState.sensorState.CalcViewMatrices(headToEyeTransforms);
+
+ Matrix4x4 matView[2];
+ memcpy(matView[0].components, aState.sensorState.leftViewMatrix,
+ sizeof(float) * 16);
+ memcpy(matView[1].components, aState.sensorState.rightViewMatrix,
+ sizeof(float) * 16);
+
+ for (uint32_t eye = 0; eye < VRDisplayState::NumEyes; eye++) {
+ Point3D eyeTranslation;
+ Quaternion eyeRotation;
+ Point3D eyeScale;
+ if (!matView[eye].Decompose(eyeTranslation, eyeRotation, eyeScale)) {
+ NS_WARNING("Failed to decompose eye pose matrix for Oculus");
+ }
+
+ eyeRotation.Invert();
+ mFrameStartPose[eye].Orientation.x = eyeRotation.x;
+ mFrameStartPose[eye].Orientation.y = eyeRotation.y;
+ mFrameStartPose[eye].Orientation.z = eyeRotation.z;
+ mFrameStartPose[eye].Orientation.w = eyeRotation.w;
+ mFrameStartPose[eye].Position.x = eyeTranslation.x;
+ mFrameStartPose[eye].Position.y = eyeTranslation.y;
+ mFrameStartPose[eye].Position.z = eyeTranslation.z;
+ }
+}
+
+void OculusSession::UpdateHeadsetPose(VRSystemState& aState) {
+ if (!mSession) {
+ return;
+ }
+ double predictedFrameTime = 0.0f;
+ if (StaticPrefs::dom_vr_poseprediction_enabled()) {
+ // XXX We might need to call ovr_GetPredictedDisplayTime even if we don't
+ // use the result. If we don't call it, the Oculus driver will spew out many
+ // warnings...
+ predictedFrameTime = ovr_GetPredictedDisplayTime(mSession, 0);
+ }
+ ovrTrackingState trackingState =
+ ovr_GetTrackingState(mSession, predictedFrameTime, true);
+ ovrPoseStatef& pose(trackingState.HeadPose);
+
+ aState.sensorState.timestamp = pose.TimeInSeconds;
+
+ if (trackingState.StatusFlags & ovrStatus_OrientationTracked) {
+ aState.sensorState.flags |= VRDisplayCapabilityFlags::Cap_Orientation;
+
+ aState.sensorState.pose.orientation[0] = pose.ThePose.Orientation.x;
+ aState.sensorState.pose.orientation[1] = pose.ThePose.Orientation.y;
+ aState.sensorState.pose.orientation[2] = pose.ThePose.Orientation.z;
+ aState.sensorState.pose.orientation[3] = pose.ThePose.Orientation.w;
+
+ aState.sensorState.pose.angularVelocity[0] = pose.AngularVelocity.x;
+ aState.sensorState.pose.angularVelocity[1] = pose.AngularVelocity.y;
+ aState.sensorState.pose.angularVelocity[2] = pose.AngularVelocity.z;
+
+ aState.sensorState.flags |=
+ VRDisplayCapabilityFlags::Cap_AngularAcceleration;
+
+ aState.sensorState.pose.angularAcceleration[0] = pose.AngularAcceleration.x;
+ aState.sensorState.pose.angularAcceleration[1] = pose.AngularAcceleration.y;
+ aState.sensorState.pose.angularAcceleration[2] = pose.AngularAcceleration.z;
+ } else {
+ // default to an identity quaternion
+ aState.sensorState.pose.orientation[3] = 1.0f;
+ }
+
+ if (trackingState.StatusFlags & ovrStatus_PositionTracked) {
+ float eyeHeight =
+ ovr_GetFloat(mSession, OVR_KEY_EYE_HEIGHT, OVR_DEFAULT_EYE_HEIGHT);
+ aState.sensorState.flags |= VRDisplayCapabilityFlags::Cap_Position;
+
+ aState.sensorState.pose.position[0] = pose.ThePose.Position.x;
+ aState.sensorState.pose.position[1] = pose.ThePose.Position.y - eyeHeight;
+ aState.sensorState.pose.position[2] = pose.ThePose.Position.z;
+
+ aState.sensorState.pose.linearVelocity[0] = pose.LinearVelocity.x;
+ aState.sensorState.pose.linearVelocity[1] = pose.LinearVelocity.y;
+ aState.sensorState.pose.linearVelocity[2] = pose.LinearVelocity.z;
+
+ aState.sensorState.flags |=
+ VRDisplayCapabilityFlags::Cap_LinearAcceleration;
+
+ aState.sensorState.pose.linearAcceleration[0] = pose.LinearAcceleration.x;
+ aState.sensorState.pose.linearAcceleration[1] = pose.LinearAcceleration.y;
+ aState.sensorState.pose.linearAcceleration[2] = pose.LinearAcceleration.z;
+ }
+ aState.sensorState.flags |= VRDisplayCapabilityFlags::Cap_External;
+ aState.sensorState.flags |= VRDisplayCapabilityFlags::Cap_MountDetection;
+ aState.sensorState.flags |= VRDisplayCapabilityFlags::Cap_Present;
+}
+
+void OculusSession::UpdateControllers(VRSystemState& aState) {
+ if (!mSession) {
+ return;
+ }
+
+ ovrInputState inputState;
+ bool hasInputState = ovr_GetInputState(mSession, ovrControllerType_Touch,
+ &inputState) == ovrSuccess;
+
+ if (!hasInputState) {
+ return;
+ }
+
+ EnumerateControllers(aState, inputState);
+ UpdateControllerInputs(aState, inputState);
+ UpdateControllerPose(aState, inputState);
+}
+
+void OculusSession::UpdateControllerPose(VRSystemState& aState,
+ const ovrInputState& aInputState) {
+ ovrTrackingState trackingState = ovr_GetTrackingState(mSession, 0.0, false);
+ for (uint32_t handIdx = 0; handIdx < 2; handIdx++) {
+ // Left Touch Controller will always be at index 0 and
+ // and Right Touch Controller will always be at index 1
+ VRControllerState& controllerState = aState.controllerState[handIdx];
+ if (aInputState.ControllerType & OculusControllerTypes[handIdx]) {
+ ovrPoseStatef& pose = trackingState.HandPoses[handIdx];
+ bool bNewController = !(controllerState.flags &
+ dom::GamepadCapabilityFlags::Cap_Orientation);
+ if (bNewController) {
+ controllerState.flags |= dom::GamepadCapabilityFlags::Cap_Orientation;
+ controllerState.flags |= dom::GamepadCapabilityFlags::Cap_Position;
+ controllerState.flags |=
+ dom::GamepadCapabilityFlags::Cap_AngularAcceleration;
+ controllerState.flags |=
+ dom::GamepadCapabilityFlags::Cap_LinearAcceleration;
+ controllerState.flags |=
+ dom::GamepadCapabilityFlags::Cap_GripSpacePosition;
+ }
+
+ if (bNewController || trackingState.HandStatusFlags[handIdx] &
+ ovrStatus_OrientationTracked) {
+ controllerState.pose.orientation[0] = pose.ThePose.Orientation.x;
+ controllerState.pose.orientation[1] = pose.ThePose.Orientation.y;
+ controllerState.pose.orientation[2] = pose.ThePose.Orientation.z;
+ controllerState.pose.orientation[3] = pose.ThePose.Orientation.w;
+ controllerState.pose.angularVelocity[0] = pose.AngularVelocity.x;
+ controllerState.pose.angularVelocity[1] = pose.AngularVelocity.y;
+ controllerState.pose.angularVelocity[2] = pose.AngularVelocity.z;
+ controllerState.pose.angularAcceleration[0] =
+ pose.AngularAcceleration.x;
+ controllerState.pose.angularAcceleration[1] =
+ pose.AngularAcceleration.y;
+ controllerState.pose.angularAcceleration[2] =
+ pose.AngularAcceleration.z;
+ controllerState.isOrientationValid = true;
+ } else {
+ controllerState.isOrientationValid = false;
+ }
+ if (bNewController ||
+ trackingState.HandStatusFlags[handIdx] & ovrStatus_PositionTracked) {
+ controllerState.pose.position[0] = pose.ThePose.Position.x;
+ controllerState.pose.position[1] = pose.ThePose.Position.y;
+ controllerState.pose.position[2] = pose.ThePose.Position.z;
+ controllerState.pose.linearVelocity[0] = pose.LinearVelocity.x;
+ controllerState.pose.linearVelocity[1] = pose.LinearVelocity.y;
+ controllerState.pose.linearVelocity[2] = pose.LinearVelocity.z;
+ controllerState.pose.linearAcceleration[0] = pose.LinearAcceleration.x;
+ controllerState.pose.linearAcceleration[1] = pose.LinearAcceleration.y;
+ controllerState.pose.linearAcceleration[2] = pose.LinearAcceleration.z;
+
+ float eyeHeight =
+ ovr_GetFloat(mSession, OVR_KEY_EYE_HEIGHT, OVR_DEFAULT_EYE_HEIGHT);
+ controllerState.pose.position[1] -= eyeHeight;
+ controllerState.isPositionValid = true;
+ } else {
+ controllerState.isPositionValid = false;
+ }
+ controllerState.targetRayPose = controllerState.pose;
+ }
+ }
+}
+
+void OculusSession::EnumerateControllers(VRSystemState& aState,
+ const ovrInputState& aInputState) {
+ for (uint32_t handIdx = 0; handIdx < 2; handIdx++) {
+ // Left Touch Controller will always be at index 0 and
+ // and Right Touch Controller will always be at index 1
+ VRControllerState& controllerState = aState.controllerState[handIdx];
+ if (aInputState.ControllerType & OculusControllerTypes[handIdx]) {
+ // Touch Controller detected
+ if (controllerState.controllerName[0] == '\0') {
+ // Controller has been just enumerated
+ strncpy(controllerState.controllerName, OculusControllerNames[handIdx],
+ kVRControllerNameMaxLen);
+ controllerState.hand = OculusControllerHand[handIdx];
+ controllerState.targetRayMode = gfx::TargetRayMode::TrackedPointer;
+ controllerState.numButtons = kNumOculusButtons;
+ controllerState.numAxes = kNumOculusAxes;
+ controllerState.numHaptics = kNumOculusHaptcs;
+ controllerState.type = VRControllerType::OculusTouch;
+ }
+ } else {
+ // Touch Controller not detected
+ if (controllerState.controllerName[0] != '\0') {
+ // Clear any newly disconnected ontrollers
+ memset(&controllerState, 0, sizeof(VRControllerState));
+ }
+ }
+ }
+}
+
+void OculusSession::UpdateControllerInputs(VRSystemState& aState,
+ const ovrInputState& aInputState) {
+ const float triggerThreshold =
+ StaticPrefs::dom_vr_controller_trigger_threshold();
+
+ for (uint32_t handIdx = 0; handIdx < 2; handIdx++) {
+ // Left Touch Controller will always be at index 0 and
+ // and Right Touch Controller will always be at index 1
+ VRControllerState& controllerState = aState.controllerState[handIdx];
+ if (aInputState.ControllerType & OculusControllerTypes[handIdx]) {
+ // Update Button States
+ controllerState.buttonPressed = 0;
+ controllerState.buttonTouched = 0;
+ uint32_t buttonIdx = 0;
+
+ // Button 0: Trigger
+ VRSession::UpdateTrigger(controllerState, buttonIdx,
+ aInputState.IndexTrigger[handIdx],
+ triggerThreshold);
+ ++buttonIdx;
+ // Button 1: Grip
+ VRSession::UpdateTrigger(controllerState, buttonIdx,
+ aInputState.HandTrigger[handIdx],
+ triggerThreshold);
+ ++buttonIdx;
+ // Button 2: a placeholder button for trackpad.
+ UpdateButton(aInputState, handIdx, buttonIdx, controllerState);
+ ++buttonIdx;
+ // Button 3: Thumbstick
+ UpdateButton(aInputState, handIdx, buttonIdx, controllerState);
+ ++buttonIdx;
+ // Button 4: A
+ UpdateButton(aInputState, handIdx, buttonIdx, controllerState);
+ ++buttonIdx;
+ // Button 5: B
+ UpdateButton(aInputState, handIdx, buttonIdx, controllerState);
+ ++buttonIdx;
+ // Button 6: ThumbRest
+ UpdateButton(aInputState, handIdx, buttonIdx, controllerState);
+ ++buttonIdx;
+
+ MOZ_ASSERT(buttonIdx == kNumOculusButtons);
+
+ // Update Thumbstick axis
+ uint32_t axisIdx = 0;
+ // Axis 0, 1: placeholder axes for trackpad.
+ axisIdx += 2;
+
+ // Axis 2, 3: placeholder axes for thumbstick.
+ float axisValue = aInputState.Thumbstick[handIdx].x;
+ if (abs(axisValue) < 0.0000009f) {
+ axisValue = 0.0f; // Clear noise signal
+ }
+ controllerState.axisValue[axisIdx] = axisValue;
+ axisIdx++;
+
+ // Note that y axis is intentionally inverted!
+ axisValue = -aInputState.Thumbstick[handIdx].y;
+ if (abs(axisValue) < 0.0000009f) {
+ axisValue = 0.0f; // Clear noise signal
+ }
+ controllerState.axisValue[axisIdx] = axisValue;
+ axisIdx++;
+
+ MOZ_ASSERT(axisIdx == kNumOculusAxes);
+ }
+ SetControllerSelectionAndSqueezeFrameId(
+ controllerState, aState.displayState.lastSubmittedFrameId);
+ }
+}
+
+void OculusSession::UpdateTelemetry(VRSystemState& aSystemState) {
+ if (!mSession) {
+ return;
+ }
+ ovrPerfStats perfStats;
+ if (ovr_GetPerfStats(mSession, &perfStats) == ovrSuccess) {
+ if (perfStats.FrameStatsCount) {
+ aSystemState.displayState.droppedFrameCount =
+ perfStats.FrameStats[0].AppDroppedFrameCount;
+ }
+ }
+}
+
+void OculusSession::VibrateHaptic(uint32_t aControllerIdx,
+ uint32_t aHapticIndex, float aIntensity,
+ float aDuration) {
+ if (!mSession) {
+ return;
+ }
+
+ if (aDuration <= 0.0f) {
+ StopVibrateHaptic(aControllerIdx);
+ return;
+ }
+
+ // Vibration amplitude in the [0.0, 1.0] range
+ MOZ_ASSERT(aControllerIdx >= 0 && aControllerIdx <= 1);
+ mHapticPulseIntensity[aControllerIdx] = aIntensity > 1.0 ? 1.0 : aIntensity;
+ mRemainingVibrateTime[aControllerIdx] = aDuration;
+ ovrControllerType hand = OculusControllerTypes[aControllerIdx];
+
+ // The gamepad extensions API does not yet have independent control
+ // of frequency and amplitude. We are always sending 0.0f (160hz)
+ // to the frequency argument.
+ ovrResult result = ovr_SetControllerVibration(
+ mSession, hand, 0.0f, mHapticPulseIntensity[aControllerIdx]);
+ if (result != ovrSuccess) {
+ // This may happen if called when not presenting.
+ gfxWarning() << "ovr_SetControllerVibration failed.";
+ }
+}
+
+void OculusSession::StopVibrateHaptic(uint32_t aControllerIdx) {
+ if (!mSession) {
+ return;
+ }
+ MOZ_ASSERT(aControllerIdx >= 0 && aControllerIdx <= 1);
+ ovrControllerType hand = OculusControllerTypes[aControllerIdx];
+ mRemainingVibrateTime[aControllerIdx] = 0.0f;
+ mHapticPulseIntensity[aControllerIdx] = 0.0f;
+
+ ovrResult result = ovr_SetControllerVibration(mSession, hand, 0.0f, 0.0f);
+ if (result != ovrSuccess) {
+ // This may happen if called when not presenting.
+ gfxWarning() << "ovr_SetControllerVibration failed.";
+ }
+}
+
+void OculusSession::StopAllHaptics() {
+ // Left Oculus Touch
+ StopVibrateHaptic(0);
+ // Right Oculus Touch
+ StopVibrateHaptic(1);
+}
+
+void OculusSession::UpdateHaptics() {
+ if (!mSession) {
+ return;
+ }
+ // The Oculus API and hardware takes at least 33ms to respond
+ // to haptic state changes, so it is not beneficial to create
+ // a dedicated haptic feedback thread and update multiple
+ // times per frame.
+ // If we wish to support more accurate effects with sub-frame timing,
+ // we should use the buffered haptic feedback API's.
+
+ TimeStamp now = TimeStamp::Now();
+ if (mLastHapticUpdate.IsNull()) {
+ mLastHapticUpdate = now;
+ return;
+ }
+ float deltaTime = (float)(now - mLastHapticUpdate).ToSeconds();
+ mLastHapticUpdate = now;
+ for (int i = 0; i < 2; i++) {
+ if (mRemainingVibrateTime[i] <= 0.0f) {
+ continue;
+ }
+ mRemainingVibrateTime[i] -= deltaTime;
+ ovrControllerType hand = OculusControllerTypes[i];
+ if (mRemainingVibrateTime[i] > 0.0f) {
+ ovrResult result = ovr_SetControllerVibration(mSession, hand, 0.0f,
+ mHapticPulseIntensity[i]);
+ if (result != ovrSuccess) {
+ // This may happen if called when not presenting.
+ gfxWarning() << "ovr_SetControllerVibration failed.";
+ }
+ } else {
+ StopVibrateHaptic(i);
+ }
+ }
+}
+
+} // namespace gfx
+} // namespace mozilla
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-20 11:56:01 +0000