diff options
Diffstat (limited to 'gfx/vr/gfxVROpenVR.cpp')
| -rw-r--r-- | gfx/vr/gfxVROpenVR.cpp | 749 |
1 files changed, 749 insertions, 0 deletions
diff --git a/gfx/vr/gfxVROpenVR.cpp b/gfx/vr/gfxVROpenVR.cpp new file mode 100644 index 000000000..01149c983 --- /dev/null +++ b/gfx/vr/gfxVROpenVR.cpp @@ -0,0 +1,749 @@ +/* -*- Mode: C++; tab-width: 20; 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/. */ + +#include <math.h> + +#include "prlink.h" +#include "prmem.h" +#include "prenv.h" +#include "gfxPrefs.h" +#include "nsString.h" +#include "mozilla/Preferences.h" + +#include "mozilla/gfx/Quaternion.h" + +#ifdef XP_WIN +#include "CompositorD3D11.h" +#include "TextureD3D11.h" +#endif // XP_WIN + +#include "gfxVROpenVR.h" + +#include "nsServiceManagerUtils.h" +#include "nsIScreenManager.h" +#include "openvr/openvr.h" + +#ifdef MOZ_GAMEPAD +#include "mozilla/dom/GamepadEventTypes.h" +#include "mozilla/dom/GamepadBinding.h" +#endif + +#ifndef M_PI +# define M_PI 3.14159265358979323846 +#endif + +using namespace mozilla; +using namespace mozilla::gfx; +using namespace mozilla::gfx::impl; +using namespace mozilla::layers; +using namespace mozilla::dom; + +namespace { +extern "C" { +typedef uint32_t (VR_CALLTYPE * pfn_VR_InitInternal)(::vr::HmdError *peError, ::vr::EVRApplicationType eApplicationType); +typedef void (VR_CALLTYPE * pfn_VR_ShutdownInternal)(); +typedef bool (VR_CALLTYPE * pfn_VR_IsHmdPresent)(); +typedef bool (VR_CALLTYPE * pfn_VR_IsRuntimeInstalled)(); +typedef const char * (VR_CALLTYPE * pfn_VR_GetStringForHmdError)(::vr::HmdError error); +typedef void * (VR_CALLTYPE * pfn_VR_GetGenericInterface)(const char *pchInterfaceVersion, ::vr::HmdError *peError); +} // extern "C" +} // namespace + +static pfn_VR_InitInternal vr_InitInternal = nullptr; +static pfn_VR_ShutdownInternal vr_ShutdownInternal = nullptr; +static pfn_VR_IsHmdPresent vr_IsHmdPresent = nullptr; +static pfn_VR_IsRuntimeInstalled vr_IsRuntimeInstalled = nullptr; +static pfn_VR_GetStringForHmdError vr_GetStringForHmdError = nullptr; +static pfn_VR_GetGenericInterface vr_GetGenericInterface = nullptr; + +// EButton_System, EButton_DPad_xx, and EButton_A +// can not be triggered in Steam Vive in OpenVR SDK 1.0.3. +const uint64_t gOpenVRButtonMask[] = { + // vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_System), + vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_ApplicationMenu), + vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_Grip), + // vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_DPad_Left), + // vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_DPad_Up), + // vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_DPad_Right), + // vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_DPad_Down), + // vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_A), + vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_SteamVR_Touchpad), + vr::ButtonMaskFromId(vr::EVRButtonId::k_EButton_SteamVR_Trigger) +}; + +const uint32_t gNumOpenVRButtonMask = sizeof(gOpenVRButtonMask) / + sizeof(uint64_t); + +enum class VRControllerAxisType : uint16_t { + TrackpadXAxis, + TrackpadYAxis, + Trigger, + NumVRControllerAxisType +}; + +#define VRControllerAxis(aButtonId) (aButtonId - vr::EVRButtonId::k_EButton_Axis0) + +const uint32_t gOpenVRAxes[] = { + VRControllerAxis(vr::EVRButtonId::k_EButton_Axis0), + VRControllerAxis(vr::EVRButtonId::k_EButton_Axis0), + VRControllerAxis(vr::EVRButtonId::k_EButton_Axis1) +}; + +const uint32_t gNumOpenVRAxis = sizeof(gOpenVRAxes) / + sizeof(uint32_t); + + +bool +LoadOpenVRRuntime() +{ + static PRLibrary *openvrLib = nullptr; + + nsAdoptingCString openvrPath = Preferences::GetCString("gfx.vr.openvr-runtime"); + if (!openvrPath) + return false; + + openvrLib = PR_LoadLibrary(openvrPath.BeginReading()); + if (!openvrLib) + return false; + +#define REQUIRE_FUNCTION(_x) do { \ + *(void **)&vr_##_x = (void *) PR_FindSymbol(openvrLib, "VR_" #_x); \ + if (!vr_##_x) { printf_stderr("VR_" #_x " symbol missing\n"); return false; } \ + } while (0) + + REQUIRE_FUNCTION(InitInternal); + REQUIRE_FUNCTION(ShutdownInternal); + REQUIRE_FUNCTION(IsHmdPresent); + REQUIRE_FUNCTION(IsRuntimeInstalled); + REQUIRE_FUNCTION(GetStringForHmdError); + REQUIRE_FUNCTION(GetGenericInterface); + +#undef REQUIRE_FUNCTION + + return true; +} + +VRDisplayOpenVR::VRDisplayOpenVR(::vr::IVRSystem *aVRSystem, + ::vr::IVRChaperone *aVRChaperone, + ::vr::IVRCompositor *aVRCompositor) + : VRDisplayHost(VRDeviceType::OpenVR) + , mVRSystem(aVRSystem) + , mVRChaperone(aVRChaperone) + , mVRCompositor(aVRCompositor) + , mIsPresenting(false) +{ + MOZ_COUNT_CTOR_INHERITED(VRDisplayOpenVR, VRDisplayHost); + + mDisplayInfo.mDisplayName.AssignLiteral("OpenVR HMD"); + mDisplayInfo.mIsConnected = true; + mDisplayInfo.mCapabilityFlags = VRDisplayCapabilityFlags::Cap_None | + VRDisplayCapabilityFlags::Cap_Orientation | + VRDisplayCapabilityFlags::Cap_Position | + VRDisplayCapabilityFlags::Cap_External | + VRDisplayCapabilityFlags::Cap_Present | + VRDisplayCapabilityFlags::Cap_StageParameters; + + mVRCompositor->SetTrackingSpace(::vr::TrackingUniverseSeated); + + uint32_t w, h; + mVRSystem->GetRecommendedRenderTargetSize(&w, &h); + mDisplayInfo.mEyeResolution.width = w; + mDisplayInfo.mEyeResolution.height = h; + + // SteamVR gives the application a single FOV to use; it's not configurable as with Oculus + for (uint32_t eye = 0; eye < 2; ++eye) { + // get l/r/t/b clip plane coordinates + float l, r, t, b; + mVRSystem->GetProjectionRaw(static_cast<::vr::Hmd_Eye>(eye), &l, &r, &t, &b); + mDisplayInfo.mEyeFOV[eye].SetFromTanRadians(-t, r, b, -l); + + ::vr::HmdMatrix34_t eyeToHead = mVRSystem->GetEyeToHeadTransform(static_cast<::vr::Hmd_Eye>(eye)); + + mDisplayInfo.mEyeTranslation[eye].x = eyeToHead.m[0][3]; + mDisplayInfo.mEyeTranslation[eye].y = eyeToHead.m[1][3]; + mDisplayInfo.mEyeTranslation[eye].z = eyeToHead.m[2][3]; + } + + UpdateStageParameters(); +} + +VRDisplayOpenVR::~VRDisplayOpenVR() +{ + Destroy(); + MOZ_COUNT_DTOR_INHERITED(VRDisplayOpenVR, VRDisplayHost); +} + +void +VRDisplayOpenVR::Destroy() +{ + StopPresentation(); + vr_ShutdownInternal(); +} + +void +VRDisplayOpenVR::UpdateStageParameters() +{ + float sizeX = 0.0f; + float sizeZ = 0.0f; + if (mVRChaperone->GetPlayAreaSize(&sizeX, &sizeZ)) { + ::vr::HmdMatrix34_t t = mVRSystem->GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + mDisplayInfo.mStageSize.width = sizeX; + mDisplayInfo.mStageSize.height = sizeZ; + + mDisplayInfo.mSittingToStandingTransform._11 = t.m[0][0]; + mDisplayInfo.mSittingToStandingTransform._12 = t.m[1][0]; + mDisplayInfo.mSittingToStandingTransform._13 = t.m[2][0]; + mDisplayInfo.mSittingToStandingTransform._14 = 0.0f; + + mDisplayInfo.mSittingToStandingTransform._21 = t.m[0][1]; + mDisplayInfo.mSittingToStandingTransform._22 = t.m[1][1]; + mDisplayInfo.mSittingToStandingTransform._23 = t.m[2][1]; + mDisplayInfo.mSittingToStandingTransform._24 = 0.0f; + + mDisplayInfo.mSittingToStandingTransform._31 = t.m[0][2]; + mDisplayInfo.mSittingToStandingTransform._32 = t.m[1][2]; + mDisplayInfo.mSittingToStandingTransform._33 = t.m[2][2]; + mDisplayInfo.mSittingToStandingTransform._34 = 0.0f; + + mDisplayInfo.mSittingToStandingTransform._41 = t.m[0][3]; + mDisplayInfo.mSittingToStandingTransform._42 = t.m[1][3]; + mDisplayInfo.mSittingToStandingTransform._43 = t.m[2][3]; + mDisplayInfo.mSittingToStandingTransform._44 = 1.0f; + } else { + // If we fail, fall back to reasonable defaults. + // 1m x 1m space, 0.75m high in seated position + + mDisplayInfo.mStageSize.width = 1.0f; + mDisplayInfo.mStageSize.height = 1.0f; + + mDisplayInfo.mSittingToStandingTransform._11 = 1.0f; + mDisplayInfo.mSittingToStandingTransform._12 = 0.0f; + mDisplayInfo.mSittingToStandingTransform._13 = 0.0f; + mDisplayInfo.mSittingToStandingTransform._14 = 0.0f; + + mDisplayInfo.mSittingToStandingTransform._21 = 0.0f; + mDisplayInfo.mSittingToStandingTransform._22 = 1.0f; + mDisplayInfo.mSittingToStandingTransform._23 = 0.0f; + mDisplayInfo.mSittingToStandingTransform._24 = 0.0f; + + mDisplayInfo.mSittingToStandingTransform._31 = 0.0f; + mDisplayInfo.mSittingToStandingTransform._32 = 0.0f; + mDisplayInfo.mSittingToStandingTransform._33 = 1.0f; + mDisplayInfo.mSittingToStandingTransform._34 = 0.0f; + + mDisplayInfo.mSittingToStandingTransform._41 = 0.0f; + mDisplayInfo.mSittingToStandingTransform._42 = 0.75f; + mDisplayInfo.mSittingToStandingTransform._43 = 0.0f; + mDisplayInfo.mSittingToStandingTransform._44 = 1.0f; + } +} + +void +VRDisplayOpenVR::ZeroSensor() +{ + mVRSystem->ResetSeatedZeroPose(); + UpdateStageParameters(); +} + +VRHMDSensorState +VRDisplayOpenVR::GetSensorState() +{ + return GetSensorState(0.0f); +} + +VRHMDSensorState +VRDisplayOpenVR::GetImmediateSensorState() +{ + return GetSensorState(0.0f); +} + +VRHMDSensorState +VRDisplayOpenVR::GetSensorState(double timeOffset) +{ + { + ::vr::VREvent_t event; + while (mVRSystem->PollNextEvent(&event, sizeof(event))) { + // ignore + } + } + + ::vr::TrackedDevicePose_t poses[::vr::k_unMaxTrackedDeviceCount]; + // Note: We *must* call WaitGetPoses in order for any rendering to happen at all + mVRCompositor->WaitGetPoses(poses, ::vr::k_unMaxTrackedDeviceCount, nullptr, 0); + + VRHMDSensorState result; + result.Clear(); + result.timestamp = PR_Now(); + + if (poses[::vr::k_unTrackedDeviceIndex_Hmd].bDeviceIsConnected && + poses[::vr::k_unTrackedDeviceIndex_Hmd].bPoseIsValid && + poses[::vr::k_unTrackedDeviceIndex_Hmd].eTrackingResult == ::vr::TrackingResult_Running_OK) + { + const ::vr::TrackedDevicePose_t& pose = poses[::vr::k_unTrackedDeviceIndex_Hmd]; + + gfx::Matrix4x4 m; + // NOTE! mDeviceToAbsoluteTracking is a 3x4 matrix, not 4x4. But + // because of its arrangement, we can copy the 12 elements in and + // then transpose them to the right place. We do this so we can + // pull out a Quaternion. + memcpy(&m._11, &pose.mDeviceToAbsoluteTracking, sizeof(float) * 12); + m.Transpose(); + + gfx::Quaternion rot; + rot.SetFromRotationMatrix(m); + rot.Invert(); + + result.flags |= VRDisplayCapabilityFlags::Cap_Orientation; + result.orientation[0] = rot.x; + result.orientation[1] = rot.y; + result.orientation[2] = rot.z; + result.orientation[3] = rot.w; + result.angularVelocity[0] = pose.vAngularVelocity.v[0]; + result.angularVelocity[1] = pose.vAngularVelocity.v[1]; + result.angularVelocity[2] = pose.vAngularVelocity.v[2]; + + result.flags |= VRDisplayCapabilityFlags::Cap_Position; + result.position[0] = m._41; + result.position[1] = m._42; + result.position[2] = m._43; + result.linearVelocity[0] = pose.vVelocity.v[0]; + result.linearVelocity[1] = pose.vVelocity.v[1]; + result.linearVelocity[2] = pose.vVelocity.v[2]; + } + + return result; +} + +void +VRDisplayOpenVR::StartPresentation() +{ + if (mIsPresenting) { + return; + } + mIsPresenting = true; +} + +void +VRDisplayOpenVR::StopPresentation() +{ + if (!mIsPresenting) { + return; + } + + mVRCompositor->ClearLastSubmittedFrame(); + + mIsPresenting = false; +} + + +#if defined(XP_WIN) + +void +VRDisplayOpenVR::SubmitFrame(TextureSourceD3D11* aSource, + const IntSize& aSize, + const VRHMDSensorState& aSensorState, + const gfx::Rect& aLeftEyeRect, + const gfx::Rect& aRightEyeRect) +{ + if (!mIsPresenting) { + return; + } + + ::vr::Texture_t tex; + tex.handle = (void *)aSource->GetD3D11Texture(); + tex.eType = ::vr::EGraphicsAPIConvention::API_DirectX; + tex.eColorSpace = ::vr::EColorSpace::ColorSpace_Auto; + + ::vr::VRTextureBounds_t bounds; + bounds.uMin = aLeftEyeRect.x; + bounds.vMin = 1.0 - aLeftEyeRect.y; + bounds.uMax = aLeftEyeRect.x + aLeftEyeRect.width; + bounds.vMax = 1.0 - aLeftEyeRect.y - aLeftEyeRect.height; + + ::vr::EVRCompositorError err; + err = mVRCompositor->Submit(::vr::EVREye::Eye_Left, &tex, &bounds); + if (err != ::vr::EVRCompositorError::VRCompositorError_None) { + printf_stderr("OpenVR Compositor Submit() failed.\n"); + } + + bounds.uMin = aRightEyeRect.x; + bounds.vMin = 1.0 - aRightEyeRect.y; + bounds.uMax = aRightEyeRect.x + aRightEyeRect.width; + bounds.vMax = 1.0 - aRightEyeRect.y - aRightEyeRect.height; + + err = mVRCompositor->Submit(::vr::EVREye::Eye_Right, &tex, &bounds); + if (err != ::vr::EVRCompositorError::VRCompositorError_None) { + printf_stderr("OpenVR Compositor Submit() failed.\n"); + } + + mVRCompositor->PostPresentHandoff(); + + // Trigger the next VSync immediately + VRManager *vm = VRManager::Get(); + MOZ_ASSERT(vm); + vm->NotifyVRVsync(mDisplayInfo.mDisplayID); +} + +#endif + +void +VRDisplayOpenVR::NotifyVSync() +{ + // We update mIsConneced once per frame. + mDisplayInfo.mIsConnected = vr_IsHmdPresent(); +} + +VRDisplayManagerOpenVR::VRDisplayManagerOpenVR() + : mOpenVRInstalled(false) +{ +} + +/*static*/ already_AddRefed<VRDisplayManagerOpenVR> +VRDisplayManagerOpenVR::Create() +{ + MOZ_ASSERT(NS_IsMainThread()); + + if (!gfxPrefs::VREnabled() || !gfxPrefs::VROpenVREnabled()) { + return nullptr; + } + + if (!LoadOpenVRRuntime()) { + return nullptr; + } + + RefPtr<VRDisplayManagerOpenVR> manager = new VRDisplayManagerOpenVR(); + return manager.forget(); +} + +bool +VRDisplayManagerOpenVR::Init() +{ + if (mOpenVRInstalled) + return true; + + if (!vr_IsRuntimeInstalled()) + return false; + + mOpenVRInstalled = true; + return true; +} + +void +VRDisplayManagerOpenVR::Destroy() +{ + if (mOpenVRInstalled) { + if (mOpenVRHMD) { + mOpenVRHMD = nullptr; + } + mOpenVRInstalled = false; + } +} + +void +VRDisplayManagerOpenVR::GetHMDs(nsTArray<RefPtr<VRDisplayHost>>& aHMDResult) +{ + if (!mOpenVRInstalled) { + return; + } + + if (!vr_IsHmdPresent()) { + if (mOpenVRHMD) { + mOpenVRHMD = nullptr; + } + } else if (mOpenVRHMD == nullptr) { + ::vr::HmdError err; + + vr_InitInternal(&err, ::vr::EVRApplicationType::VRApplication_Scene); + if (err) { + return; + } + + ::vr::IVRSystem *system = (::vr::IVRSystem *)vr_GetGenericInterface(::vr::IVRSystem_Version, &err); + if (err || !system) { + vr_ShutdownInternal(); + return; + } + ::vr::IVRChaperone *chaperone = (::vr::IVRChaperone *)vr_GetGenericInterface(::vr::IVRChaperone_Version, &err); + if (err || !chaperone) { + vr_ShutdownInternal(); + return; + } + ::vr::IVRCompositor *compositor = (::vr::IVRCompositor*)vr_GetGenericInterface(::vr::IVRCompositor_Version, &err); + if (err || !compositor) { + vr_ShutdownInternal(); + return; + } + + mOpenVRHMD = new VRDisplayOpenVR(system, chaperone, compositor); + } + + if (mOpenVRHMD) { + aHMDResult.AppendElement(mOpenVRHMD); + } +} + +VRControllerOpenVR::VRControllerOpenVR() + : VRControllerHost(VRDeviceType::OpenVR) +{ + MOZ_COUNT_CTOR_INHERITED(VRControllerOpenVR, VRControllerHost); + mControllerInfo.mControllerName.AssignLiteral("OpenVR HMD"); +#ifdef MOZ_GAMEPAD + mControllerInfo.mMappingType = static_cast<uint32_t>(GamepadMappingType::_empty); +#else + mControllerInfo.mMappingType = 0; +#endif + mControllerInfo.mNumButtons = gNumOpenVRButtonMask; + mControllerInfo.mNumAxes = gNumOpenVRAxis; +} + +VRControllerOpenVR::~VRControllerOpenVR() +{ + MOZ_COUNT_DTOR_INHERITED(VRControllerOpenVR, VRControllerHost); +} + +void +VRControllerOpenVR::SetTrackedIndex(uint32_t aTrackedIndex) +{ + mTrackedIndex = aTrackedIndex; +} + +uint32_t +VRControllerOpenVR::GetTrackedIndex() +{ + return mTrackedIndex; +} + +VRControllerManagerOpenVR::VRControllerManagerOpenVR() + : mOpenVRInstalled(false), mVRSystem(nullptr) +{ +} + +VRControllerManagerOpenVR::~VRControllerManagerOpenVR() +{ + Destroy(); +} + +/*static*/ already_AddRefed<VRControllerManagerOpenVR> +VRControllerManagerOpenVR::Create() +{ + if (!gfxPrefs::VREnabled() || !gfxPrefs::VROpenVREnabled()) { + return nullptr; + } + + RefPtr<VRControllerManagerOpenVR> manager = new VRControllerManagerOpenVR(); + return manager.forget(); +} + +bool +VRControllerManagerOpenVR::Init() +{ + if (mOpenVRInstalled) + return true; + + if (!vr_IsRuntimeInstalled()) + return false; + + // Loading the OpenVR Runtime + vr::EVRInitError err = vr::VRInitError_None; + + vr_InitInternal(&err, vr::VRApplication_Scene); + if (err != vr::VRInitError_None) { + return false; + } + + mVRSystem = (vr::IVRSystem *)vr_GetGenericInterface(vr::IVRSystem_Version, &err); + if ((err != vr::VRInitError_None) || !mVRSystem) { + vr_ShutdownInternal(); + return false; + } + + mOpenVRInstalled = true; + return true; +} + +void +VRControllerManagerOpenVR::Destroy() +{ + mOpenVRController.Clear(); + mOpenVRInstalled = false; +} + +void +VRControllerManagerOpenVR::HandleInput() +{ + RefPtr<impl::VRControllerOpenVR> controller; + vr::VRControllerState_t state; + uint32_t axis = 0; + + if (!mOpenVRInstalled) { + return; + } + + MOZ_ASSERT(mVRSystem); + + vr::TrackedDevicePose_t poses[vr::k_unMaxTrackedDeviceCount]; + mVRSystem->GetDeviceToAbsoluteTrackingPose(vr::TrackingUniverseSeated, 0.0f, + poses, vr::k_unMaxTrackedDeviceCount); + // Process OpenVR controller state + for (uint32_t i = 0; i < mOpenVRController.Length(); ++i) { + controller = mOpenVRController[i]; + + MOZ_ASSERT(mVRSystem->GetTrackedDeviceClass(controller->GetTrackedIndex()) + == vr::TrackedDeviceClass_Controller); + + if (mVRSystem->GetControllerState(controller->GetTrackedIndex(), &state)) { + HandleButtonPress(controller->GetIndex(), state.ulButtonPressed); + + axis = static_cast<uint32_t>(VRControllerAxisType::TrackpadXAxis); + HandleAxisMove(controller->GetIndex(), axis, + state.rAxis[gOpenVRAxes[axis]].x); + + axis = static_cast<uint32_t>(VRControllerAxisType::TrackpadYAxis); + HandleAxisMove(controller->GetIndex(), axis, + state.rAxis[gOpenVRAxes[axis]].y); + + axis = static_cast<uint32_t>(VRControllerAxisType::Trigger); + HandleAxisMove(controller->GetIndex(), axis, + state.rAxis[gOpenVRAxes[axis]].x); + } + + // Start to process pose + const ::vr::TrackedDevicePose_t& pose = poses[controller->GetTrackedIndex()]; + + if (pose.bDeviceIsConnected && pose.bPoseIsValid && + pose.eTrackingResult == vr::TrackingResult_Running_OK) { + gfx::Matrix4x4 m; + + // NOTE! mDeviceToAbsoluteTracking is a 3x4 matrix, not 4x4. But + // because of its arrangement, we can copy the 12 elements in and + // then transpose them to the right place. We do this so we can + // pull out a Quaternion. + memcpy(&m.components, &pose.mDeviceToAbsoluteTracking, sizeof(float) * 12); + m.Transpose(); + + gfx::Quaternion rot; + rot.SetFromRotationMatrix(m); + rot.Invert(); + + GamepadPoseState poseState; + poseState.flags |= GamepadCapabilityFlags::Cap_Orientation; + poseState.orientation[0] = rot.x; + poseState.orientation[1] = rot.y; + poseState.orientation[2] = rot.z; + poseState.orientation[3] = rot.w; + poseState.angularVelocity[0] = pose.vAngularVelocity.v[0]; + poseState.angularVelocity[1] = pose.vAngularVelocity.v[1]; + poseState.angularVelocity[2] = pose.vAngularVelocity.v[2]; + + poseState.flags |= GamepadCapabilityFlags::Cap_Position; + poseState.position[0] = m._41; + poseState.position[1] = m._42; + poseState.position[2] = m._43; + poseState.linearVelocity[0] = pose.vVelocity.v[0]; + poseState.linearVelocity[1] = pose.vVelocity.v[1]; + poseState.linearVelocity[2] = pose.vVelocity.v[2]; + HandlePoseTracking(controller->GetIndex(), poseState, controller); + } + } +} + +void +VRControllerManagerOpenVR::HandleButtonPress(uint32_t aControllerIdx, + uint64_t aButtonPressed) +{ + uint64_t buttonMask = 0; + RefPtr<impl::VRControllerOpenVR> controller; + controller = mOpenVRController[aControllerIdx]; + uint64_t diff = (controller->GetButtonPressed() ^ aButtonPressed); + + if (!diff) { + return; + } + + for (uint32_t i = 0; i < gNumOpenVRButtonMask; ++i) { + buttonMask = gOpenVRButtonMask[i]; + + if (diff & buttonMask) { + // diff & aButtonPressed would be true while a new button press + // event, otherwise it is an old press event and needs to notify + // the button has been released. + NewButtonEvent(aControllerIdx, i, diff & aButtonPressed); + } + } + + controller->SetButtonPressed(aButtonPressed); +} + +void +VRControllerManagerOpenVR::HandleAxisMove(uint32_t aControllerIdx, uint32_t aAxis, + float aValue) +{ + if (aValue != 0.0f) { + NewAxisMove(aControllerIdx, aAxis, aValue); + } +} + +void +VRControllerManagerOpenVR::HandlePoseTracking(uint32_t aControllerIdx, + const GamepadPoseState& aPose, + VRControllerHost* aController) +{ + if (aPose != aController->GetPose()) { + aController->SetPose(aPose); + NewPoseState(aControllerIdx, aPose); + } +} + +void +VRControllerManagerOpenVR::GetControllers(nsTArray<RefPtr<VRControllerHost>>& aControllerResult) +{ + if (!mOpenVRInstalled) { + return; + } + + aControllerResult.Clear(); + for (uint32_t i = 0; i < mOpenVRController.Length(); ++i) { + aControllerResult.AppendElement(mOpenVRController[i]); + } +} + +void +VRControllerManagerOpenVR::ScanForDevices() +{ + // Remove the existing gamepads + for (uint32_t i = 0; i < mOpenVRController.Length(); ++i) { + RemoveGamepad(mOpenVRController[i]->GetIndex()); + } + mControllerCount = 0; + mOpenVRController.Clear(); + + if (!mVRSystem) + return; + + // Basically, we would have HMDs in the tracked devices, but we are just interested in the controllers. + for ( vr::TrackedDeviceIndex_t trackedDevice = vr::k_unTrackedDeviceIndex_Hmd + 1; + trackedDevice < vr::k_unMaxTrackedDeviceCount; ++trackedDevice ) { + if (!mVRSystem->IsTrackedDeviceConnected(trackedDevice)) { + continue; + } + + if (mVRSystem->GetTrackedDeviceClass(trackedDevice) != vr::TrackedDeviceClass_Controller) { + continue; + } + + RefPtr<VRControllerOpenVR> openVRController = new VRControllerOpenVR(); + openVRController->SetIndex(mControllerCount); + openVRController->SetTrackedIndex(trackedDevice); + mOpenVRController.AppendElement(openVRController); + +// Only in MOZ_GAMEPAD platform, We add gamepads. +#ifdef MOZ_GAMEPAD + // Not already present, add it. + AddGamepad("OpenVR Gamepad", static_cast<uint32_t>(GamepadMappingType::_empty), + gNumOpenVRButtonMask, gNumOpenVRAxis); + ++mControllerCount; +#endif + } +}
\ No newline at end of file |