Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

83 files changed, 20448 insertions, 0 deletions

diff --git a/gfx/vr/service/OSVRSession.cpp b/gfx/vr/service/OSVRSession.cpp
new file mode 100644
index 0000000000..8315bc7f4a
--- /dev/null
+++ b/gfx/vr/service/OSVRSession.cpp
@@ -0,0 +1,513 @@
+/* -*- 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/. */
+
+#include "OSVRSession.h"
+#include "prenv.h"
+#include "nsString.h"
+#include "mozilla/Preferences.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "mozilla/SharedLibrary.h"
+#include "mozilla/gfx/Quaternion.h"
+
+#if defined(XP_WIN)
+#  include <d3d11.h>
+#  include "mozilla/gfx/DeviceManagerDx.h"
+#endif  // defined(XP_WIN)
+
+#ifndef M_PI
+#  define M_PI 3.14159265358979323846
+#endif
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+namespace {
+// need to typedef functions that will be used in the code below
+extern "C" {
+typedef OSVR_ClientContext (*pfn_osvrClientInit)(
+    const char applicationIdentifier[], uint32_t flags);
+typedef OSVR_ReturnCode (*pfn_osvrClientShutdown)(OSVR_ClientContext ctx);
+typedef OSVR_ReturnCode (*pfn_osvrClientUpdate)(OSVR_ClientContext ctx);
+typedef OSVR_ReturnCode (*pfn_osvrClientCheckStatus)(OSVR_ClientContext ctx);
+typedef OSVR_ReturnCode (*pfn_osvrClientGetInterface)(
+    OSVR_ClientContext ctx, const char path[], OSVR_ClientInterface* iface);
+typedef OSVR_ReturnCode (*pfn_osvrClientFreeInterface)(
+    OSVR_ClientContext ctx, OSVR_ClientInterface iface);
+typedef OSVR_ReturnCode (*pfn_osvrGetOrientationState)(
+    OSVR_ClientInterface iface, OSVR_TimeValue* timestamp,
+    OSVR_OrientationState* state);
+typedef OSVR_ReturnCode (*pfn_osvrGetPositionState)(OSVR_ClientInterface iface,
+                                                    OSVR_TimeValue* timestamp,
+                                                    OSVR_PositionState* state);
+typedef OSVR_ReturnCode (*pfn_osvrClientGetDisplay)(OSVR_ClientContext ctx,
+                                                    OSVR_DisplayConfig* disp);
+typedef OSVR_ReturnCode (*pfn_osvrClientFreeDisplay)(OSVR_DisplayConfig disp);
+typedef OSVR_ReturnCode (*pfn_osvrClientGetNumEyesForViewer)(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount* eyes);
+typedef OSVR_ReturnCode (*pfn_osvrClientGetViewerEyePose)(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_Pose3* pose);
+typedef OSVR_ReturnCode (*pfn_osvrClientGetDisplayDimensions)(
+    OSVR_DisplayConfig disp, OSVR_DisplayInputCount displayInputIndex,
+    OSVR_DisplayDimension* width, OSVR_DisplayDimension* height);
+typedef OSVR_ReturnCode (
+    *pfn_osvrClientGetViewerEyeSurfaceProjectionClippingPlanes)(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, double* left, double* right, double* bottom,
+    double* top);
+typedef OSVR_ReturnCode (*pfn_osvrClientGetRelativeViewportForViewerEyeSurface)(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, OSVR_ViewportDimension* left,
+    OSVR_ViewportDimension* bottom, OSVR_ViewportDimension* width,
+    OSVR_ViewportDimension* height);
+typedef OSVR_ReturnCode (*pfn_osvrClientGetViewerEyeSurfaceProjectionMatrixf)(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, float near, float far,
+    OSVR_MatrixConventions flags, float* matrix);
+typedef OSVR_ReturnCode (*pfn_osvrClientCheckDisplayStartup)(
+    OSVR_DisplayConfig disp);
+typedef OSVR_ReturnCode (*pfn_osvrClientSetRoomRotationUsingHead)(
+    OSVR_ClientContext ctx);
+}
+
+static pfn_osvrClientInit osvr_ClientInit = nullptr;
+static pfn_osvrClientShutdown osvr_ClientShutdown = nullptr;
+static pfn_osvrClientUpdate osvr_ClientUpdate = nullptr;
+static pfn_osvrClientCheckStatus osvr_ClientCheckStatus = nullptr;
+static pfn_osvrClientGetInterface osvr_ClientGetInterface = nullptr;
+static pfn_osvrClientFreeInterface osvr_ClientFreeInterface = nullptr;
+static pfn_osvrGetOrientationState osvr_GetOrientationState = nullptr;
+static pfn_osvrGetPositionState osvr_GetPositionState = nullptr;
+static pfn_osvrClientGetDisplay osvr_ClientGetDisplay = nullptr;
+static pfn_osvrClientFreeDisplay osvr_ClientFreeDisplay = nullptr;
+static pfn_osvrClientGetNumEyesForViewer osvr_ClientGetNumEyesForViewer =
+    nullptr;
+static pfn_osvrClientGetViewerEyePose osvr_ClientGetViewerEyePose = nullptr;
+static pfn_osvrClientGetDisplayDimensions osvr_ClientGetDisplayDimensions =
+    nullptr;
+static pfn_osvrClientGetViewerEyeSurfaceProjectionClippingPlanes
+    osvr_ClientGetViewerEyeSurfaceProjectionClippingPlanes = nullptr;
+static pfn_osvrClientGetRelativeViewportForViewerEyeSurface
+    osvr_ClientGetRelativeViewportForViewerEyeSurface = nullptr;
+static pfn_osvrClientGetViewerEyeSurfaceProjectionMatrixf
+    osvr_ClientGetViewerEyeSurfaceProjectionMatrixf = nullptr;
+static pfn_osvrClientCheckDisplayStartup osvr_ClientCheckDisplayStartup =
+    nullptr;
+static pfn_osvrClientSetRoomRotationUsingHead
+    osvr_ClientSetRoomRotationUsingHead = nullptr;
+
+bool LoadOSVRRuntime() {
+  static PRLibrary* osvrUtilLib = nullptr;
+  static PRLibrary* osvrCommonLib = nullptr;
+  static PRLibrary* osvrClientLib = nullptr;
+  static PRLibrary* osvrClientKitLib = nullptr;
+  // this looks up the path in the about:config setting, from greprefs.js or
+  // modules\libpref\init\all.js we need all the libs to be valid
+#ifdef XP_WIN
+  constexpr static auto* pfnGetPathStringPref = mozilla::Preferences::GetString;
+  nsAutoString osvrUtilPath, osvrCommonPath, osvrClientPath, osvrClientKitPath;
+#else
+  constexpr static auto* pfnGetPathStringPref =
+      mozilla::Preferences::GetCString;
+  nsAutoCString osvrUtilPath, osvrCommonPath, osvrClientPath, osvrClientKitPath;
+#endif
+  if (NS_FAILED(pfnGetPathStringPref("gfx.vr.osvr.utilLibPath", osvrUtilPath,
+                                     PrefValueKind::User)) ||
+      NS_FAILED(pfnGetPathStringPref("gfx.vr.osvr.commonLibPath",
+                                     osvrCommonPath, PrefValueKind::User)) ||
+      NS_FAILED(pfnGetPathStringPref("gfx.vr.osvr.clientLibPath",
+                                     osvrClientPath, PrefValueKind::User)) ||
+      NS_FAILED(pfnGetPathStringPref("gfx.vr.osvr.clientKitLibPath",
+                                     osvrClientKitPath, PrefValueKind::User))) {
+    return false;
+  }
+
+  osvrUtilLib = LoadLibraryWithFlags(osvrUtilPath.get());
+  osvrCommonLib = LoadLibraryWithFlags(osvrCommonPath.get());
+  osvrClientLib = LoadLibraryWithFlags(osvrClientPath.get());
+  osvrClientKitLib = LoadLibraryWithFlags(osvrClientKitPath.get());
+
+  if (!osvrUtilLib) {
+    printf_stderr("[OSVR] Failed to load OSVR Util library!\n");
+    return false;
+  }
+  if (!osvrCommonLib) {
+    printf_stderr("[OSVR] Failed to load OSVR Common library!\n");
+    return false;
+  }
+  if (!osvrClientLib) {
+    printf_stderr("[OSVR] Failed to load OSVR Client library!\n");
+    return false;
+  }
+  if (!osvrClientKitLib) {
+    printf_stderr("[OSVR] Failed to load OSVR ClientKit library!\n");
+    return false;
+  }
+
+// make sure all functions that we'll be using are available
+#define REQUIRE_FUNCTION(_x)                                                  \
+  do {                                                                        \
+    *(void**)&osvr_##_x = (void*)PR_FindSymbol(osvrClientKitLib, "osvr" #_x); \
+    if (!osvr_##_x) {                                                         \
+      printf_stderr("osvr" #_x " symbol missing\n");                          \
+      goto fail;                                                              \
+    }                                                                         \
+  } while (0)
+
+  REQUIRE_FUNCTION(ClientInit);
+  REQUIRE_FUNCTION(ClientShutdown);
+  REQUIRE_FUNCTION(ClientUpdate);
+  REQUIRE_FUNCTION(ClientCheckStatus);
+  REQUIRE_FUNCTION(ClientGetInterface);
+  REQUIRE_FUNCTION(ClientFreeInterface);
+  REQUIRE_FUNCTION(GetOrientationState);
+  REQUIRE_FUNCTION(GetPositionState);
+  REQUIRE_FUNCTION(ClientGetDisplay);
+  REQUIRE_FUNCTION(ClientFreeDisplay);
+  REQUIRE_FUNCTION(ClientGetNumEyesForViewer);
+  REQUIRE_FUNCTION(ClientGetViewerEyePose);
+  REQUIRE_FUNCTION(ClientGetDisplayDimensions);
+  REQUIRE_FUNCTION(ClientGetViewerEyeSurfaceProjectionClippingPlanes);
+  REQUIRE_FUNCTION(ClientGetRelativeViewportForViewerEyeSurface);
+  REQUIRE_FUNCTION(ClientGetViewerEyeSurfaceProjectionMatrixf);
+  REQUIRE_FUNCTION(ClientCheckDisplayStartup);
+  REQUIRE_FUNCTION(ClientSetRoomRotationUsingHead);
+
+#undef REQUIRE_FUNCTION
+
+  return true;
+
+fail:
+  return false;
+}
+
+}  // namespace
+
+mozilla::gfx::VRFieldOfView SetFromTanRadians(double left, double right,
+                                              double bottom, double top) {
+  mozilla::gfx::VRFieldOfView fovInfo;
+  fovInfo.leftDegrees = atan(left) * 180.0 / M_PI;
+  fovInfo.rightDegrees = atan(right) * 180.0 / M_PI;
+  fovInfo.upDegrees = atan(top) * 180.0 / M_PI;
+  fovInfo.downDegrees = atan(bottom) * 180.0 / M_PI;
+  return fovInfo;
+}
+
+OSVRSession::OSVRSession()
+    : mRuntimeLoaded(false),
+      mOSVRInitialized(false),
+      mClientContextInitialized(false),
+      mDisplayConfigInitialized(false),
+      mInterfaceInitialized(false),
+      m_ctx(nullptr),
+      m_iface(nullptr),
+      m_display(nullptr) {}
+OSVRSession::~OSVRSession() { Shutdown(); }
+
+bool OSVRSession::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_osvr_enabled()) {
+    return false;
+  }
+  if (mOSVRInitialized) {
+    return true;
+  }
+  if (!LoadOSVRRuntime()) {
+    return false;
+  }
+  mRuntimeLoaded = true;
+
+  if (aDetectRuntimesOnly) {
+    aSystemState.displayState.capabilityFlags |=
+        VRDisplayCapabilityFlags::Cap_ImmersiveVR;
+    return false;
+  }
+
+  // initialize client context
+  InitializeClientContext();
+  // try to initialize interface
+  InitializeInterface();
+  // try to initialize display object
+  InitializeDisplay();
+  // verify all components are initialized
+  CheckOSVRStatus();
+
+  if (!mOSVRInitialized) {
+    return false;
+  }
+
+  if (!InitState(aSystemState)) {
+    return false;
+  }
+
+  return true;
+}
+
+void OSVRSession::CheckOSVRStatus() {
+  if (mOSVRInitialized) {
+    return;
+  }
+
+  // client context must be initialized first
+  InitializeClientContext();
+
+  // update client context
+  osvr_ClientUpdate(m_ctx);
+
+  // initialize interface and display if they are not initialized yet
+  InitializeInterface();
+  InitializeDisplay();
+
+  // OSVR is fully initialized now
+  if (mClientContextInitialized && mDisplayConfigInitialized &&
+      mInterfaceInitialized) {
+    mOSVRInitialized = true;
+  }
+}
+
+void OSVRSession::InitializeClientContext() {
+  // already initialized
+  if (mClientContextInitialized) {
+    return;
+  }
+
+  // first time creating
+  if (!m_ctx) {
+    // get client context
+    m_ctx = osvr_ClientInit("com.osvr.webvr", 0);
+    // update context
+    osvr_ClientUpdate(m_ctx);
+    // verify we are connected
+    if (OSVR_RETURN_SUCCESS == osvr_ClientCheckStatus(m_ctx)) {
+      mClientContextInitialized = true;
+    }
+  }
+  // client context exists but not up and running yet
+  else {
+    // update context
+    osvr_ClientUpdate(m_ctx);
+    if (OSVR_RETURN_SUCCESS == osvr_ClientCheckStatus(m_ctx)) {
+      mClientContextInitialized = true;
+    }
+  }
+}
+
+void OSVRSession::InitializeInterface() {
+  // already initialized
+  if (mInterfaceInitialized) {
+    return;
+  }
+  // Client context must be initialized before getting interface
+  if (mClientContextInitialized) {
+    // m_iface will remain nullptr if no interface is returned
+    if (OSVR_RETURN_SUCCESS ==
+        osvr_ClientGetInterface(m_ctx, "/me/head", &m_iface)) {
+      mInterfaceInitialized = true;
+    }
+  }
+}
+
+void OSVRSession::InitializeDisplay() {
+  // display is fully configured
+  if (mDisplayConfigInitialized) {
+    return;
+  }
+
+  // Client context must be initialized before getting interface
+  if (mClientContextInitialized) {
+    // first time creating display object
+    if (m_display == nullptr) {
+      OSVR_ReturnCode ret = osvr_ClientGetDisplay(m_ctx, &m_display);
+
+      if (ret == OSVR_RETURN_SUCCESS) {
+        osvr_ClientUpdate(m_ctx);
+        // display object may have been created but not fully startup
+        if (OSVR_RETURN_SUCCESS == osvr_ClientCheckDisplayStartup(m_display)) {
+          mDisplayConfigInitialized = true;
+        }
+      }
+
+      // Typically once we get Display object, pose data is available after
+      // clientUpdate but sometimes it takes ~ 200 ms to get
+      // a succesfull connection, so we might have to run a few update cycles
+    } else {
+      if (OSVR_RETURN_SUCCESS == osvr_ClientCheckDisplayStartup(m_display)) {
+        mDisplayConfigInitialized = true;
+      }
+    }
+  }
+}
+
+bool OSVRSession::InitState(mozilla::gfx::VRSystemState& aSystemState) {
+  VRDisplayState& state = aSystemState.displayState;
+  strncpy(state.displayName, "OSVR HMD", kVRDisplayNameMaxLen);
+  state.eightCC = GFX_VR_EIGHTCC('O', 'S', 'V', 'R', ' ', ' ', ' ', ' ');
+  state.isConnected = true;
+  state.isMounted = false;
+  state.capabilityFlags =
+      (VRDisplayCapabilityFlags)((int)VRDisplayCapabilityFlags::Cap_None |
+                                 (int)
+                                     VRDisplayCapabilityFlags::Cap_Orientation |
+                                 (int)VRDisplayCapabilityFlags::Cap_Position |
+                                 (int)VRDisplayCapabilityFlags::Cap_External |
+                                 (int)VRDisplayCapabilityFlags::Cap_Present |
+                                 (int)
+                                     VRDisplayCapabilityFlags::Cap_ImmersiveVR);
+  state.blendMode = VRDisplayBlendMode::Opaque;
+  state.reportsDroppedFrames = false;
+
+  // XXX OSVR display topology allows for more than one viewer
+  // will assume only one viewer for now (most likely stay that way)
+
+  OSVR_EyeCount numEyes;
+  osvr_ClientGetNumEyesForViewer(m_display, 0, &numEyes);
+
+  for (uint8_t eye = 0; eye < numEyes; eye++) {
+    double left, right, bottom, top;
+    // XXX for now there is only one surface per eye
+    osvr_ClientGetViewerEyeSurfaceProjectionClippingPlanes(
+        m_display, 0, eye, 0, &left, &right, &bottom, &top);
+    state.eyeFOV[eye] = SetFromTanRadians(-left, right, -bottom, top);
+  }
+
+  // XXX Assuming there is only one display input for now
+  // however, it's possible to have more than one (dSight with 2 HDMI inputs)
+  OSVR_DisplayDimension width, height;
+  osvr_ClientGetDisplayDimensions(m_display, 0, &width, &height);
+
+  for (uint8_t eye = 0; eye < numEyes; eye++) {
+    OSVR_ViewportDimension l, b, w, h;
+    osvr_ClientGetRelativeViewportForViewerEyeSurface(m_display, 0, eye, 0, &l,
+                                                      &b, &w, &h);
+    state.eyeResolution.width = w;
+    state.eyeResolution.height = h;
+    OSVR_Pose3 eyePose;
+    // Viewer eye pose may not be immediately available, update client context
+    // until we get it
+    OSVR_ReturnCode ret =
+        osvr_ClientGetViewerEyePose(m_display, 0, eye, &eyePose);
+    while (ret != OSVR_RETURN_SUCCESS) {
+      osvr_ClientUpdate(m_ctx);
+      ret = osvr_ClientGetViewerEyePose(m_display, 0, eye, &eyePose);
+    }
+    state.eyeTranslation[eye].x = eyePose.translation.data[0];
+    state.eyeTranslation[eye].y = eyePose.translation.data[1];
+    state.eyeTranslation[eye].z = eyePose.translation.data[2];
+
+    Matrix4x4 pose;
+    pose.SetRotationFromQuaternion(gfx::Quaternion(
+        osvrQuatGetX(&eyePose.rotation), osvrQuatGetY(&eyePose.rotation),
+        osvrQuatGetZ(&eyePose.rotation), osvrQuatGetW(&eyePose.rotation)));
+    pose.PreTranslate(eyePose.translation.data[0], eyePose.translation.data[1],
+                      eyePose.translation.data[2]);
+    pose.Invert();
+    mHeadToEye[eye] = pose;
+  }
+
+  // default to an identity quaternion
+  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 OSVRSession::Shutdown() {
+  if (!mRuntimeLoaded) {
+    return;
+  }
+  mOSVRInitialized = false;
+  // client context may not have been initialized
+  if (m_ctx) {
+    osvr_ClientFreeDisplay(m_display);
+  }
+  // osvr checks that m_ctx or m_iface are not null
+  osvr_ClientFreeInterface(m_ctx, m_iface);
+  osvr_ClientShutdown(m_ctx);
+}
+
+void OSVRSession::ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) {}
+
+void OSVRSession::StartFrame(mozilla::gfx::VRSystemState& aSystemState) {
+  UpdateHeadsetPose(aSystemState);
+}
+
+void OSVRSession::UpdateHeadsetPose(mozilla::gfx::VRSystemState& aState) {
+  // Update client context before anything
+  // this usually goes into app's mainloop
+  osvr_ClientUpdate(m_ctx);
+
+  VRHMDSensorState result{};
+  OSVR_TimeValue timestamp;
+
+  OSVR_OrientationState orientation;
+
+  OSVR_ReturnCode ret =
+      osvr_GetOrientationState(m_iface, &timestamp, &orientation);
+
+  aState.sensorState.timestamp = timestamp.seconds;
+
+  if (ret == OSVR_RETURN_SUCCESS) {
+    result.flags |= VRDisplayCapabilityFlags::Cap_Orientation;
+    result.pose.orientation[0] = orientation.data[1];
+    result.pose.orientation[1] = orientation.data[2];
+    result.pose.orientation[2] = orientation.data[3];
+    result.pose.orientation[3] = orientation.data[0];
+  } else {
+    // default to an identity quaternion
+    result.pose.orientation[3] = 1.0f;
+  }
+
+  OSVR_PositionState position;
+  ret = osvr_GetPositionState(m_iface, &timestamp, &position);
+  if (ret == OSVR_RETURN_SUCCESS) {
+    result.flags |= VRDisplayCapabilityFlags::Cap_Position;
+    result.pose.position[0] = position.data[0];
+    result.pose.position[1] = position.data[1];
+    result.pose.position[2] = position.data[2];
+  }
+
+  result.CalcViewMatrices(mHeadToEye);
+}
+
+bool OSVRSession::StartPresentation() {
+  return false;
+  // TODO Implement
+}
+
+void OSVRSession::StopPresentation() {
+  // TODO Implement
+}
+
+#if defined(XP_WIN)
+bool OSVRSession::SubmitFrame(
+    const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+    ID3D11Texture2D* aTexture) {
+  return false;
+  // TODO Implement
+}
+#elif defined(XP_MACOSX)
+bool OSVRSession::SubmitFrame(
+    const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+    const VRLayerTextureHandle& aTexture) {
+  return false;
+  // TODO Implement
+}
+#endif
+
+void OSVRSession::VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
+                                float aIntensity, float aDuration) {}
+
+void OSVRSession::StopVibrateHaptic(uint32_t aControllerIdx) {}
+
+void OSVRSession::StopAllHaptics() {}
diff --git a/gfx/vr/service/OSVRSession.h b/gfx/vr/service/OSVRSession.h
new file mode 100644
index 0000000000..d98553ff33
--- /dev/null
+++ b/gfx/vr/service/OSVRSession.h
@@ -0,0 +1,76 @@
+/* -*- 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 GFX_VR_SERVICE_OSVRSESSION_H
+#define GFX_VR_SERVICE_OSVRSESSION_H
+
+#include "VRSession.h"
+
+#include "mozilla/gfx/2D.h"
+#include "mozilla/TimeStamp.h"
+#include "moz_external_vr.h"
+
+#include <osvr/ClientKit/ClientKitC.h>
+#include <osvr/ClientKit/DisplayC.h>
+
+#if defined(XP_WIN)
+#  include <d3d11_1.h>
+#endif
+
+namespace mozilla {
+namespace gfx {
+
+class OSVRSession : public VRSession {
+ public:
+  OSVRSession();
+  virtual ~OSVRSession();
+
+  bool Initialize(mozilla::gfx::VRSystemState& aSystemState,
+                  bool aDetectRuntimesOnly) override;
+  void Shutdown() override;
+  void ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) override;
+  void StartFrame(mozilla::gfx::VRSystemState& aSystemState) override;
+  bool StartPresentation() override;
+  void StopPresentation() override;
+  void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
+                     float aIntensity, float aDuration) override;
+  void StopVibrateHaptic(uint32_t aControllerIdx) override;
+  void StopAllHaptics() override;
+
+ protected:
+#if defined(XP_WIN)
+  bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                   ID3D11Texture2D* aTexture) override;
+#elif defined(XP_MACOSX)
+  bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                   const VRLayerTextureHandle& aTexture) override;
+#endif
+
+ private:
+  bool InitState(mozilla::gfx::VRSystemState& aSystemState);
+  void UpdateHeadsetPose(mozilla::gfx::VRSystemState& aState);
+  bool mRuntimeLoaded;
+  bool mOSVRInitialized;
+  bool mClientContextInitialized;
+  bool mDisplayConfigInitialized;
+  bool mInterfaceInitialized;
+  OSVR_ClientContext m_ctx;
+  OSVR_ClientInterface m_iface;
+  OSVR_DisplayConfig m_display;
+  gfx::Matrix4x4 mHeadToEye[2];
+
+  // check if all components are initialized
+  // and if not, it will try to initialize them
+  void CheckOSVRStatus();
+  void InitializeClientContext();
+  void InitializeDisplay();
+  void InitializeInterface();
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OSVRSESSION_H
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
diff --git a/gfx/vr/service/OculusSession.h b/gfx/vr/service/OculusSession.h
new file mode 100644
index 0000000000..0ab70e1817
--- /dev/null
+++ b/gfx/vr/service/OculusSession.h
@@ -0,0 +1,115 @@
+/* -*- 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 GFX_VR_SERVICE_OCULUSSESSION_H
+#define GFX_VR_SERVICE_OCULUSSESSION_H
+
+#include "VRSession.h"
+
+#include "moz_external_vr.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/gfx/2D.h"
+#include "nsTArray.h"
+#include "oculus/ovr_capi_dynamic.h"
+#include "prlink.h"
+#include "ShaderDefinitionsD3D11.h"  // for VertexShaderConstants and PixelShaderConstants
+
+struct ID3D11Device;
+
+namespace mozilla {
+namespace layers {
+struct VertexShaderConstants;
+struct PixelShaderConstants;
+}  // namespace layers
+namespace gfx {
+
+class OculusSession : public VRSession {
+ public:
+  OculusSession();
+  virtual ~OculusSession();
+
+  bool Initialize(mozilla::gfx::VRSystemState& aSystemState,
+                  bool aDetectRuntimesOnly) override;
+  void Shutdown() override;
+  void ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) override;
+  void StartFrame(mozilla::gfx::VRSystemState& aSystemState) override;
+  bool StartPresentation() override;
+  void StopPresentation() override;
+  bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                   ID3D11Texture2D* aTexture) override;
+  void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
+                     float aIntensity, float aDuration) override;
+  void StopVibrateHaptic(uint32_t aControllerIdx) override;
+  void StopAllHaptics() override;
+
+ private:
+  bool LoadOvrLib();
+  void UnloadOvrLib();
+  bool StartLib(ovrInitFlags aFlags);
+  void StopLib();
+  bool StartSession();
+  void StopSession();
+  bool StartRendering();
+  void StopRendering();
+  bool CreateD3DObjects();
+  bool CreateShaders();
+  void DestroyShaders();
+  void CoverTransitions();
+  void UpdateVisibility();
+  bool ChangeVisibility(bool bVisible);
+  bool InitState(mozilla::gfx::VRSystemState& aSystemState);
+  void UpdateStageParameters(mozilla::gfx::VRDisplayState& aState);
+  void UpdateEyeParameters(mozilla::gfx::VRSystemState& aState);
+  void UpdateHeadsetPose(mozilla::gfx::VRSystemState& aState);
+  void UpdateControllers(VRSystemState& aState);
+  void UpdateControllerInputs(VRSystemState& aState,
+                              const ovrInputState& aInputState);
+  void UpdateHaptics();
+  void EnumerateControllers(VRSystemState& aState,
+                            const ovrInputState& aInputState);
+  void UpdateControllerPose(VRSystemState& aState,
+                            const ovrInputState& aInputState);
+  void UpdateTelemetry(VRSystemState& aSystemState);
+  bool IsPresentationReady() const;
+  bool UpdateConstantBuffers();
+
+  PRLibrary* mOvrLib;
+  ovrSession mSession;
+  ovrInitFlags mInitFlags;
+  ovrTextureSwapChain mTextureSet;
+  nsTArray<RefPtr<ID3D11RenderTargetView>> mRTView;
+  nsTArray<RefPtr<ID3D11Texture2D>> mTexture;
+  nsTArray<RefPtr<ID3D11ShaderResourceView>> mSRV;
+
+  ID3D11VertexShader* mQuadVS;
+  ID3D11PixelShader* mQuadPS;
+  RefPtr<ID3D11SamplerState> mLinearSamplerState;
+  layers::VertexShaderConstants mVSConstants;
+  layers::PixelShaderConstants mPSConstants;
+  RefPtr<ID3D11Buffer> mVSConstantBuffer;
+  RefPtr<ID3D11Buffer> mPSConstantBuffer;
+  RefPtr<ID3D11Buffer> mVertexBuffer;
+  RefPtr<ID3D11InputLayout> mInputLayout;
+
+  IntSize mPresentationSize;
+  ovrFovPort mFOVPort[2];
+
+  // Most recent HMD eye poses, from start of frame
+  ovrPosef mFrameStartPose[2];
+
+  float mRemainingVibrateTime[2];
+  float mHapticPulseIntensity[2];
+  TimeStamp mLastHapticUpdate;
+
+  // The timestamp of the last ending presentation
+  TimeStamp mLastPresentationEnd;
+  bool mIsPresenting;
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OCULUSSESSION_H
diff --git a/gfx/vr/service/OpenVRControllerMapper.cpp b/gfx/vr/service/OpenVRControllerMapper.cpp
new file mode 100644
index 0000000000..7cb4cfb563
--- /dev/null
+++ b/gfx/vr/service/OpenVRControllerMapper.cpp
@@ -0,0 +1,89 @@
+/* -*- 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/. */
+
+#include "OpenVRControllerMapper.h"
+#include "mozilla/StaticPrefs_dom.h"
+
+#include "VRSession.h"
+
+namespace mozilla::gfx {
+
+OpenVRControllerMapper::OpenVRControllerMapper()
+    : mNumButtons(0), mNumAxes(0) {}
+
+void OpenVRControllerMapper::GetButtonValueFromAction(
+    VRControllerState& aControllerState, const ControllerAction& aPressAction,
+    const ControllerAction& aTouchAction) {
+  vr::InputDigitalActionData_t actionData = {};
+  bool bPressed = false;
+  bool bTouched = false;
+  uint64_t mask = 0;
+
+  if (aPressAction.handle &&
+      vr::VRInput()->GetDigitalActionData(
+          aPressAction.handle, &actionData, sizeof(actionData),
+          vr::k_ulInvalidInputValueHandle) == vr::VRInputError_None &&
+      actionData.bActive) {
+    bPressed = actionData.bState;
+    mask = (1ULL << mNumButtons);
+    aControllerState.triggerValue[mNumButtons] = bPressed ? 1.0 : 0.0f;
+    if (bPressed) {
+      aControllerState.buttonPressed |= mask;
+    } else {
+      aControllerState.buttonPressed &= ~mask;
+    }
+    if (aTouchAction.handle &&
+        vr::VRInput()->GetDigitalActionData(
+            aTouchAction.handle, &actionData, sizeof(actionData),
+            vr::k_ulInvalidInputValueHandle) == vr::VRInputError_None) {
+      bTouched = actionData.bActive && actionData.bState;
+      mask = (1ULL << mNumButtons);
+      if (bTouched) {
+        aControllerState.buttonTouched |= mask;
+      } else {
+        aControllerState.buttonTouched &= ~mask;
+      }
+    }
+    ++mNumButtons;
+  }
+}
+
+void OpenVRControllerMapper::GetTriggerValueFromAction(
+    VRControllerState& aControllerState, const ControllerAction& aAction) {
+  vr::InputAnalogActionData_t analogData = {};
+  const float triggerThreshold =
+      StaticPrefs::dom_vr_controller_trigger_threshold();
+
+  if (aAction.handle &&
+      vr::VRInput()->GetAnalogActionData(
+          aAction.handle, &analogData, sizeof(analogData),
+          vr::k_ulInvalidInputValueHandle) == vr::VRInputError_None &&
+      analogData.bActive) {
+    VRSession::UpdateTrigger(aControllerState, mNumButtons, analogData.x,
+                             triggerThreshold);
+    ++mNumButtons;
+  }
+}
+
+void OpenVRControllerMapper::GetAxisValueFromAction(
+    VRControllerState& aControllerState, const ControllerAction& aAction,
+    bool aInvertAxis) {
+  vr::InputAnalogActionData_t analogData = {};
+  const float yAxisInvert = (aInvertAxis) ? -1.0f : 1.0f;
+
+  if (aAction.handle &&
+      vr::VRInput()->GetAnalogActionData(
+          aAction.handle, &analogData, sizeof(analogData),
+          vr::k_ulInvalidInputValueHandle) == vr::VRInputError_None &&
+      analogData.bActive) {
+    aControllerState.axisValue[mNumAxes] = analogData.x;
+    ++mNumAxes;
+    aControllerState.axisValue[mNumAxes] = analogData.y * yAxisInvert;
+    ++mNumAxes;
+  }
+}
+
+}  // namespace mozilla::gfx
diff --git a/gfx/vr/service/OpenVRControllerMapper.h b/gfx/vr/service/OpenVRControllerMapper.h
new file mode 100644
index 0000000000..0fe96c8bbe
--- /dev/null
+++ b/gfx/vr/service/OpenVRControllerMapper.h
@@ -0,0 +1,96 @@
+/* -*- 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 GFX_VR_SERVICE_OPENVRCONTROLLERMAPPER_H
+#define GFX_VR_SERVICE_OPENVRCONTROLLERMAPPER_H
+
+#include "openvr.h"
+#include "nsString.h"
+
+#include "moz_external_vr.h"
+
+namespace mozilla {
+namespace gfx {
+
+struct ControllerAction {
+  nsCString name;
+  nsCString type;
+  vr::VRActionHandle_t handle = vr::k_ulInvalidActionHandle;
+
+  ControllerAction() = default;
+
+  ControllerAction(const char* aName, const char* aType)
+      : name(aName), type(aType) {}
+};
+
+struct ControllerInfo {
+  vr::VRInputValueHandle_t mSource = vr::k_ulInvalidInputValueHandle;
+
+  ControllerAction mActionPose;
+  ControllerAction mActionHaptic;
+
+  ControllerAction mActionTrackpad_Analog;
+  ControllerAction mActionTrackpad_Pressed;
+  ControllerAction mActionTrackpad_Touched;
+
+  ControllerAction mActionTrigger_Value;
+
+  ControllerAction mActionGrip_Pressed;
+  ControllerAction mActionGrip_Touched;
+  ControllerAction mActionMenu_Pressed;
+  ControllerAction mActionMenu_Touched;
+  // It seems like there's no way to get response from a sys. btn.
+  ControllerAction mActionSystem_Pressed;
+  ControllerAction mActionSystem_Touched;
+
+  // --- Knuckles & Cosmos
+  ControllerAction mActionA_Pressed;
+  ControllerAction mActionA_Touched;
+  ControllerAction mActionB_Pressed;
+  ControllerAction mActionB_Touched;
+
+  // --- Knuckles, Cosmos, and WMR
+  ControllerAction mActionThumbstick_Analog;
+  ControllerAction mActionThumbstick_Pressed;
+  ControllerAction mActionThumbstick_Touched;
+
+  // --- Knuckles
+  ControllerAction mActionFingerIndex_Value;
+  ControllerAction mActionFingerMiddle_Value;
+  ControllerAction mActionFingerRing_Value;
+  ControllerAction mActionFingerPinky_Value;
+
+  // --- Cosmos
+  ControllerAction mActionBumper_Pressed;
+};
+
+class OpenVRControllerMapper {
+ public:
+  OpenVRControllerMapper();
+  virtual ~OpenVRControllerMapper() = default;
+
+  virtual void UpdateButtons(VRControllerState& aControllerState,
+                             ControllerInfo& aControllerInfo) = 0;
+  uint32_t GetButtonCount() { return mNumButtons; }
+  uint32_t GetAxisCount() { return mNumAxes; }
+
+ protected:
+  void GetButtonValueFromAction(VRControllerState& aControllerState,
+                                const ControllerAction& aPressAction,
+                                const ControllerAction& aTouchAction);
+  void GetTriggerValueFromAction(VRControllerState& aControllerState,
+                                 const ControllerAction& aAction);
+  void GetAxisValueFromAction(VRControllerState& aControllerState,
+                              const ControllerAction& aAction,
+                              bool aInvertAxis = false);
+  uint32_t mNumButtons;
+  uint32_t mNumAxes;
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OPENVRCONTROLLERMAPPER_H
diff --git a/gfx/vr/service/OpenVRCosmosMapper.cpp b/gfx/vr/service/OpenVRCosmosMapper.cpp
new file mode 100644
index 0000000000..8c5c87253d
--- /dev/null
+++ b/gfx/vr/service/OpenVRCosmosMapper.cpp
@@ -0,0 +1,51 @@
+/* -*- 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/. */
+
+#include "OpenVRCosmosMapper.h"
+
+#include "moz_external_vr.h"
+#include "VRSession.h"
+
+namespace mozilla::gfx {
+
+void OpenVRCosmosMapper::UpdateButtons(VRControllerState& aControllerState,
+                                       ControllerInfo& aControllerInfo) {
+  mNumButtons = mNumAxes = 0;
+  // Button 0: Trigger
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionTrigger_Value);
+  // Button 1: Grip
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionGrip_Pressed,
+                           aControllerInfo.mActionGrip_Touched);
+  // Button 2: a placeholder button for trackpad.
+  ++mNumButtons;
+  // Button 3: Thumbstick
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionThumbstick_Pressed,
+                           aControllerInfo.mActionThumbstick_Touched);
+  // Button 4: A
+  GetButtonValueFromAction(aControllerState, aControllerInfo.mActionA_Pressed,
+                           aControllerInfo.mActionA_Touched);
+  // Button 5: B
+  GetButtonValueFromAction(aControllerState, aControllerInfo.mActionB_Pressed,
+                           aControllerInfo.mActionB_Touched);
+  // Button 6: Bumper
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionBumper_Pressed,
+                           aControllerInfo.mActionBumper_Pressed);
+
+  // Axis 0, 1: placeholder axes for touchpad.
+  mNumAxes += 2;
+  // Axis 2, 3: Thumbstick
+  GetAxisValueFromAction(aControllerState,
+                         aControllerInfo.mActionThumbstick_Analog);
+
+  aControllerState.numButtons = mNumButtons;
+  aControllerState.numAxes = mNumAxes;
+}
+
+}  // namespace mozilla::gfx
diff --git a/gfx/vr/service/OpenVRCosmosMapper.h b/gfx/vr/service/OpenVRCosmosMapper.h
new file mode 100644
index 0000000000..3796cd1c6d
--- /dev/null
+++ b/gfx/vr/service/OpenVRCosmosMapper.h
@@ -0,0 +1,26 @@
+/* -*- 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 GFX_VR_SERVICE_OPENVRCOSMOSMAPPER_H
+#define GFX_VR_SERVICE_OPENVRCOSMOSMAPPER_H
+
+#include "OpenVRControllerMapper.h"
+
+namespace mozilla {
+namespace gfx {
+
+class OpenVRCosmosMapper : public OpenVRControllerMapper {
+ public:
+  OpenVRCosmosMapper() = default;
+  virtual ~OpenVRCosmosMapper() = default;
+  virtual void UpdateButtons(VRControllerState& aControllerState,
+                             ControllerInfo& aControllerInfo);
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OPENVRCOSMOSMAPPER_H
diff --git a/gfx/vr/service/OpenVRDefaultMapper.cpp b/gfx/vr/service/OpenVRDefaultMapper.cpp
new file mode 100644
index 0000000000..ac65369475
--- /dev/null
+++ b/gfx/vr/service/OpenVRDefaultMapper.cpp
@@ -0,0 +1,70 @@
+/* -*- 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/. */
+
+#include "OpenVRDefaultMapper.h"
+
+#include "moz_external_vr.h"
+#include "VRSession.h"
+
+namespace mozilla::gfx {
+
+void OpenVRDefaultMapper::UpdateButtons(VRControllerState& aControllerState,
+                                        ControllerInfo& aControllerInfo) {
+  mNumButtons = mNumAxes = 0;
+  // Button 0: Trigger
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionTrigger_Value);
+  // Button 1: Grip
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionGrip_Pressed,
+                           aControllerInfo.mActionGrip_Touched);
+  // Button 2: Touchpad.
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionTrackpad_Pressed,
+                           aControllerInfo.mActionTrackpad_Touched);
+  // Button 3: Thumbstick
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionThumbstick_Pressed,
+                           aControllerInfo.mActionThumbstick_Touched);
+  // Button 4: Menu
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionMenu_Pressed,
+                           aControllerInfo.mActionMenu_Touched);
+  // Button 5: A
+  GetButtonValueFromAction(aControllerState, aControllerInfo.mActionA_Pressed,
+                           aControllerInfo.mActionA_Touched);
+  // Button 6: B
+  GetButtonValueFromAction(aControllerState, aControllerInfo.mActionB_Pressed,
+                           aControllerInfo.mActionB_Touched);
+  // Button 7: Bumper
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionBumper_Pressed,
+                           aControllerInfo.mActionBumper_Pressed);
+  // Button 8: Finger index
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionFingerIndex_Value);
+  // Button 9: Finger middle
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionFingerMiddle_Value);
+  // Button 10: Finger ring
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionFingerRing_Value);
+  // Button 11: Finger pinky
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionFingerPinky_Value);
+
+  // Axis 0, 1: Touchpad
+  GetAxisValueFromAction(aControllerState,
+                         aControllerInfo.mActionTrackpad_Analog);
+  // Axis 2, 3: Thumbstick
+  GetAxisValueFromAction(aControllerState,
+                         aControllerInfo.mActionThumbstick_Analog);
+
+  aControllerState.numButtons = mNumButtons;
+  aControllerState.numAxes = mNumAxes;
+}
+
+}  // namespace mozilla::gfx
diff --git a/gfx/vr/service/OpenVRDefaultMapper.h b/gfx/vr/service/OpenVRDefaultMapper.h
new file mode 100644
index 0000000000..0478a90687
--- /dev/null
+++ b/gfx/vr/service/OpenVRDefaultMapper.h
@@ -0,0 +1,26 @@
+/* -*- 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 GFX_VR_SERVICE_OPENVRDEFAULTMAPPER_H
+#define GFX_VR_SERVICE_OPENVRDEFAULTMAPPER_H
+
+#include "OpenVRControllerMapper.h"
+
+namespace mozilla {
+namespace gfx {
+
+class OpenVRDefaultMapper : public OpenVRControllerMapper {
+ public:
+  OpenVRDefaultMapper() = default;
+  virtual ~OpenVRDefaultMapper() = default;
+  virtual void UpdateButtons(VRControllerState& aControllerState,
+                             ControllerInfo& aControllerInfo);
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OPENVRDEFAULTMAPPER_H
diff --git a/gfx/vr/service/OpenVRKnucklesMapper.cpp b/gfx/vr/service/OpenVRKnucklesMapper.cpp
new file mode 100644
index 0000000000..74f38c820c
--- /dev/null
+++ b/gfx/vr/service/OpenVRKnucklesMapper.cpp
@@ -0,0 +1,62 @@
+/* -*- 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/. */
+
+#include "OpenVRKnucklesMapper.h"
+
+#include "moz_external_vr.h"
+#include "VRSession.h"
+
+namespace mozilla::gfx {
+
+void OpenVRKnucklesMapper::UpdateButtons(VRControllerState& aControllerState,
+                                         ControllerInfo& aControllerInfo) {
+  mNumButtons = mNumAxes = 0;
+  // Button 0: Trigger
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionTrigger_Value);
+  // Button 1: Grip
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionGrip_Pressed,
+                           aControllerInfo.mActionGrip_Touched);
+  // Button 2: Touchpad.
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionTrackpad_Pressed,
+                           aControllerInfo.mActionTrackpad_Touched);
+  // Button 3: Thumbstick
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionThumbstick_Pressed,
+                           aControllerInfo.mActionThumbstick_Touched);
+  // Button 4: A
+  GetButtonValueFromAction(aControllerState, aControllerInfo.mActionA_Pressed,
+                           aControllerInfo.mActionA_Touched);
+  // Button 5: B
+  GetButtonValueFromAction(aControllerState, aControllerInfo.mActionB_Pressed,
+                           aControllerInfo.mActionB_Touched);
+  // Button 6: Finger index
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionFingerIndex_Value);
+  // Button 7: Finger middle
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionFingerMiddle_Value);
+  // Button 8: Finger ring
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionFingerRing_Value);
+  // Button 9: Finger pinky
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionFingerPinky_Value);
+
+  // Axis 0, 1: Touchpad
+  GetAxisValueFromAction(aControllerState,
+                         aControllerInfo.mActionTrackpad_Analog);
+  // Axis 2, 3: Thumbstick
+  GetAxisValueFromAction(aControllerState,
+                         aControllerInfo.mActionThumbstick_Analog);
+
+  aControllerState.numButtons = mNumButtons;
+  aControllerState.numAxes = mNumAxes;
+}
+
+}  // namespace mozilla::gfx
diff --git a/gfx/vr/service/OpenVRKnucklesMapper.h b/gfx/vr/service/OpenVRKnucklesMapper.h
new file mode 100644
index 0000000000..45168e7749
--- /dev/null
+++ b/gfx/vr/service/OpenVRKnucklesMapper.h
@@ -0,0 +1,26 @@
+/* -*- 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 GFX_VR_SERVICE_OPENVRKNUCKLESMAPPER_H
+#define GFX_VR_SERVICE_OPENVRKNUCKLESMAPPER_H
+
+#include "OpenVRControllerMapper.h"
+
+namespace mozilla {
+namespace gfx {
+
+class OpenVRKnucklesMapper : public OpenVRControllerMapper {
+ public:
+  OpenVRKnucklesMapper() = default;
+  virtual ~OpenVRKnucklesMapper() = default;
+  virtual void UpdateButtons(VRControllerState& aControllerState,
+                             ControllerInfo& aControllerInfo);
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OPENVRKNUCKLESMAPPER_H
diff --git a/gfx/vr/service/OpenVRSession.cpp b/gfx/vr/service/OpenVRSession.cpp
new file mode 100644
index 0000000000..bfb486799d
--- /dev/null
+++ b/gfx/vr/service/OpenVRSession.cpp
@@ -0,0 +1,1476 @@
+/* -*- 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/. */
+
+#include <fstream>
+#include "mozilla/JSONStringWriteFuncs.h"
+#include "mozilla/ClearOnShutdown.h"
+#include "nsIThread.h"
+#include "nsString.h"
+
+#include "OpenVRSession.h"
+#include "mozilla/StaticPrefs_dom.h"
+
+#if defined(XP_WIN)
+#  include <d3d11.h>
+#  include "mozilla/gfx/DeviceManagerDx.h"
+#elif defined(XP_MACOSX)
+#  include "mozilla/gfx/MacIOSurface.h"
+#endif
+
+#if !defined(XP_WIN)
+#  include <sys/stat.h>  // for umask()
+#endif
+
+#include "mozilla/dom/GamepadEventTypes.h"
+#include "mozilla/dom/GamepadBinding.h"
+#include "binding/OpenVRCosmosBinding.h"
+#include "binding/OpenVRKnucklesBinding.h"
+#include "binding/OpenVRViveBinding.h"
+#include "OpenVRCosmosMapper.h"
+#include "OpenVRDefaultMapper.h"
+#include "OpenVRKnucklesMapper.h"
+#include "OpenVRViveMapper.h"
+#if defined(XP_WIN)  // Windows Mixed Reality is only available in Windows.
+#  include "OpenVRWMRMapper.h"
+#  include "binding/OpenVRWMRBinding.h"
+#endif
+
+#include "VRParent.h"
+#include "VRProcessChild.h"
+#include "VRThread.h"
+
+#if !defined(M_PI)
+#  define M_PI 3.14159265358979323846264338327950288
+#endif
+
+#define BTN_MASK_FROM_ID(_id) ::vr::ButtonMaskFromId(vr::EVRButtonId::_id)
+
+// Haptic feedback is updated every 5ms, as this is
+// the minimum period between new haptic pulse requests.
+// Effectively, this results in a pulse width modulation
+// with an interval of 5ms.  Through experimentation, the
+// maximum duty cycle was found to be about 3.9ms
+const uint32_t kVRHapticUpdateInterval = 5;
+
+using namespace mozilla::gfx;
+
+namespace mozilla::gfx {
+
+namespace {
+
+class ControllerManifestFile {
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(ControllerManifestFile)
+
+ public:
+  static already_AddRefed<ControllerManifestFile> CreateManifest() {
+    RefPtr<ControllerManifestFile> manifest = new ControllerManifestFile();
+    return manifest.forget();
+  }
+
+  bool IsExisting() {
+    if (mFileName.IsEmpty() ||
+        !std::ifstream(mFileName.BeginReading()).good()) {
+      return false;
+    }
+    return true;
+  }
+
+  void SetFileName(const char* aName) { mFileName = aName; }
+
+  const char* GetFileName() const { return mFileName.BeginReading(); }
+
+ private:
+  ControllerManifestFile() = default;
+
+  ~ControllerManifestFile() {
+    if (!mFileName.IsEmpty() && remove(mFileName.BeginReading()) != 0) {
+      MOZ_ASSERT(false, "Delete controller manifest file failed.");
+    }
+    mFileName = "";
+  }
+
+  nsCString mFileName;
+};
+
+// We wanna keep these temporary files existing
+// until Firefox is closed instead of following OpenVRSession's lifetime.
+StaticRefPtr<ControllerManifestFile> sCosmosBindingFile;
+StaticRefPtr<ControllerManifestFile> sKnucklesBindingFile;
+StaticRefPtr<ControllerManifestFile> sViveBindingFile;
+#if defined(XP_WIN)
+StaticRefPtr<ControllerManifestFile> sWMRBindingFile;
+#endif
+StaticRefPtr<ControllerManifestFile> sControllerActionFile;
+
+dom::GamepadHand GetControllerHandFromControllerRole(OpenVRHand aRole) {
+  dom::GamepadHand hand;
+  switch (aRole) {
+    case OpenVRHand::None:
+      hand = dom::GamepadHand::_empty;
+      break;
+    case OpenVRHand::Left:
+      hand = dom::GamepadHand::Left;
+      break;
+    case OpenVRHand::Right:
+      hand = dom::GamepadHand::Right;
+      break;
+    default:
+      hand = dom::GamepadHand::_empty;
+      MOZ_ASSERT(false);
+      break;
+  }
+
+  return hand;
+}
+
+bool FileIsExisting(const nsCString& aPath) {
+  if (aPath.IsEmpty() || !std::ifstream(aPath.BeginReading()).good()) {
+    return false;
+  }
+  return true;
+}
+
+};  // anonymous namespace
+
+#if defined(XP_WIN)
+bool GenerateTempFileName(nsCString& aPath) {
+  TCHAR tempPathBuffer[MAX_PATH];
+  TCHAR tempFileName[MAX_PATH];
+
+  // Gets the temp path env string (no guarantee it's a valid path).
+  DWORD dwRetVal = GetTempPath(MAX_PATH, tempPathBuffer);
+  if (dwRetVal > MAX_PATH || (dwRetVal == 0)) {
+    NS_WARNING("OpenVR - Creating temp path failed.");
+    return false;
+  }
+
+  // Generates a temporary file name.
+  UINT uRetVal = GetTempFileName(tempPathBuffer,  // directory for tmp files
+                                 TEXT("mozvr"),   // temp file name prefix
+                                 0,               // create unique name
+                                 tempFileName);   // buffer for name
+  if (uRetVal == 0) {
+    NS_WARNING("OpenVR - Creating temp file failed.");
+    return false;
+  }
+
+  aPath.Assign(NS_ConvertUTF16toUTF8(tempFileName));
+  return true;
+}
+#else
+bool GenerateTempFileName(nsCString& aPath) {
+  const char tmp[] = "/tmp/mozvrXXXXXX";
+  char fileName[PATH_MAX];
+
+  strcpy(fileName, tmp);
+  const mode_t prevMask = umask(S_IXUSR | S_IRWXO | S_IRWXG);
+  const int fd = mkstemp(fileName);
+  umask(prevMask);
+  if (fd == -1) {
+    NS_WARNING(nsPrintfCString("OpenVR - Creating temp file failed: %s",
+                               strerror(errno))
+                   .get());
+    return false;
+  }
+  close(fd);
+
+  aPath.Assign(fileName);
+  return true;
+}
+#endif  // defined(XP_WIN)
+
+OpenVRSession::OpenVRSession()
+    : mVRSystem(nullptr),
+      mVRChaperone(nullptr),
+      mVRCompositor(nullptr),
+      mHapticPulseRemaining{},
+      mHapticPulseIntensity{},
+      mIsWindowsMR(false),
+      mControllerHapticStateMutex(
+          "OpenVRSession::mControllerHapticStateMutex") {
+  std::fill_n(mControllerDeviceIndex, kVRControllerMaxCount, OpenVRHand::None);
+}
+
+OpenVRSession::~OpenVRSession() {
+  mActionsetFirefox = ::vr::k_ulInvalidActionSetHandle;
+  Shutdown();
+}
+
+bool OpenVRSession::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_openvr_enabled()) {
+    return false;
+  }
+  if (mVRSystem != nullptr) {
+    // Already initialized
+    return true;
+  }
+  if (!::vr::VR_IsRuntimeInstalled()) {
+    return false;
+  }
+  if (aDetectRuntimesOnly) {
+    aSystemState.displayState.capabilityFlags |=
+        VRDisplayCapabilityFlags::Cap_ImmersiveVR;
+    return false;
+  }
+  if (!::vr::VR_IsHmdPresent()) {
+    return false;
+  }
+
+  ::vr::HmdError err;
+
+  ::vr::VR_Init(&err, ::vr::EVRApplicationType::VRApplication_Scene);
+  if (err) {
+    return false;
+  }
+
+  mVRSystem = (::vr::IVRSystem*)::vr::VR_GetGenericInterface(
+      ::vr::IVRSystem_Version, &err);
+  if (err || !mVRSystem) {
+    Shutdown();
+    return false;
+  }
+  mVRChaperone = (::vr::IVRChaperone*)::vr::VR_GetGenericInterface(
+      ::vr::IVRChaperone_Version, &err);
+  if (err || !mVRChaperone) {
+    Shutdown();
+    return false;
+  }
+  mVRCompositor = (::vr::IVRCompositor*)::vr::VR_GetGenericInterface(
+      ::vr::IVRCompositor_Version, &err);
+  if (err || !mVRCompositor) {
+    Shutdown();
+    return false;
+  }
+
+#if defined(XP_WIN)
+  if (!CreateD3DObjects()) {
+    Shutdown();
+    return false;
+  }
+
+#endif
+
+  // Configure coordinate system
+  mVRCompositor->SetTrackingSpace(::vr::TrackingUniverseSeated);
+
+  if (!InitState(aSystemState)) {
+    Shutdown();
+    return false;
+  }
+  if (!SetupContollerActions()) {
+    return false;
+  }
+
+  // Succeeded
+  return true;
+}
+
+// "actions": [] Action paths must take the form: "/actions/<action
+// set>/in|out/<action>"
+#define CreateControllerAction(hand, name, type) \
+  ControllerAction("/actions/firefox/in/" #hand "Hand_" #name, #type)
+#define CreateControllerOutAction(hand, name, type) \
+  ControllerAction("/actions/firefox/out/" #hand "Hand_" #name, #type)
+
+bool OpenVRSession::SetupContollerActions() {
+  if (!vr::VRInput()) {
+    NS_WARNING("OpenVR - vr::VRInput() is null.");
+    return false;
+  }
+
+  // Check if this device binding file has been created.
+  // If it didn't exist yet, create a new temp file.
+  nsCString controllerAction;
+  nsCString viveManifest;
+  nsCString WMRManifest;
+  nsCString knucklesManifest;
+  nsCString cosmosManifest;
+
+  // Getting / Generating manifest file paths.
+  if (StaticPrefs::dom_vr_process_enabled_AtStartup()) {
+    VRParent* vrParent = VRProcessChild::GetVRParent();
+    nsCString output;
+
+    if (vrParent->GetOpenVRControllerActionPath(&output)) {
+      controllerAction = output;
+    }
+
+    if (vrParent->GetOpenVRControllerManifestPath(VRControllerType::HTCVive,
+                                                  &output)) {
+      viveManifest = output;
+    }
+    if (!viveManifest.Length() || !FileIsExisting(viveManifest)) {
+      if (!GenerateTempFileName(viveManifest)) {
+        return false;
+      }
+      OpenVRViveBinding viveBinding;
+      std::ofstream viveBindingFile(viveManifest.BeginReading());
+      if (viveBindingFile.is_open()) {
+        viveBindingFile << viveBinding.binding;
+        viveBindingFile.close();
+      }
+    }
+
+#if defined(XP_WIN)
+    if (vrParent->GetOpenVRControllerManifestPath(VRControllerType::MSMR,
+                                                  &output)) {
+      WMRManifest = output;
+    }
+    if (!WMRManifest.Length() || !FileIsExisting(WMRManifest)) {
+      if (!GenerateTempFileName(WMRManifest)) {
+        return false;
+      }
+      OpenVRWMRBinding WMRBinding;
+      std::ofstream WMRBindingFile(WMRManifest.BeginReading());
+      if (WMRBindingFile.is_open()) {
+        WMRBindingFile << WMRBinding.binding;
+        WMRBindingFile.close();
+      }
+    }
+#endif
+    if (vrParent->GetOpenVRControllerManifestPath(VRControllerType::ValveIndex,
+                                                  &output)) {
+      knucklesManifest = output;
+    }
+    if (!knucklesManifest.Length() || !FileIsExisting(knucklesManifest)) {
+      if (!GenerateTempFileName(knucklesManifest)) {
+        return false;
+      }
+      OpenVRKnucklesBinding knucklesBinding;
+      std::ofstream knucklesBindingFile(knucklesManifest.BeginReading());
+      if (knucklesBindingFile.is_open()) {
+        knucklesBindingFile << knucklesBinding.binding;
+        knucklesBindingFile.close();
+      }
+    }
+    if (vrParent->GetOpenVRControllerManifestPath(
+            VRControllerType::HTCViveCosmos, &output)) {
+      cosmosManifest = output;
+    }
+    if (!cosmosManifest.Length() || !FileIsExisting(cosmosManifest)) {
+      if (!GenerateTempFileName(cosmosManifest)) {
+        return false;
+      }
+      OpenVRCosmosBinding cosmosBinding;
+      std::ofstream cosmosBindingFile(cosmosManifest.BeginReading());
+      if (cosmosBindingFile.is_open()) {
+        cosmosBindingFile << cosmosBinding.binding;
+        cosmosBindingFile.close();
+      }
+    }
+  } else {
+    // Without using VR process
+    if (!sControllerActionFile) {
+      sControllerActionFile = ControllerManifestFile::CreateManifest();
+      NS_DispatchToMainThread(NS_NewRunnableFunction(
+          "ClearOnShutdown ControllerManifestFile",
+          []() { ClearOnShutdown(&sControllerActionFile); }));
+    }
+    controllerAction = sControllerActionFile->GetFileName();
+
+    if (!sViveBindingFile) {
+      sViveBindingFile = ControllerManifestFile::CreateManifest();
+      NS_DispatchToMainThread(
+          NS_NewRunnableFunction("ClearOnShutdown ControllerManifestFile",
+                                 []() { ClearOnShutdown(&sViveBindingFile); }));
+    }
+    if (!sViveBindingFile->IsExisting()) {
+      nsCString viveBindingPath;
+      if (!GenerateTempFileName(viveBindingPath)) {
+        return false;
+      }
+      sViveBindingFile->SetFileName(viveBindingPath.BeginReading());
+      OpenVRViveBinding viveBinding;
+      std::ofstream viveBindingFile(sViveBindingFile->GetFileName());
+      if (viveBindingFile.is_open()) {
+        viveBindingFile << viveBinding.binding;
+        viveBindingFile.close();
+      }
+    }
+    viveManifest = sViveBindingFile->GetFileName();
+
+    if (!sKnucklesBindingFile) {
+      sKnucklesBindingFile = ControllerManifestFile::CreateManifest();
+      NS_DispatchToMainThread(NS_NewRunnableFunction(
+          "ClearOnShutdown ControllerManifestFile",
+          []() { ClearOnShutdown(&sKnucklesBindingFile); }));
+    }
+    if (!sKnucklesBindingFile->IsExisting()) {
+      nsCString knucklesBindingPath;
+      if (!GenerateTempFileName(knucklesBindingPath)) {
+        return false;
+      }
+      sKnucklesBindingFile->SetFileName(knucklesBindingPath.BeginReading());
+      OpenVRKnucklesBinding knucklesBinding;
+      std::ofstream knucklesBindingFile(sKnucklesBindingFile->GetFileName());
+      if (knucklesBindingFile.is_open()) {
+        knucklesBindingFile << knucklesBinding.binding;
+        knucklesBindingFile.close();
+      }
+    }
+    knucklesManifest = sKnucklesBindingFile->GetFileName();
+
+    if (!sCosmosBindingFile) {
+      sCosmosBindingFile = ControllerManifestFile::CreateManifest();
+      NS_DispatchToMainThread(NS_NewRunnableFunction(
+          "ClearOnShutdown ControllerManifestFile",
+          []() { ClearOnShutdown(&sCosmosBindingFile); }));
+    }
+    if (!sCosmosBindingFile->IsExisting()) {
+      nsCString cosmosBindingPath;
+      if (!GenerateTempFileName(cosmosBindingPath)) {
+        return false;
+      }
+      sCosmosBindingFile->SetFileName(cosmosBindingPath.BeginReading());
+      OpenVRCosmosBinding cosmosBinding;
+      std::ofstream cosmosBindingFile(sCosmosBindingFile->GetFileName());
+      if (cosmosBindingFile.is_open()) {
+        cosmosBindingFile << cosmosBinding.binding;
+        cosmosBindingFile.close();
+      }
+    }
+    cosmosManifest = sCosmosBindingFile->GetFileName();
+#if defined(XP_WIN)
+    if (!sWMRBindingFile) {
+      sWMRBindingFile = ControllerManifestFile::CreateManifest();
+      NS_DispatchToMainThread(
+          NS_NewRunnableFunction("ClearOnShutdown ControllerManifestFile",
+                                 []() { ClearOnShutdown(&sWMRBindingFile); }));
+    }
+    if (!sWMRBindingFile->IsExisting()) {
+      nsCString WMRBindingPath;
+      if (!GenerateTempFileName(WMRBindingPath)) {
+        return false;
+      }
+      sWMRBindingFile->SetFileName(WMRBindingPath.BeginReading());
+      OpenVRWMRBinding WMRBinding;
+      std::ofstream WMRBindingFile(sWMRBindingFile->GetFileName());
+      if (WMRBindingFile.is_open()) {
+        WMRBindingFile << WMRBinding.binding;
+        WMRBindingFile.close();
+      }
+    }
+    WMRManifest = sWMRBindingFile->GetFileName();
+#endif
+  }
+  // End of Getting / Generating manifest file paths.
+
+  // Setup controller actions.
+  ControllerInfo leftContollerInfo;
+  leftContollerInfo.mActionPose = CreateControllerAction(L, pose, pose);
+  leftContollerInfo.mActionTrackpad_Analog =
+      CreateControllerAction(L, trackpad_analog, vector2);
+  leftContollerInfo.mActionTrackpad_Pressed =
+      CreateControllerAction(L, trackpad_pressed, boolean);
+  leftContollerInfo.mActionTrackpad_Touched =
+      CreateControllerAction(L, trackpad_touched, boolean);
+  leftContollerInfo.mActionTrigger_Value =
+      CreateControllerAction(L, trigger_value, vector1);
+  leftContollerInfo.mActionGrip_Pressed =
+      CreateControllerAction(L, grip_pressed, boolean);
+  leftContollerInfo.mActionGrip_Touched =
+      CreateControllerAction(L, grip_touched, boolean);
+  leftContollerInfo.mActionMenu_Pressed =
+      CreateControllerAction(L, menu_pressed, boolean);
+  leftContollerInfo.mActionMenu_Touched =
+      CreateControllerAction(L, menu_touched, boolean);
+  leftContollerInfo.mActionSystem_Pressed =
+      CreateControllerAction(L, system_pressed, boolean);
+  leftContollerInfo.mActionSystem_Touched =
+      CreateControllerAction(L, system_touched, boolean);
+  leftContollerInfo.mActionA_Pressed =
+      CreateControllerAction(L, A_pressed, boolean);
+  leftContollerInfo.mActionA_Touched =
+      CreateControllerAction(L, A_touched, boolean);
+  leftContollerInfo.mActionB_Pressed =
+      CreateControllerAction(L, B_pressed, boolean);
+  leftContollerInfo.mActionB_Touched =
+      CreateControllerAction(L, B_touched, boolean);
+  leftContollerInfo.mActionThumbstick_Analog =
+      CreateControllerAction(L, thumbstick_analog, vector2);
+  leftContollerInfo.mActionThumbstick_Pressed =
+      CreateControllerAction(L, thumbstick_pressed, boolean);
+  leftContollerInfo.mActionThumbstick_Touched =
+      CreateControllerAction(L, thumbstick_touched, boolean);
+  leftContollerInfo.mActionFingerIndex_Value =
+      CreateControllerAction(L, finger_index_value, vector1);
+  leftContollerInfo.mActionFingerMiddle_Value =
+      CreateControllerAction(L, finger_middle_value, vector1);
+  leftContollerInfo.mActionFingerRing_Value =
+      CreateControllerAction(L, finger_ring_value, vector1);
+  leftContollerInfo.mActionFingerPinky_Value =
+      CreateControllerAction(L, finger_pinky_value, vector1);
+  leftContollerInfo.mActionBumper_Pressed =
+      CreateControllerAction(L, bumper_pressed, boolean);
+  leftContollerInfo.mActionHaptic =
+      CreateControllerOutAction(L, haptic, vibration);
+
+  ControllerInfo rightContollerInfo;
+  rightContollerInfo.mActionPose = CreateControllerAction(R, pose, pose);
+  rightContollerInfo.mActionTrackpad_Analog =
+      CreateControllerAction(R, trackpad_analog, vector2);
+  rightContollerInfo.mActionTrackpad_Pressed =
+      CreateControllerAction(R, trackpad_pressed, boolean);
+  rightContollerInfo.mActionTrackpad_Touched =
+      CreateControllerAction(R, trackpad_touched, boolean);
+  rightContollerInfo.mActionTrigger_Value =
+      CreateControllerAction(R, trigger_value, vector1);
+  rightContollerInfo.mActionGrip_Pressed =
+      CreateControllerAction(R, grip_pressed, boolean);
+  rightContollerInfo.mActionGrip_Touched =
+      CreateControllerAction(R, grip_touched, boolean);
+  rightContollerInfo.mActionMenu_Pressed =
+      CreateControllerAction(R, menu_pressed, boolean);
+  rightContollerInfo.mActionMenu_Touched =
+      CreateControllerAction(R, menu_touched, boolean);
+  rightContollerInfo.mActionSystem_Pressed =
+      CreateControllerAction(R, system_pressed, boolean);
+  rightContollerInfo.mActionSystem_Touched =
+      CreateControllerAction(R, system_touched, boolean);
+  rightContollerInfo.mActionA_Pressed =
+      CreateControllerAction(R, A_pressed, boolean);
+  rightContollerInfo.mActionA_Touched =
+      CreateControllerAction(R, A_touched, boolean);
+  rightContollerInfo.mActionB_Pressed =
+      CreateControllerAction(R, B_pressed, boolean);
+  rightContollerInfo.mActionB_Touched =
+      CreateControllerAction(R, B_touched, boolean);
+  rightContollerInfo.mActionThumbstick_Analog =
+      CreateControllerAction(R, thumbstick_analog, vector2);
+  rightContollerInfo.mActionThumbstick_Pressed =
+      CreateControllerAction(R, thumbstick_pressed, boolean);
+  rightContollerInfo.mActionThumbstick_Touched =
+      CreateControllerAction(R, thumbstick_touched, boolean);
+  rightContollerInfo.mActionFingerIndex_Value =
+      CreateControllerAction(R, finger_index_value, vector1);
+  rightContollerInfo.mActionFingerMiddle_Value =
+      CreateControllerAction(R, finger_middle_value, vector1);
+  rightContollerInfo.mActionFingerRing_Value =
+      CreateControllerAction(R, finger_ring_value, vector1);
+  rightContollerInfo.mActionFingerPinky_Value =
+      CreateControllerAction(R, finger_pinky_value, vector1);
+  rightContollerInfo.mActionBumper_Pressed =
+      CreateControllerAction(R, bumper_pressed, boolean);
+  rightContollerInfo.mActionHaptic =
+      CreateControllerOutAction(R, haptic, vibration);
+
+  mControllerHand[OpenVRHand::Left] = leftContollerInfo;
+  mControllerHand[OpenVRHand::Right] = rightContollerInfo;
+
+  if (!controllerAction.Length() || !FileIsExisting(controllerAction)) {
+    if (!GenerateTempFileName(controllerAction)) {
+      return false;
+    }
+    JSONStringWriteFunc<nsCString> actionData;
+    JSONWriter actionWriter(actionData);
+    actionWriter.Start();
+
+    actionWriter.StringProperty("version",
+                                "0.1.0");  // TODO: adding a version check.
+    // "default_bindings": []
+    actionWriter.StartArrayProperty("default_bindings");
+
+    auto SetupActionWriterByControllerType = [&](const char* aType,
+                                                 const nsCString& aManifest) {
+      actionWriter.StartObjectElement();
+      actionWriter.StringProperty("controller_type", MakeStringSpan(aType));
+      actionWriter.StringProperty("binding_url", aManifest);
+      actionWriter.EndObject();
+    };
+    SetupActionWriterByControllerType("vive_controller", viveManifest);
+    SetupActionWriterByControllerType("knuckles", knucklesManifest);
+    SetupActionWriterByControllerType("vive_cosmos_controller", cosmosManifest);
+#if defined(XP_WIN)
+    SetupActionWriterByControllerType("holographic_controller", WMRManifest);
+#endif
+    actionWriter.EndArray();  // End "default_bindings": []
+
+    actionWriter.StartArrayProperty("actions");
+
+    for (auto& controller : mControllerHand) {
+      auto SetActionsToWriter = [&](const ControllerAction& aAction) {
+        actionWriter.StartObjectElement();
+        actionWriter.StringProperty("name", aAction.name);
+        actionWriter.StringProperty("type", aAction.type);
+        actionWriter.EndObject();
+      };
+
+      SetActionsToWriter(controller.mActionPose);
+      SetActionsToWriter(controller.mActionTrackpad_Analog);
+      SetActionsToWriter(controller.mActionTrackpad_Pressed);
+      SetActionsToWriter(controller.mActionTrackpad_Touched);
+      SetActionsToWriter(controller.mActionTrigger_Value);
+      SetActionsToWriter(controller.mActionGrip_Pressed);
+      SetActionsToWriter(controller.mActionGrip_Touched);
+      SetActionsToWriter(controller.mActionMenu_Pressed);
+      SetActionsToWriter(controller.mActionMenu_Touched);
+      SetActionsToWriter(controller.mActionSystem_Pressed);
+      SetActionsToWriter(controller.mActionSystem_Touched);
+      SetActionsToWriter(controller.mActionA_Pressed);
+      SetActionsToWriter(controller.mActionA_Touched);
+      SetActionsToWriter(controller.mActionB_Pressed);
+      SetActionsToWriter(controller.mActionB_Touched);
+      SetActionsToWriter(controller.mActionThumbstick_Analog);
+      SetActionsToWriter(controller.mActionThumbstick_Pressed);
+      SetActionsToWriter(controller.mActionThumbstick_Touched);
+      SetActionsToWriter(controller.mActionFingerIndex_Value);
+      SetActionsToWriter(controller.mActionFingerMiddle_Value);
+      SetActionsToWriter(controller.mActionFingerRing_Value);
+      SetActionsToWriter(controller.mActionFingerPinky_Value);
+      SetActionsToWriter(controller.mActionBumper_Pressed);
+      SetActionsToWriter(controller.mActionHaptic);
+    }
+    actionWriter.EndArray();  // End "actions": []
+    actionWriter.End();
+
+    std::ofstream actionfile(controllerAction.BeginReading());
+    if (actionfile.is_open()) {
+      actionfile << actionData.StringCRef().get();
+      actionfile.close();
+    }
+  }
+
+  vr::EVRInputError err =
+      vr::VRInput()->SetActionManifestPath(controllerAction.BeginReading());
+  if (err != vr::VRInputError_None) {
+    NS_WARNING("OpenVR - SetActionManifestPath failed.");
+    return false;
+  }
+  // End of setup controller actions.
+
+  // Notify the parent process these manifest files are already been recorded.
+  if (StaticPrefs::dom_vr_process_enabled_AtStartup()) {
+    NS_DispatchToMainThread(NS_NewRunnableFunction(
+        "SendOpenVRControllerActionPathToParent",
+        [controllerAction, viveManifest, WMRManifest, knucklesManifest,
+         cosmosManifest]() {
+          VRParent* vrParent = VRProcessChild::GetVRParent();
+          Unused << vrParent->SendOpenVRControllerActionPathToParent(
+              controllerAction);
+          Unused << vrParent->SendOpenVRControllerManifestPathToParent(
+              VRControllerType::HTCVive, viveManifest);
+          Unused << vrParent->SendOpenVRControllerManifestPathToParent(
+              VRControllerType::MSMR, WMRManifest);
+          Unused << vrParent->SendOpenVRControllerManifestPathToParent(
+              VRControllerType::ValveIndex, knucklesManifest);
+          Unused << vrParent->SendOpenVRControllerManifestPathToParent(
+              VRControllerType::HTCViveCosmos, cosmosManifest);
+        }));
+  } else {
+    sControllerActionFile->SetFileName(controllerAction.BeginReading());
+  }
+
+  return true;
+}
+
+#if defined(XP_WIN)
+bool OpenVRSession::CreateD3DObjects() {
+  RefPtr<ID3D11Device> device = gfx::DeviceManagerDx::Get()->GetVRDevice();
+  if (!device) {
+    return false;
+  }
+  if (!CreateD3DContext(device)) {
+    return false;
+  }
+  return true;
+}
+#endif
+
+void OpenVRSession::Shutdown() {
+  StopHapticTimer();
+  StopHapticThread();
+  if (mVRSystem || mVRCompositor || mVRChaperone) {
+    ::vr::VR_Shutdown();
+    mVRCompositor = nullptr;
+    mVRChaperone = nullptr;
+    mVRSystem = nullptr;
+  }
+}
+
+bool OpenVRSession::InitState(VRSystemState& aSystemState) {
+  VRDisplayState& state = aSystemState.displayState;
+  strncpy(state.displayName, "OpenVR HMD", kVRDisplayNameMaxLen);
+  state.eightCC = GFX_VR_EIGHTCC('O', 'p', 'e', 'n', 'V', 'R', ' ', ' ');
+  state.isConnected =
+      mVRSystem->IsTrackedDeviceConnected(::vr::k_unTrackedDeviceIndex_Hmd);
+  state.isMounted = false;
+  state.capabilityFlags =
+      (VRDisplayCapabilityFlags)((int)VRDisplayCapabilityFlags::Cap_None |
+                                 (int)
+                                     VRDisplayCapabilityFlags::Cap_Orientation |
+                                 (int)VRDisplayCapabilityFlags::Cap_Position |
+                                 (int)VRDisplayCapabilityFlags::Cap_External |
+                                 (int)VRDisplayCapabilityFlags::Cap_Present |
+                                 (int)VRDisplayCapabilityFlags::
+                                     Cap_StageParameters |
+                                 (int)
+                                     VRDisplayCapabilityFlags::Cap_ImmersiveVR);
+  state.blendMode = VRDisplayBlendMode::Opaque;
+  state.reportsDroppedFrames = true;
+
+  ::vr::ETrackedPropertyError err;
+  bool bHasProximitySensor = mVRSystem->GetBoolTrackedDeviceProperty(
+      ::vr::k_unTrackedDeviceIndex_Hmd, ::vr::Prop_ContainsProximitySensor_Bool,
+      &err);
+  if (err == ::vr::TrackedProp_Success && bHasProximitySensor) {
+    state.capabilityFlags =
+        (VRDisplayCapabilityFlags)((int)state.capabilityFlags |
+                                   (int)VRDisplayCapabilityFlags::
+                                       Cap_MountDetection);
+  }
+
+  uint32_t w, h;
+  mVRSystem->GetRecommendedRenderTargetSize(&w, &h);
+  state.eyeResolution.width = w;
+  state.eyeResolution.height = 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 OpenVRSession::UpdateStageParameters(VRDisplayState& aState) {
+  float sizeX = 0.0f;
+  float sizeZ = 0.0f;
+  if (mVRChaperone->GetPlayAreaSize(&sizeX, &sizeZ)) {
+    ::vr::HmdMatrix34_t t =
+        mVRSystem->GetSeatedZeroPoseToStandingAbsoluteTrackingPose();
+    aState.stageSize.width = sizeX;
+    aState.stageSize.height = sizeZ;
+
+    aState.sittingToStandingTransform[0] = t.m[0][0];
+    aState.sittingToStandingTransform[1] = t.m[1][0];
+    aState.sittingToStandingTransform[2] = t.m[2][0];
+    aState.sittingToStandingTransform[3] = 0.0f;
+
+    aState.sittingToStandingTransform[4] = t.m[0][1];
+    aState.sittingToStandingTransform[5] = t.m[1][1];
+    aState.sittingToStandingTransform[6] = t.m[2][1];
+    aState.sittingToStandingTransform[7] = 0.0f;
+
+    aState.sittingToStandingTransform[8] = t.m[0][2];
+    aState.sittingToStandingTransform[9] = t.m[1][2];
+    aState.sittingToStandingTransform[10] = t.m[2][2];
+    aState.sittingToStandingTransform[11] = 0.0f;
+
+    aState.sittingToStandingTransform[12] = t.m[0][3];
+    aState.sittingToStandingTransform[13] = t.m[1][3];
+    aState.sittingToStandingTransform[14] = t.m[2][3];
+    aState.sittingToStandingTransform[15] = 1.0f;
+  } else {
+    // If we fail, fall back to reasonable defaults.
+    // 1m x 1m space, 0.75m high in seated position
+    aState.stageSize.width = 1.0f;
+    aState.stageSize.height = 1.0f;
+
+    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] = 0.75f;
+    aState.sittingToStandingTransform[14] = 0.0f;
+    aState.sittingToStandingTransform[15] = 1.0f;
+  }
+}
+
+void OpenVRSession::UpdateEyeParameters(VRSystemState& aState) {
+  // 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 < 2; ++eye) {
+    ::vr::HmdMatrix34_t eyeToHead =
+        mVRSystem->GetEyeToHeadTransform(static_cast<::vr::Hmd_Eye>(eye));
+    aState.displayState.eyeTranslation[eye].x = eyeToHead.m[0][3];
+    aState.displayState.eyeTranslation[eye].y = eyeToHead.m[1][3];
+    aState.displayState.eyeTranslation[eye].z = eyeToHead.m[2][3];
+
+    float left, right, up, down;
+    mVRSystem->GetProjectionRaw(static_cast<::vr::Hmd_Eye>(eye), &left, &right,
+                                &up, &down);
+    aState.displayState.eyeFOV[eye].upDegrees = atan(-up) * 180.0 / M_PI;
+    aState.displayState.eyeFOV[eye].rightDegrees = atan(right) * 180.0 / M_PI;
+    aState.displayState.eyeFOV[eye].downDegrees = atan(down) * 180.0 / M_PI;
+    aState.displayState.eyeFOV[eye].leftDegrees = atan(-left) * 180.0 / M_PI;
+
+    Matrix4x4 pose;
+    // NOTE! eyeToHead.m 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.
+    memcpy(&pose._11, &eyeToHead.m, sizeof(eyeToHead.m));
+    pose.Transpose();
+    pose.Invert();
+    headToEyeTransforms[eye] = pose;
+  }
+  aState.sensorState.CalcViewMatrices(headToEyeTransforms);
+}
+
+void OpenVRSession::UpdateHeadsetPose(VRSystemState& aState) {
+  const uint32_t posesSize = ::vr::k_unTrackedDeviceIndex_Hmd + 1;
+  ::vr::TrackedDevicePose_t poses[posesSize];
+  // Note: We *must* call WaitGetPoses in order for any rendering to happen at
+  // all.
+  mVRCompositor->WaitGetPoses(poses, posesSize, nullptr, 0);
+
+  ::vr::Compositor_FrameTiming timing;
+  timing.m_nSize = sizeof(::vr::Compositor_FrameTiming);
+  if (mVRCompositor->GetFrameTiming(&timing)) {
+    aState.sensorState.timestamp = timing.m_flSystemTimeInSeconds;
+  } else {
+    // This should not happen, but log it just in case
+    fprintf(stderr, "OpenVR - IVRCompositor::GetFrameTiming failed");
+  }
+
+  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(pose.mDeviceToAbsoluteTracking));
+    m.Transpose();
+
+    gfx::Quaternion rot;
+    rot.SetFromRotationMatrix(m);
+
+    aState.sensorState.flags =
+        (VRDisplayCapabilityFlags)((int)aState.sensorState.flags |
+                                   (int)VRDisplayCapabilityFlags::
+                                       Cap_Orientation);
+    aState.sensorState.pose.orientation[0] = rot.x;
+    aState.sensorState.pose.orientation[1] = rot.y;
+    aState.sensorState.pose.orientation[2] = rot.z;
+    aState.sensorState.pose.orientation[3] = rot.w;
+    aState.sensorState.pose.angularVelocity[0] = pose.vAngularVelocity.v[0];
+    aState.sensorState.pose.angularVelocity[1] = pose.vAngularVelocity.v[1];
+    aState.sensorState.pose.angularVelocity[2] = pose.vAngularVelocity.v[2];
+
+    aState.sensorState.flags =
+        (VRDisplayCapabilityFlags)((int)aState.sensorState.flags |
+                                   (int)VRDisplayCapabilityFlags::Cap_Position);
+    aState.sensorState.pose.position[0] = m._41;
+    aState.sensorState.pose.position[1] = m._42;
+    aState.sensorState.pose.position[2] = m._43;
+    aState.sensorState.pose.linearVelocity[0] = pose.vVelocity.v[0];
+    aState.sensorState.pose.linearVelocity[1] = pose.vVelocity.v[1];
+    aState.sensorState.pose.linearVelocity[2] = pose.vVelocity.v[2];
+  }
+}
+
+void OpenVRSession::EnumerateControllers(VRSystemState& aState) {
+  MOZ_ASSERT(mVRSystem);
+
+  MutexAutoLock lock(mControllerHapticStateMutex);
+
+  bool controllerPresent[kVRControllerMaxCount] = {false};
+  uint32_t stateIndex = 0;
+  mActionsetFirefox = vr::k_ulInvalidActionSetHandle;
+  VRControllerType controllerType = VRControllerType::_empty;
+
+  if (vr::VRInput()->GetActionSetHandle(
+          "/actions/firefox", &mActionsetFirefox) != vr::VRInputError_None) {
+    return;
+  }
+
+  for (int8_t handIndex = 0; handIndex < OpenVRHand::Total; ++handIndex) {
+    if (handIndex == OpenVRHand::Left) {
+      if (vr::VRInput()->GetInputSourceHandle(
+              "/user/hand/left", &mControllerHand[OpenVRHand::Left].mSource) !=
+          vr::VRInputError_None) {
+        continue;
+      }
+    } else if (handIndex == OpenVRHand::Right) {
+      if (vr::VRInput()->GetInputSourceHandle(
+              "/user/hand/right",
+              &mControllerHand[OpenVRHand::Right].mSource) !=
+          vr::VRInputError_None) {
+        continue;
+      }
+    } else {
+      MOZ_ASSERT(false, "Unknown OpenVR hand type.");
+    }
+
+    vr::InputOriginInfo_t originInfo;
+    if (vr::VRInput()->GetOriginTrackedDeviceInfo(
+            mControllerHand[handIndex].mSource, &originInfo,
+            sizeof(originInfo)) == vr::VRInputError_None &&
+        originInfo.trackedDeviceIndex != vr::k_unTrackedDeviceIndexInvalid &&
+        mVRSystem->IsTrackedDeviceConnected(originInfo.trackedDeviceIndex)) {
+      const ::vr::ETrackedDeviceClass deviceType =
+          mVRSystem->GetTrackedDeviceClass(originInfo.trackedDeviceIndex);
+      if (deviceType != ::vr::TrackedDeviceClass_Controller &&
+          deviceType != ::vr::TrackedDeviceClass_GenericTracker) {
+        continue;
+      }
+
+      if (mControllerDeviceIndex[stateIndex] != handIndex) {
+        VRControllerState& controllerState = aState.controllerState[stateIndex];
+
+        // Get controllers' action handles.
+        auto SetActionsToWriter = [&](ControllerAction& aAction) {
+          vr::VRInput()->GetActionHandle(aAction.name.BeginReading(),
+                                         &aAction.handle);
+        };
+
+        SetActionsToWriter(mControllerHand[handIndex].mActionPose);
+        SetActionsToWriter(mControllerHand[handIndex].mActionHaptic);
+        SetActionsToWriter(mControllerHand[handIndex].mActionTrackpad_Analog);
+        SetActionsToWriter(mControllerHand[handIndex].mActionTrackpad_Pressed);
+        SetActionsToWriter(mControllerHand[handIndex].mActionTrackpad_Touched);
+        SetActionsToWriter(mControllerHand[handIndex].mActionTrigger_Value);
+        SetActionsToWriter(mControllerHand[handIndex].mActionGrip_Pressed);
+        SetActionsToWriter(mControllerHand[handIndex].mActionGrip_Touched);
+        SetActionsToWriter(mControllerHand[handIndex].mActionMenu_Pressed);
+        SetActionsToWriter(mControllerHand[handIndex].mActionMenu_Touched);
+        SetActionsToWriter(mControllerHand[handIndex].mActionSystem_Pressed);
+        SetActionsToWriter(mControllerHand[handIndex].mActionSystem_Touched);
+        SetActionsToWriter(mControllerHand[handIndex].mActionA_Pressed);
+        SetActionsToWriter(mControllerHand[handIndex].mActionA_Touched);
+        SetActionsToWriter(mControllerHand[handIndex].mActionB_Pressed);
+        SetActionsToWriter(mControllerHand[handIndex].mActionB_Touched);
+        SetActionsToWriter(mControllerHand[handIndex].mActionThumbstick_Analog);
+        SetActionsToWriter(
+            mControllerHand[handIndex].mActionThumbstick_Pressed);
+        SetActionsToWriter(
+            mControllerHand[handIndex].mActionThumbstick_Touched);
+        SetActionsToWriter(mControllerHand[handIndex].mActionFingerIndex_Value);
+        SetActionsToWriter(
+            mControllerHand[handIndex].mActionFingerMiddle_Value);
+        SetActionsToWriter(mControllerHand[handIndex].mActionFingerRing_Value);
+        SetActionsToWriter(mControllerHand[handIndex].mActionFingerPinky_Value);
+        SetActionsToWriter(mControllerHand[handIndex].mActionBumper_Pressed);
+
+        nsCString deviceId;
+        VRControllerType contrlType = VRControllerType::_empty;
+        GetControllerDeviceId(deviceType, originInfo.trackedDeviceIndex,
+                              deviceId, contrlType);
+        // Controllers should be the same type with one VR display.
+        MOZ_ASSERT(controllerType == contrlType ||
+                   controllerType == VRControllerType::_empty);
+        controllerType = contrlType;
+        strncpy(controllerState.controllerName, deviceId.BeginReading(),
+                kVRControllerNameMaxLen);
+        controllerState.numHaptics = kNumOpenVRHaptics;
+        controllerState.targetRayMode = gfx::TargetRayMode::TrackedPointer;
+        controllerState.type = controllerType;
+      }
+      controllerPresent[stateIndex] = true;
+      mControllerDeviceIndex[stateIndex] = static_cast<OpenVRHand>(handIndex);
+      ++stateIndex;
+    }
+  }
+
+  // Clear out entries for disconnected controllers
+  for (uint32_t stateIndex = 0; stateIndex < kVRControllerMaxCount;
+       stateIndex++) {
+    if (!controllerPresent[stateIndex] &&
+        mControllerDeviceIndex[stateIndex] != OpenVRHand::None) {
+      mControllerDeviceIndex[stateIndex] = OpenVRHand::None;
+      memset(&aState.controllerState[stateIndex], 0, sizeof(VRControllerState));
+    }
+  }
+
+  // Create controller mapper
+  if (controllerType != VRControllerType::_empty) {
+    switch (controllerType) {
+      case VRControllerType::HTCVive:
+        mControllerMapper = MakeUnique<OpenVRViveMapper>();
+        break;
+      case VRControllerType::HTCViveCosmos:
+        mControllerMapper = MakeUnique<OpenVRCosmosMapper>();
+        break;
+#if defined(XP_WIN)
+      case VRControllerType::MSMR:
+        mControllerMapper = MakeUnique<OpenVRWMRMapper>();
+        break;
+#endif
+      case VRControllerType::ValveIndex:
+        mControllerMapper = MakeUnique<OpenVRKnucklesMapper>();
+        break;
+      default:
+        mControllerMapper = MakeUnique<OpenVRDefaultMapper>();
+        NS_WARNING("Undefined controller type");
+        break;
+    }
+  }
+}
+
+void OpenVRSession::UpdateControllerButtons(VRSystemState& aState) {
+  MOZ_ASSERT(mVRSystem);
+
+  for (uint32_t stateIndex = 0; stateIndex < kVRControllerMaxCount;
+       ++stateIndex) {
+    const OpenVRHand role = mControllerDeviceIndex[stateIndex];
+    if (role == OpenVRHand::None) {
+      continue;
+    }
+    VRControllerState& controllerState = aState.controllerState[stateIndex];
+    controllerState.hand = GetControllerHandFromControllerRole(role);
+    mControllerMapper->UpdateButtons(controllerState, mControllerHand[role]);
+    SetControllerSelectionAndSqueezeFrameId(
+        controllerState, aState.displayState.lastSubmittedFrameId);
+  }
+}
+
+void OpenVRSession::UpdateControllerPoses(VRSystemState& aState) {
+  MOZ_ASSERT(mVRSystem);
+
+  for (uint32_t stateIndex = 0; stateIndex < kVRControllerMaxCount;
+       ++stateIndex) {
+    const OpenVRHand role = mControllerDeviceIndex[stateIndex];
+    if (role == OpenVRHand::None) {
+      continue;
+    }
+    VRControllerState& controllerState = aState.controllerState[stateIndex];
+    vr::InputPoseActionData_t poseData;
+    if (vr::VRInput()->GetPoseActionDataRelativeToNow(
+            mControllerHand[role].mActionPose.handle,
+            vr::TrackingUniverseSeated, 0, &poseData, sizeof(poseData),
+            vr::k_ulInvalidInputValueHandle) != vr::VRInputError_None ||
+        !poseData.bActive || !poseData.pose.bPoseIsValid) {
+      controllerState.isOrientationValid = false;
+      controllerState.isPositionValid = false;
+    } else {
+      const ::vr::TrackedDevicePose_t& pose = poseData.pose;
+      if (pose.bDeviceIsConnected) {
+        controllerState.flags =
+            (dom::GamepadCapabilityFlags::Cap_Orientation |
+             dom::GamepadCapabilityFlags::Cap_Position |
+             dom::GamepadCapabilityFlags::Cap_GripSpacePosition);
+      } else {
+        controllerState.flags = dom::GamepadCapabilityFlags::Cap_None;
+      }
+      if (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(pose.mDeviceToAbsoluteTracking));
+        m.Transpose();
+
+        gfx::Quaternion rot;
+        rot.SetFromRotationMatrix(m);
+
+        controllerState.pose.orientation[0] = rot.x;
+        controllerState.pose.orientation[1] = rot.y;
+        controllerState.pose.orientation[2] = rot.z;
+        controllerState.pose.orientation[3] = rot.w;
+        controllerState.pose.angularVelocity[0] = pose.vAngularVelocity.v[0];
+        controllerState.pose.angularVelocity[1] = pose.vAngularVelocity.v[1];
+        controllerState.pose.angularVelocity[2] = pose.vAngularVelocity.v[2];
+        controllerState.pose.angularAcceleration[0] = 0.0f;
+        controllerState.pose.angularAcceleration[1] = 0.0f;
+        controllerState.pose.angularAcceleration[2] = 0.0f;
+        controllerState.isOrientationValid = true;
+
+        controllerState.pose.position[0] = m._41;
+        controllerState.pose.position[1] = m._42;
+        controllerState.pose.position[2] = m._43;
+        controllerState.pose.linearVelocity[0] = pose.vVelocity.v[0];
+        controllerState.pose.linearVelocity[1] = pose.vVelocity.v[1];
+        controllerState.pose.linearVelocity[2] = pose.vVelocity.v[2];
+        controllerState.pose.linearAcceleration[0] = 0.0f;
+        controllerState.pose.linearAcceleration[1] = 0.0f;
+        controllerState.pose.linearAcceleration[2] = 0.0f;
+        controllerState.isPositionValid = true;
+
+        // Calculate its target ray space by shifting degrees in x-axis
+        // for ergonomic.
+        const float kPointerAngleDegrees = -0.698;  // 40 degrees.
+        gfx::Matrix4x4 rayMtx(m);
+        rayMtx.RotateX(kPointerAngleDegrees);
+        gfx::Quaternion rayRot;
+        rayRot.SetFromRotationMatrix(rayMtx);
+
+        controllerState.targetRayPose = controllerState.pose;
+        controllerState.targetRayPose.orientation[0] = rayRot.x;
+        controllerState.targetRayPose.orientation[1] = rayRot.y;
+        controllerState.targetRayPose.orientation[2] = rayRot.z;
+        controllerState.targetRayPose.orientation[3] = rayRot.w;
+        controllerState.targetRayPose.position[0] = rayMtx._41;
+        controllerState.targetRayPose.position[1] = rayMtx._42;
+        controllerState.targetRayPose.position[2] = rayMtx._43;
+      }
+    }
+  }
+}
+
+void OpenVRSession::GetControllerDeviceId(
+    ::vr::ETrackedDeviceClass aDeviceType,
+    ::vr::TrackedDeviceIndex_t aDeviceIndex, nsCString& aId,
+    VRControllerType& aControllerType) {
+  switch (aDeviceType) {
+    case ::vr::TrackedDeviceClass_Controller: {
+      ::vr::ETrackedPropertyError err;
+      uint32_t requiredBufferLen;
+      bool isFound = false;
+      char charBuf[128];
+      requiredBufferLen = mVRSystem->GetStringTrackedDeviceProperty(
+          aDeviceIndex, ::vr::Prop_RenderModelName_String, charBuf, 128, &err);
+      if (requiredBufferLen > 128) {
+        MOZ_CRASH("Larger than the buffer size.");
+      }
+      MOZ_ASSERT(requiredBufferLen && err == ::vr::TrackedProp_Success);
+      nsCString deviceId(charBuf);
+      if (deviceId.Find("vr_controller_vive") != kNotFound) {
+        aId.AssignLiteral("OpenVR Gamepad");
+        isFound = true;
+        aControllerType = VRControllerType::HTCVive;
+      } else if (deviceId.Find("knuckles") != kNotFound ||
+                 deviceId.Find("valve_controller_knu") != kNotFound) {
+        aId.AssignLiteral("OpenVR Knuckles");
+        isFound = true;
+        aControllerType = VRControllerType::ValveIndex;
+      } else if (deviceId.Find("vive_cosmos_controller") != kNotFound) {
+        aId.AssignLiteral("OpenVR Cosmos");
+        isFound = true;
+        aControllerType = VRControllerType::HTCViveCosmos;
+      }
+      if (!isFound) {
+        requiredBufferLen = mVRSystem->GetStringTrackedDeviceProperty(
+            aDeviceIndex, ::vr::Prop_SerialNumber_String, charBuf, 128, &err);
+        if (requiredBufferLen > 128) {
+          MOZ_CRASH("Larger than the buffer size.");
+        }
+        MOZ_ASSERT(requiredBufferLen && err == ::vr::TrackedProp_Success);
+        deviceId.Assign(charBuf);
+        if (deviceId.Find("MRSOURCE") != kNotFound) {
+          aId.AssignLiteral("Spatial Controller (Spatial Interaction Source) ");
+          mIsWindowsMR = true;
+          isFound = true;
+          aControllerType = VRControllerType::MSMR;
+        }
+      }
+      if (!isFound) {
+        aId.AssignLiteral("OpenVR Undefined");
+        aControllerType = VRControllerType::_empty;
+      }
+      break;
+    }
+    case ::vr::TrackedDeviceClass_GenericTracker: {
+      aId.AssignLiteral("OpenVR Tracker");
+      aControllerType = VRControllerType::_empty;
+      break;
+    }
+    default:
+      MOZ_ASSERT(false);
+      break;
+  }
+}
+
+void OpenVRSession::StartFrame(mozilla::gfx::VRSystemState& aSystemState) {
+  UpdateHeadsetPose(aSystemState);
+  UpdateEyeParameters(aSystemState);
+  EnumerateControllers(aSystemState);
+
+  vr::VRActiveActionSet_t actionSet = {0};
+  actionSet.ulActionSet = mActionsetFirefox;
+  vr::VRInput()->UpdateActionState(&actionSet, sizeof(actionSet), 1);
+  UpdateControllerButtons(aSystemState);
+  UpdateControllerPoses(aSystemState);
+  UpdateTelemetry(aSystemState);
+}
+
+void OpenVRSession::ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) {
+  bool isHmdPresent = ::vr::VR_IsHmdPresent();
+  if (!isHmdPresent) {
+    mShouldQuit = true;
+  }
+
+  ::vr::VREvent_t event;
+  while (mVRSystem && mVRSystem->PollNextEvent(&event, sizeof(event))) {
+    switch (event.eventType) {
+      case ::vr::VREvent_TrackedDeviceUserInteractionStarted:
+        if (event.trackedDeviceIndex == ::vr::k_unTrackedDeviceIndex_Hmd) {
+          aSystemState.displayState.isMounted = true;
+        }
+        break;
+      case ::vr::VREvent_TrackedDeviceUserInteractionEnded:
+        if (event.trackedDeviceIndex == ::vr::k_unTrackedDeviceIndex_Hmd) {
+          aSystemState.displayState.isMounted = false;
+        }
+        break;
+      case ::vr::EVREventType::VREvent_TrackedDeviceActivated:
+        if (event.trackedDeviceIndex == ::vr::k_unTrackedDeviceIndex_Hmd) {
+          aSystemState.displayState.isConnected = true;
+        }
+        break;
+      case ::vr::EVREventType::VREvent_TrackedDeviceDeactivated:
+        if (event.trackedDeviceIndex == ::vr::k_unTrackedDeviceIndex_Hmd) {
+          aSystemState.displayState.isConnected = false;
+        }
+        break;
+      case ::vr::EVREventType::VREvent_DriverRequestedQuit:
+      case ::vr::EVREventType::VREvent_Quit:
+      // When SteamVR runtime haven't been launched before viewing VR,
+      // SteamVR will send a VREvent_ProcessQuit event. It will tell the parent
+      // process to shutdown the VR process, and we need to avoid it.
+      // case ::vr::EVREventType::VREvent_ProcessQuit:
+      case ::vr::EVREventType::VREvent_QuitAcknowledged:
+        mShouldQuit = true;
+        break;
+      default:
+        // ignore
+        break;
+    }
+  }
+}
+
+#if defined(XP_WIN)
+bool OpenVRSession::SubmitFrame(
+    const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+    ID3D11Texture2D* aTexture) {
+  return SubmitFrame((void*)aTexture, ::vr::ETextureType::TextureType_DirectX,
+                     aLayer.leftEyeRect, aLayer.rightEyeRect);
+}
+#elif defined(XP_MACOSX)
+bool OpenVRSession::SubmitFrame(
+    const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+    const VRLayerTextureHandle& aTexture) {
+  return SubmitFrame(aTexture, ::vr::ETextureType::TextureType_IOSurface,
+                     aLayer.leftEyeRect, aLayer.rightEyeRect);
+}
+#endif
+
+bool OpenVRSession::SubmitFrame(const VRLayerTextureHandle& aTextureHandle,
+                                ::vr::ETextureType aTextureType,
+                                const VRLayerEyeRect& aLeftEyeRect,
+                                const VRLayerEyeRect& aRightEyeRect) {
+  ::vr::Texture_t tex;
+#if defined(XP_MACOSX)
+  // We get aTextureHandle from get_SurfaceDescriptorMacIOSurface() at
+  // VRDisplayExternal. scaleFactor and opaque are skipped because they always
+  // are 1.0 and false.
+  RefPtr<MacIOSurface> surf = MacIOSurface::LookupSurface(aTextureHandle);
+  if (!surf) {
+    NS_WARNING("OpenVRSession::SubmitFrame failed to get a MacIOSurface");
+    return false;
+  }
+
+  CFTypeRefPtr<IOSurfaceRef> ioSurface = surf->GetIOSurfaceRef();
+  tex.handle = (void*)ioSurface.get();
+#else
+  tex.handle = aTextureHandle;
+#endif
+  tex.eType = aTextureType;
+  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();
+  return true;
+}
+
+void OpenVRSession::StopPresentation() {
+  mVRCompositor->ClearLastSubmittedFrame();
+
+  ::vr::Compositor_CumulativeStats stats;
+  mVRCompositor->GetCumulativeStats(&stats,
+                                    sizeof(::vr::Compositor_CumulativeStats));
+}
+
+bool OpenVRSession::StartPresentation() { return true; }
+
+void OpenVRSession::VibrateHaptic(uint32_t aControllerIdx,
+                                  uint32_t aHapticIndex, float aIntensity,
+                                  float aDuration) {
+  MutexAutoLock lock(mControllerHapticStateMutex);
+
+  // Initilize the haptic thread when the first time to do vibration.
+  if (!mHapticThread) {
+    NS_DispatchToMainThread(NS_NewRunnableFunction(
+        "OpenVRSession::StartHapticThread", [this]() { StartHapticThread(); }));
+  }
+  if (aHapticIndex >= kNumOpenVRHaptics ||
+      aControllerIdx >= kVRControllerMaxCount) {
+    return;
+  }
+
+  const OpenVRHand role = mControllerDeviceIndex[aControllerIdx];
+  if (role == OpenVRHand::None) {
+    return;
+  }
+  mHapticPulseRemaining[aControllerIdx][aHapticIndex] = aDuration;
+  mHapticPulseIntensity[aControllerIdx][aHapticIndex] = aIntensity;
+}
+
+void OpenVRSession::StartHapticThread() {
+  MOZ_ASSERT(NS_IsMainThread());
+  if (!mHapticThread) {
+    mHapticThread = new VRThread("VR_OpenVR_Haptics"_ns);
+  }
+  mHapticThread->Start();
+  StartHapticTimer();
+}
+
+void OpenVRSession::StopHapticThread() {
+  if (mHapticThread) {
+    NS_DispatchToMainThread(NS_NewRunnableFunction(
+        "mHapticThread::Shutdown",
+        [thread = mHapticThread]() { thread->Shutdown(); }));
+    mHapticThread = nullptr;
+  }
+}
+
+void OpenVRSession::StartHapticTimer() {
+  if (!mHapticTimer && mHapticThread) {
+    mLastHapticUpdate = TimeStamp();
+    mHapticTimer = NS_NewTimer();
+    nsCOMPtr<nsIThread> thread = mHapticThread->GetThread();
+    mHapticTimer->SetTarget(thread);
+    mHapticTimer->InitWithNamedFuncCallback(
+        HapticTimerCallback, this, kVRHapticUpdateInterval,
+        nsITimer::TYPE_REPEATING_PRECISE_CAN_SKIP,
+        "OpenVRSession::HapticTimerCallback");
+  }
+}
+
+void OpenVRSession::StopHapticTimer() {
+  if (mHapticTimer) {
+    mHapticTimer->Cancel();
+    mHapticTimer = nullptr;
+  }
+}
+
+/*static*/
+void OpenVRSession::HapticTimerCallback(nsITimer* aTimer, void* aClosure) {
+  /**
+   * It is safe to use the pointer passed in aClosure to reference the
+   * OpenVRSession object as the timer is canceled in OpenVRSession::Shutdown,
+   * which is called by the OpenVRSession destructor, guaranteeing
+   * that this function runs if and only if the VRManager object is valid.
+   */
+  OpenVRSession* self = static_cast<OpenVRSession*>(aClosure);
+  MOZ_ASSERT(self);
+  self->UpdateHaptics();
+}
+
+void OpenVRSession::UpdateHaptics() {
+  MOZ_ASSERT(mHapticThread->GetThread() == NS_GetCurrentThread());
+  MOZ_ASSERT(mVRSystem);
+
+  MutexAutoLock lock(mControllerHapticStateMutex);
+
+  TimeStamp now = TimeStamp::Now();
+  if (mLastHapticUpdate.IsNull()) {
+    mLastHapticUpdate = now;
+    return;
+  }
+  float deltaTime = (float)(now - mLastHapticUpdate).ToSeconds();
+  mLastHapticUpdate = now;
+
+  for (uint32_t stateIndex = 0; stateIndex < kVRControllerMaxCount;
+       ++stateIndex) {
+    const OpenVRHand role = mControllerDeviceIndex[stateIndex];
+    if (role == OpenVRHand::None) {
+      continue;
+    }
+    for (uint32_t hapticIdx = 0; hapticIdx < kNumOpenVRHaptics; hapticIdx++) {
+      float intensity = mHapticPulseIntensity[stateIndex][hapticIdx];
+      float duration = mHapticPulseRemaining[stateIndex][hapticIdx];
+      if (duration <= 0.0f || intensity <= 0.0f) {
+        continue;
+      }
+      vr::VRInput()->TriggerHapticVibrationAction(
+          mControllerHand[role].mActionHaptic.handle, 0.0f, deltaTime, 4.0f,
+          intensity > 1.0f ? 1.0f : intensity, vr::k_ulInvalidInputValueHandle);
+
+      duration -= deltaTime;
+      if (duration < 0.0f) {
+        duration = 0.0f;
+      }
+      mHapticPulseRemaining[stateIndex][hapticIdx] = duration;
+    }
+  }
+}
+
+void OpenVRSession::StopVibrateHaptic(uint32_t aControllerIdx) {
+  MutexAutoLock lock(mControllerHapticStateMutex);
+  if (aControllerIdx >= kVRControllerMaxCount) {
+    return;
+  }
+  for (int iHaptic = 0; iHaptic < kNumOpenVRHaptics; iHaptic++) {
+    mHapticPulseRemaining[aControllerIdx][iHaptic] = 0.0f;
+  }
+}
+
+void OpenVRSession::StopAllHaptics() {
+  MutexAutoLock lock(mControllerHapticStateMutex);
+  for (auto& controller : mHapticPulseRemaining) {
+    for (auto& haptic : controller) {
+      haptic = 0.0f;
+    }
+  }
+}
+
+void OpenVRSession::UpdateTelemetry(VRSystemState& aSystemState) {
+  ::vr::Compositor_CumulativeStats stats;
+  mVRCompositor->GetCumulativeStats(&stats,
+                                    sizeof(::vr::Compositor_CumulativeStats));
+  aSystemState.displayState.droppedFrameCount = stats.m_nNumReprojectedFrames;
+}
+
+}  // namespace mozilla::gfx
diff --git a/gfx/vr/service/OpenVRSession.h b/gfx/vr/service/OpenVRSession.h
new file mode 100644
index 0000000000..dc58b5d7fd
--- /dev/null
+++ b/gfx/vr/service/OpenVRSession.h
@@ -0,0 +1,112 @@
+/* -*- 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 GFX_VR_SERVICE_OPENVRSESSION_H
+#define GFX_VR_SERVICE_OPENVRSESSION_H
+
+#include "VRSession.h"
+
+#include "openvr.h"
+#include "mozilla/TimeStamp.h"
+#include "moz_external_vr.h"
+#include "OpenVRControllerMapper.h"
+
+#if defined(XP_WIN)
+#  include <d3d11_1.h>
+#endif
+class nsITimer;
+
+namespace mozilla {
+namespace gfx {
+class VRThread;
+class OpenVRControllerMapper;
+
+static const int kNumOpenVRHaptics = 1;
+
+enum OpenVRHand : int8_t {
+  Left = 0,
+  Right = 1,
+  Total = 2,
+
+  None = -1
+};
+
+class OpenVRSession : public VRSession {
+ public:
+  OpenVRSession();
+  virtual ~OpenVRSession();
+
+  bool Initialize(mozilla::gfx::VRSystemState& aSystemState,
+                  bool aDetectRuntimesOnly) override;
+  void Shutdown() override;
+  void ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) override;
+  void StartFrame(mozilla::gfx::VRSystemState& aSystemState) override;
+  bool StartPresentation() override;
+  void StopPresentation() override;
+  void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
+                     float aIntensity, float aDuration) override;
+  void StopVibrateHaptic(uint32_t aControllerIdx) override;
+  void StopAllHaptics() override;
+
+ protected:
+#if defined(XP_WIN)
+  bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                   ID3D11Texture2D* aTexture) override;
+#elif defined(XP_MACOSX)
+  bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                   const VRLayerTextureHandle& aTexture) override;
+#endif
+
+ private:
+  // OpenVR State
+  ::vr::IVRSystem* mVRSystem = nullptr;
+  ::vr::IVRChaperone* mVRChaperone = nullptr;
+  ::vr::IVRCompositor* mVRCompositor = nullptr;
+  ::vr::VRActionSetHandle_t mActionsetFirefox = vr::k_ulInvalidActionSetHandle;
+  OpenVRHand mControllerDeviceIndex[kVRControllerMaxCount];
+  ControllerInfo mControllerHand[OpenVRHand::Total];
+  float mHapticPulseRemaining[kVRControllerMaxCount][kNumOpenVRHaptics];
+  float mHapticPulseIntensity[kVRControllerMaxCount][kNumOpenVRHaptics];
+  bool mIsWindowsMR;
+  TimeStamp mLastHapticUpdate;
+
+  static void HapticTimerCallback(nsITimer* aTimer, void* aClosure);
+  bool InitState(mozilla::gfx::VRSystemState& aSystemState);
+  void UpdateStageParameters(mozilla::gfx::VRDisplayState& aState);
+  void UpdateEyeParameters(mozilla::gfx::VRSystemState& aState);
+  void UpdateHeadsetPose(mozilla::gfx::VRSystemState& aState);
+  void EnumerateControllers(VRSystemState& aState);
+  void UpdateControllerPoses(VRSystemState& aState);
+  void UpdateControllerButtons(VRSystemState& aState);
+  void UpdateTelemetry(VRSystemState& aSystemState);
+  bool SetupContollerActions();
+
+  bool SubmitFrame(const VRLayerTextureHandle& aTextureHandle,
+                   ::vr::ETextureType aTextureType,
+                   const VRLayerEyeRect& aLeftEyeRect,
+                   const VRLayerEyeRect& aRightEyeRect);
+#if defined(XP_WIN)
+  bool CreateD3DObjects();
+#endif
+  void GetControllerDeviceId(::vr::ETrackedDeviceClass aDeviceType,
+                             ::vr::TrackedDeviceIndex_t aDeviceIndex,
+                             nsCString& aId,
+                             mozilla::gfx::VRControllerType& aControllerType);
+  void UpdateHaptics();
+  void StartHapticThread();
+  void StopHapticThread();
+  void StartHapticTimer();
+  void StopHapticTimer();
+  RefPtr<nsITimer> mHapticTimer;
+  RefPtr<VRThread> mHapticThread;
+  mozilla::Mutex mControllerHapticStateMutex MOZ_UNANNOTATED;
+  UniquePtr<OpenVRControllerMapper> mControllerMapper;
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OPENVRSESSION_H
diff --git a/gfx/vr/service/OpenVRViveMapper.cpp b/gfx/vr/service/OpenVRViveMapper.cpp
new file mode 100644
index 0000000000..a5fadd6e37
--- /dev/null
+++ b/gfx/vr/service/OpenVRViveMapper.cpp
@@ -0,0 +1,43 @@
+/* -*- 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/. */
+
+#include "OpenVRViveMapper.h"
+
+#include "moz_external_vr.h"
+#include "VRSession.h"
+
+namespace mozilla::gfx {
+
+void OpenVRViveMapper::UpdateButtons(VRControllerState& aControllerState,
+                                     ControllerInfo& aControllerInfo) {
+  mNumButtons = mNumAxes = 0;
+  // Button 0: Trigger
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionTrigger_Value);
+  // Button 1: Grip
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionGrip_Pressed,
+                           aControllerInfo.mActionGrip_Touched);
+  // Button 2: Trackpad
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionTrackpad_Pressed,
+                           aControllerInfo.mActionTrackpad_Touched);
+  // Button 3: a placeholder button for thumbstick.
+  ++mNumButtons;
+  // Button 4: Menu
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionMenu_Pressed,
+                           aControllerInfo.mActionMenu_Touched);
+
+  // Axis 0, 1: Trackpad
+  GetAxisValueFromAction(aControllerState,
+                         aControllerInfo.mActionTrackpad_Analog);
+
+  aControllerState.numButtons = mNumButtons;
+  aControllerState.numAxes = mNumAxes;
+}
+
+}  // namespace mozilla::gfx
diff --git a/gfx/vr/service/OpenVRViveMapper.h b/gfx/vr/service/OpenVRViveMapper.h
new file mode 100644
index 0000000000..93b999df5c
--- /dev/null
+++ b/gfx/vr/service/OpenVRViveMapper.h
@@ -0,0 +1,26 @@
+/* -*- 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 GFX_VR_SERVICE_OPENVRVIVEMAPPER_H
+#define GFX_VR_SERVICE_OPENVRVIVEMAPPER_H
+
+#include "OpenVRControllerMapper.h"
+
+namespace mozilla {
+namespace gfx {
+
+class OpenVRViveMapper : public OpenVRControllerMapper {
+ public:
+  OpenVRViveMapper() = default;
+  virtual ~OpenVRViveMapper() = default;
+  virtual void UpdateButtons(VRControllerState& aControllerState,
+                             ControllerInfo& aControllerInfo);
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OPENVRVIVEMAPPER_H
diff --git a/gfx/vr/service/OpenVRWMRMapper.cpp b/gfx/vr/service/OpenVRWMRMapper.cpp
new file mode 100644
index 0000000000..4611d9ee0a
--- /dev/null
+++ b/gfx/vr/service/OpenVRWMRMapper.cpp
@@ -0,0 +1,51 @@
+/* -*- 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/. */
+
+#include "OpenVRWMRMapper.h"
+
+#include "moz_external_vr.h"
+#include "VRSession.h"
+
+namespace mozilla::gfx {
+
+void OpenVRWMRMapper::UpdateButtons(VRControllerState& aControllerState,
+                                    ControllerInfo& aControllerInfo) {
+  mNumButtons = mNumAxes = 0;
+  // Button 0: Trigger
+  GetTriggerValueFromAction(aControllerState,
+                            aControllerInfo.mActionTrigger_Value);
+  // Button 1: Grip
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionGrip_Pressed,
+                           aControllerInfo.mActionGrip_Touched);
+  // Button 2: Touchpad
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionTrackpad_Pressed,
+                           aControllerInfo.mActionTrackpad_Touched);
+  // Button 3: Thumbstick.
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionThumbstick_Pressed,
+                           aControllerInfo.mActionThumbstick_Touched);
+  // Button 4: Menu
+  GetButtonValueFromAction(aControllerState,
+                           aControllerInfo.mActionMenu_Pressed,
+                           aControllerInfo.mActionMenu_Touched);
+
+  // Compared to Edge, we have a wrong implementation for the vertical axis
+  // value. In order to not affect the current VR content, we add a workaround
+  // for yAxis.
+  // Axis 0, 1: Trackpad
+  GetAxisValueFromAction(aControllerState,
+                         aControllerInfo.mActionTrackpad_Analog, true);
+  // Axis 2, 3: Thumbstick
+  GetAxisValueFromAction(aControllerState,
+                         aControllerInfo.mActionThumbstick_Analog, true);
+
+  aControllerState.numButtons = mNumButtons;
+  aControllerState.numAxes = mNumAxes;
+}
+
+}  // namespace mozilla::gfx
diff --git a/gfx/vr/service/OpenVRWMRMapper.h b/gfx/vr/service/OpenVRWMRMapper.h
new file mode 100644
index 0000000000..538d1edfeb
--- /dev/null
+++ b/gfx/vr/service/OpenVRWMRMapper.h
@@ -0,0 +1,26 @@
+/* -*- 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 GFX_VR_SERVICE_OPENVRWMRMAPPER_H
+#define GFX_VR_SERVICE_OPENVRWMRMAPPER_H
+
+#include "OpenVRControllerMapper.h"
+
+namespace mozilla {
+namespace gfx {
+
+class OpenVRWMRMapper : public OpenVRControllerMapper {
+ public:
+  OpenVRWMRMapper() = default;
+  virtual ~OpenVRWMRMapper() = default;
+  virtual void UpdateButtons(VRControllerState& aControllerState,
+                             ControllerInfo& aControllerInfo);
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_OPENVRWMRMAPPER_H
diff --git a/gfx/vr/service/PuppetSession.cpp b/gfx/vr/service/PuppetSession.cpp
new file mode 100644
index 0000000000..6f46bccacc
--- /dev/null
+++ b/gfx/vr/service/PuppetSession.cpp
@@ -0,0 +1,124 @@
+/* -*- 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/. */
+
+#include "PuppetSession.h"
+
+#include "nsString.h"
+#include "VRPuppetCommandBuffer.h"
+#include "mozilla/StaticPrefs_dom.h"
+
+#if defined(XP_WIN)
+#  include <d3d11.h>
+#  include "mozilla/gfx/DeviceManagerDx.h"
+#elif defined(XP_MACOSX)
+#  include "mozilla/gfx/MacIOSurface.h"
+#endif
+
+using namespace mozilla::gfx;
+
+namespace mozilla::gfx {
+
+PuppetSession::PuppetSession() = default;
+
+PuppetSession::~PuppetSession() { Shutdown(); }
+
+bool PuppetSession::Initialize(mozilla::gfx::VRSystemState& aSystemState,
+                               bool aDetectRuntimesOnly) {
+  if (!StaticPrefs::dom_vr_enabled() || !StaticPrefs::dom_vr_puppet_enabled()) {
+    return false;
+  }
+  if (!VRPuppetCommandBuffer::IsCreated()) {
+    // We only want to initialize VRPuppetCommandBuffer on the main thread.
+    // We can assume if it is not initialized, that the puppet display
+    // would not be enumerated.
+    return false;
+  }
+  if (aDetectRuntimesOnly) {
+    aSystemState.displayState.capabilityFlags |=
+        VRDisplayCapabilityFlags::Cap_ImmersiveVR;
+    return false;
+  }
+  VRPuppetCommandBuffer::Get().Run(aSystemState);
+  if (!aSystemState.displayState.isConnected) {
+    return false;
+  }
+#if defined(XP_WIN)
+  if (!CreateD3DObjects()) {
+    Shutdown();
+    return false;
+  }
+#endif
+
+  // Succeeded
+  return true;
+}
+
+#if defined(XP_WIN)
+bool PuppetSession::CreateD3DObjects() {
+  RefPtr<ID3D11Device> device = gfx::DeviceManagerDx::Get()->GetVRDevice();
+  if (!device) {
+    return false;
+  }
+  if (!CreateD3DContext(device)) {
+    return false;
+  }
+  return true;
+}
+#endif
+
+void PuppetSession::Shutdown() {}
+
+void PuppetSession::StartFrame(mozilla::gfx::VRSystemState& aSystemState) {
+  VRPuppetCommandBuffer::Get().Run(aSystemState);
+}
+
+void PuppetSession::ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) {
+  VRPuppetCommandBuffer& puppet = VRPuppetCommandBuffer::Get();
+  puppet.Run(aSystemState);
+  if (!aSystemState.displayState.isConnected) {
+    mShouldQuit = true;
+  }
+}
+
+#if defined(XP_WIN)
+bool PuppetSession::SubmitFrame(
+    const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+    ID3D11Texture2D* aTexture) {
+  return VRPuppetCommandBuffer::Get().SubmitFrame();
+}
+#elif defined(XP_MACOSX)
+bool PuppetSession::SubmitFrame(
+    const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+    const VRLayerTextureHandle& aTexture) {
+  return VRPuppetCommandBuffer::Get().SubmitFrame();
+}
+#endif
+
+void PuppetSession::StopPresentation() {
+  VRPuppetCommandBuffer::Get().StopPresentation();
+}
+
+bool PuppetSession::StartPresentation() {
+  VRPuppetCommandBuffer::Get().StartPresentation();
+  return true;
+}
+
+void PuppetSession::VibrateHaptic(uint32_t aControllerIdx,
+                                  uint32_t aHapticIndex, float aIntensity,
+                                  float aDuration) {
+  VRPuppetCommandBuffer::Get().VibrateHaptic(aControllerIdx, aHapticIndex,
+                                             aIntensity, aDuration);
+}
+
+void PuppetSession::StopVibrateHaptic(uint32_t aControllerIdx) {
+  VRPuppetCommandBuffer::Get().StopVibrateHaptic(aControllerIdx);
+}
+
+void PuppetSession::StopAllHaptics() {
+  VRPuppetCommandBuffer::Get().StopAllHaptics();
+}
+
+}  // namespace mozilla::gfx
diff --git a/gfx/vr/service/PuppetSession.h b/gfx/vr/service/PuppetSession.h
new file mode 100644
index 0000000000..fb0a7c3517
--- /dev/null
+++ b/gfx/vr/service/PuppetSession.h
@@ -0,0 +1,58 @@
+/* -*- 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 GFX_VR_SERVICE_PUPPETSESSION_H
+#define GFX_VR_SERVICE_PUPPETSESSION_H
+
+#include "VRSession.h"
+
+#include "mozilla/TimeStamp.h"
+#include "moz_external_vr.h"
+
+#if defined(XP_WIN)
+#  include <d3d11_1.h>
+#endif
+class nsITimer;
+
+namespace mozilla {
+namespace gfx {
+
+class PuppetSession : public VRSession {
+ public:
+  PuppetSession();
+  virtual ~PuppetSession();
+
+  bool Initialize(mozilla::gfx::VRSystemState& aSystemState,
+                  bool aDetectRuntimesOnly) override;
+  void Shutdown() override;
+  void ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) override;
+  void StartFrame(mozilla::gfx::VRSystemState& aSystemState) override;
+  bool StartPresentation() override;
+  void StopPresentation() override;
+  void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
+                     float aIntensity, float aDuration) override;
+  void StopVibrateHaptic(uint32_t aControllerIdx) override;
+  void StopAllHaptics() override;
+
+ protected:
+#if defined(XP_WIN)
+  bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                   ID3D11Texture2D* aTexture) override;
+#elif defined(XP_MACOSX)
+  bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                   const VRLayerTextureHandle& aTexture) override;
+#endif
+
+ private:
+#if defined(XP_WIN)
+  bool CreateD3DObjects();
+#endif
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_PUPPETSESSION_H
diff --git a/gfx/vr/service/VRService.cpp b/gfx/vr/service/VRService.cpp
new file mode 100644
index 0000000000..2b774c2531
--- /dev/null
+++ b/gfx/vr/service/VRService.cpp
@@ -0,0 +1,418 @@
+/* -*- 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/. */
+
+#include "VRService.h"
+
+#include <cstring>  // for memcmp
+
+#include "../VRShMem.h"
+#include "../gfxVRMutex.h"
+#include "PuppetSession.h"
+#include "mozilla/BackgroundHangMonitor.h"
+#include "mozilla/StaticPrefs_dom.h"
+#include "nsThread.h"
+#include "nsXULAppAPI.h"
+
+#if defined(XP_WIN)
+#  include "OculusSession.h"
+#endif
+
+#if defined(XP_WIN) || defined(XP_MACOSX) || \
+    (defined(XP_LINUX) && !defined(MOZ_WIDGET_ANDROID))
+#  include "OpenVRSession.h"
+#endif
+#if !defined(MOZ_WIDGET_ANDROID)
+#  include "OSVRSession.h"
+#endif
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+namespace {
+
+int64_t FrameIDFromBrowserState(const mozilla::gfx::VRBrowserState& aState) {
+  for (const auto& layer : aState.layerState) {
+    if (layer.type == VRLayerType::LayerType_Stereo_Immersive) {
+      return layer.layer_stereo_immersive.frameId;
+    }
+  }
+  return 0;
+}
+
+bool IsImmersiveContentActive(const mozilla::gfx::VRBrowserState& aState) {
+  for (const auto& layer : aState.layerState) {
+    if (layer.type == VRLayerType::LayerType_Stereo_Immersive) {
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // anonymous namespace
+
+/*static*/
+already_AddRefed<VRService> VRService::Create(
+    volatile VRExternalShmem* aShmem) {
+  RefPtr<VRService> service = new VRService(aShmem);
+  return service.forget();
+}
+
+VRService::VRService(volatile VRExternalShmem* aShmem)
+    : mSystemState{},
+      mBrowserState{},
+      mShutdownRequested(false),
+      mLastHapticState{},
+      mFrameStartTime{} {
+  // When we have the VR process, we map the memory
+  // of mAPIShmem from GPU process and pass it to the CTOR.
+  // If we don't have the VR process, we will instantiate
+  // mAPIShmem in VRService.
+  mShmem = new VRShMem(aShmem, aShmem == nullptr /*aRequiresMutex*/);
+}
+
+VRService::~VRService() {
+  // PSA: We must store the value of any staticPrefs preferences as this
+  // destructor will be called after staticPrefs has been shut down.
+  StopInternal(true /*aFromDtor*/);
+}
+
+void VRService::Refresh() {
+  if (mShmem != nullptr && mShmem->IsDisplayStateShutdown()) {
+    Stop();
+  }
+}
+
+void VRService::Start() {
+  if (!mServiceThread) {
+    /**
+     * We must ensure that any time the service is re-started, that
+     * the VRSystemState is reset, including mSystemState.enumerationCompleted
+     * This must happen before VRService::Start returns to the caller, in order
+     * to prevent the WebVR/WebXR promises from being resolved before the
+     * enumeration has been completed.
+     */
+    memset(&mSystemState, 0, sizeof(mSystemState));
+    PushState(mSystemState);
+    RefPtr<VRService> self = this;
+    nsCOMPtr<nsIThread> thread;
+    nsresult rv = NS_NewNamedThread(
+        "VRService", getter_AddRefs(thread),
+        NS_NewRunnableFunction("VRService::ServiceThreadStartup", [self]() {
+          self->mBackgroundHangMonitor =
+              MakeUnique<mozilla::BackgroundHangMonitor>(
+                  "VRService",
+                  /* Timeout values are powers-of-two to enable us get better
+                     data. 128ms is chosen for transient hangs because 8Hz
+                     should be the minimally acceptable goal for Compositor
+                     responsiveness (normal goal is 60Hz). */
+                  128,
+                  /* 2048ms is chosen for permanent hangs because it's longer
+                   * than most Compositor hangs seen in the wild, but is short
+                   * enough to not miss getting native hang stacks. */
+                  2048);
+          static_cast<nsThread*>(NS_GetCurrentThread())
+              ->SetUseHangMonitor(true);
+        }));
+
+    if (NS_FAILED(rv)) {
+      return;
+    }
+    thread.swap(mServiceThread);
+    // ServiceInitialize needs mServiceThread to be set in order to be able to
+    // assert that it's running on the right thread as well as dispatching new
+    // tasks. It can't be run within the NS_NewRunnableFunction initial event.
+    MOZ_ALWAYS_SUCCEEDS(mServiceThread->Dispatch(
+        NewRunnableMethod("gfx::VRService::ServiceInitialize", this,
+                          &VRService::ServiceInitialize)));
+  }
+}
+
+void VRService::Stop() { StopInternal(false /*aFromDtor*/); }
+
+void VRService::StopInternal(bool aFromDtor) {
+  if (mServiceThread) {
+    // We must disable the background hang monitor before we can shutdown this
+    // thread. Dispatched a last task to do so. No task will be allowed to run
+    // on the service thread after this one.
+    mServiceThread->Dispatch(NS_NewRunnableFunction(
+        "VRService::StopInternal", [self = RefPtr<VRService>(this), this] {
+          static_cast<nsThread*>(NS_GetCurrentThread())
+              ->SetUseHangMonitor(false);
+          mBackgroundHangMonitor = nullptr;
+        }));
+    mShutdownRequested = true;
+    mServiceThread->Shutdown();
+    mServiceThread = nullptr;
+  }
+
+  if (mShmem != nullptr && (aFromDtor || !mShmem->IsSharedExternalShmem())) {
+    // Only leave the VRShMem and clean up the pointer when the struct
+    // was not passed in. Otherwise, VRService will no longer have a
+    // way to access that struct if VRService starts again.
+    mShmem->LeaveShMem();
+    delete mShmem;
+    mShmem = nullptr;
+  }
+
+  mSession = nullptr;
+}
+
+bool VRService::InitShmem() { return mShmem->JoinShMem(); }
+
+bool VRService::IsInServiceThread() {
+  return mServiceThread && mServiceThread->IsOnCurrentThread();
+}
+
+void VRService::ServiceInitialize() {
+  MOZ_ASSERT(IsInServiceThread());
+
+  if (!InitShmem()) {
+    return;
+  }
+
+  mShutdownRequested = false;
+  // Get initial state from the browser
+  PullState(mBrowserState);
+
+  // Try to start a VRSession
+  UniquePtr<VRSession> session;
+
+  if (StaticPrefs::dom_vr_puppet_enabled()) {
+    // When the VR Puppet is enabled, we don't want
+    // to enumerate any real devices
+    session = MakeUnique<PuppetSession>();
+    if (!session->Initialize(mSystemState, mBrowserState.detectRuntimesOnly)) {
+      session = nullptr;
+    }
+  } else {
+    // We try Oculus first to ensure we use Oculus
+    // devices trough the most native interface
+    // when possible.
+#if defined(XP_WIN)
+    // Try Oculus
+    if (!session) {
+      session = MakeUnique<OculusSession>();
+      if (!session->Initialize(mSystemState,
+                               mBrowserState.detectRuntimesOnly)) {
+        session = nullptr;
+      }
+    }
+#endif
+
+#if defined(XP_WIN) || defined(XP_MACOSX) || \
+    (defined(XP_LINUX) && !defined(MOZ_WIDGET_ANDROID))
+    // Try OpenVR
+    if (!session) {
+      session = MakeUnique<OpenVRSession>();
+      if (!session->Initialize(mSystemState,
+                               mBrowserState.detectRuntimesOnly)) {
+        session = nullptr;
+      }
+    }
+#endif
+#if !defined(MOZ_WIDGET_ANDROID)
+    // Try OSVR
+    if (!session) {
+      session = MakeUnique<OSVRSession>();
+      if (!session->Initialize(mSystemState,
+                               mBrowserState.detectRuntimesOnly)) {
+        session = nullptr;
+      }
+    }
+#endif
+
+  }  // if (staticPrefs:VRPuppetEnabled())
+
+  if (session) {
+    mSession = std::move(session);
+    // Setting enumerationCompleted to true indicates to the browser
+    // that it should resolve any promises in the WebVR/WebXR API
+    // waiting for hardware detection.
+    mSystemState.enumerationCompleted = true;
+    PushState(mSystemState);
+
+    mServiceThread->Dispatch(
+        NewRunnableMethod("gfx::VRService::ServiceWaitForImmersive", this,
+                          &VRService::ServiceWaitForImmersive));
+  } else {
+    // VR hardware was not detected.
+    // We must inform the browser of the failure so it may try again
+    // later and resolve WebVR promises.  A failure or shutdown is
+    // indicated by enumerationCompleted being set to true, with all
+    // other fields remaining zeroed out.
+    VRDisplayCapabilityFlags capFlags =
+        mSystemState.displayState.capabilityFlags;
+    memset(&mSystemState, 0, sizeof(mSystemState));
+    mSystemState.enumerationCompleted = true;
+
+    if (mBrowserState.detectRuntimesOnly) {
+      mSystemState.displayState.capabilityFlags = capFlags;
+    } else {
+      mSystemState.displayState.minRestartInterval =
+          StaticPrefs::dom_vr_external_notdetected_timeout();
+    }
+    mSystemState.displayState.shutdown = true;
+    PushState(mSystemState);
+  }
+}
+
+void VRService::ServiceShutdown() {
+  MOZ_ASSERT(IsInServiceThread());
+
+  // Notify the browser that we have shut down.
+  // This is indicated by enumerationCompleted being set
+  // to true, with all other fields remaining zeroed out.
+  memset(&mSystemState, 0, sizeof(mSystemState));
+  mSystemState.enumerationCompleted = true;
+  mSystemState.displayState.shutdown = true;
+  if (mSession && mSession->ShouldQuit()) {
+    mSystemState.displayState.minRestartInterval =
+        StaticPrefs::dom_vr_external_quit_timeout();
+  }
+  PushState(mSystemState);
+  mSession = nullptr;
+}
+
+void VRService::ServiceWaitForImmersive() {
+  MOZ_ASSERT(IsInServiceThread());
+  MOZ_ASSERT(mSession);
+
+  mSession->ProcessEvents(mSystemState);
+  PushState(mSystemState);
+  PullState(mBrowserState);
+
+  if (mSession->ShouldQuit() || mShutdownRequested) {
+    // Shut down
+    mServiceThread->Dispatch(NewRunnableMethod(
+        "gfx::VRService::ServiceShutdown", this, &VRService::ServiceShutdown));
+  } else if (IsImmersiveContentActive(mBrowserState)) {
+    // Enter Immersive Mode
+    mSession->StartPresentation();
+    mSession->StartFrame(mSystemState);
+    PushState(mSystemState);
+
+    mServiceThread->Dispatch(
+        NewRunnableMethod("gfx::VRService::ServiceImmersiveMode", this,
+                          &VRService::ServiceImmersiveMode));
+  } else {
+    // Continue waiting for immersive mode
+    mServiceThread->Dispatch(
+        NewRunnableMethod("gfx::VRService::ServiceWaitForImmersive", this,
+                          &VRService::ServiceWaitForImmersive));
+  }
+}
+
+void VRService::ServiceImmersiveMode() {
+  MOZ_ASSERT(IsInServiceThread());
+  MOZ_ASSERT(mSession);
+
+  mSession->ProcessEvents(mSystemState);
+  UpdateHaptics();
+  PushState(mSystemState);
+  PullState(mBrowserState);
+
+  if (mSession->ShouldQuit() || mShutdownRequested) {
+    // Shut down
+    mServiceThread->Dispatch(NewRunnableMethod(
+        "gfx::VRService::ServiceShutdown", this, &VRService::ServiceShutdown));
+    return;
+  }
+
+  if (!IsImmersiveContentActive(mBrowserState)) {
+    // Exit immersive mode
+    mSession->StopAllHaptics();
+    mSession->StopPresentation();
+    mServiceThread->Dispatch(
+        NewRunnableMethod("gfx::VRService::ServiceWaitForImmersive", this,
+                          &VRService::ServiceWaitForImmersive));
+    return;
+  }
+
+  uint64_t newFrameId = FrameIDFromBrowserState(mBrowserState);
+  if (newFrameId != mSystemState.displayState.lastSubmittedFrameId) {
+    // A new immersive frame has been received.
+    // Submit the textures to the VR system compositor.
+    bool success = false;
+    for (const auto& layer : mBrowserState.layerState) {
+      if (layer.type == VRLayerType::LayerType_Stereo_Immersive) {
+        // SubmitFrame may block in order to control the timing for
+        // the next frame start
+        success = mSession->SubmitFrame(layer.layer_stereo_immersive);
+        break;
+      }
+    }
+
+    // Changing mLastSubmittedFrameId triggers a new frame to start
+    // rendering.  Changes to mLastSubmittedFrameId and the values
+    // used for rendering, such as headset pose, must be pushed
+    // atomically to the browser.
+    mSystemState.displayState.lastSubmittedFrameId = newFrameId;
+    mSystemState.displayState.lastSubmittedFrameSuccessful = success;
+
+    // StartFrame may block to control the timing for the next frame start
+    mSession->StartFrame(mSystemState);
+    mSystemState.sensorState.inputFrameID++;
+    size_t historyIndex =
+        mSystemState.sensorState.inputFrameID % ArrayLength(mFrameStartTime);
+    mFrameStartTime[historyIndex] = TimeStamp::Now();
+    PushState(mSystemState);
+  }
+
+  // Continue immersive mode
+  mServiceThread->Dispatch(
+      NewRunnableMethod("gfx::VRService::ServiceImmersiveMode", this,
+                        &VRService::ServiceImmersiveMode));
+}
+
+void VRService::UpdateHaptics() {
+  MOZ_ASSERT(IsInServiceThread());
+  MOZ_ASSERT(mSession);
+
+  for (size_t i = 0; i < ArrayLength(mBrowserState.hapticState); i++) {
+    VRHapticState& state = mBrowserState.hapticState[i];
+    VRHapticState& lastState = mLastHapticState[i];
+    // Note that VRHapticState is asserted to be a POD type, thus memcmp is safe
+    if (memcmp(&state, &lastState, sizeof(VRHapticState)) == 0) {
+      // No change since the last update
+      continue;
+    }
+    if (state.inputFrameID == 0) {
+      // The haptic feedback was stopped
+      mSession->StopVibrateHaptic(state.controllerIndex);
+    } else {
+      TimeStamp now;
+      if (now.IsNull()) {
+        // TimeStamp::Now() is expensive, so we
+        // must call it only when needed and save the
+        // output for further loop iterations.
+        now = TimeStamp::Now();
+      }
+      // This is a new haptic pulse, or we are overriding a prior one
+      size_t historyIndex = state.inputFrameID % ArrayLength(mFrameStartTime);
+      float startOffset =
+          (float)(now - mFrameStartTime[historyIndex]).ToSeconds();
+
+      // state.pulseStart is guaranteed never to be in the future
+      mSession->VibrateHaptic(
+          state.controllerIndex, state.hapticIndex, state.pulseIntensity,
+          state.pulseDuration + state.pulseStart - startOffset);
+    }
+    // Record the state for comparison in the next run
+    memcpy(&lastState, &state, sizeof(VRHapticState));
+  }
+}
+
+void VRService::PushState(const mozilla::gfx::VRSystemState& aState) {
+  if (mShmem != nullptr) {
+    mShmem->PushSystemState(aState);
+  }
+}
+
+void VRService::PullState(mozilla::gfx::VRBrowserState& aState) {
+  if (mShmem != nullptr) {
+    mShmem->PullBrowserState(aState);
+  }
+}
diff --git a/gfx/vr/service/VRService.h b/gfx/vr/service/VRService.h
new file mode 100644
index 0000000000..2e41cd2980
--- /dev/null
+++ b/gfx/vr/service/VRService.h
@@ -0,0 +1,93 @@
+/* -*- 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 GFX_VR_SERVICE_VRSERVICE_H
+#define GFX_VR_SERVICE_VRSERVICE_H
+
+#include "moz_external_vr.h"
+#include "base/process.h"  // for base::ProcessHandle
+#include "mozilla/Atomics.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/UniquePtr.h"
+#include "nsCOMPtr.h"
+
+class nsIThread;
+namespace mozilla {
+class BackgroundHangMonitor;
+namespace gfx {
+
+class VRSession;
+class VRShMem;
+
+static const int kVRFrameTimingHistoryDepth = 100;
+
+class VRService {
+ public:
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(VRService)
+  static already_AddRefed<VRService> Create(
+      volatile VRExternalShmem* aShmem = nullptr);
+
+  void Refresh();
+  void Start();
+  void Stop();
+
+ private:
+  explicit VRService(volatile VRExternalShmem* aShmem);
+  ~VRService();
+
+  void StopInternal(bool aFromDtor);
+
+  bool InitShmem();
+  void PushState(const mozilla::gfx::VRSystemState& aState);
+  void PullState(mozilla::gfx::VRBrowserState& aState);
+
+  /**
+   * VRSystemState contains the most recent state of the VR
+   * system, to be shared with the browser by Shmem.
+   * mSystemState is the VR Service copy of this data, which
+   * is memcpy'ed atomically to the Shmem.
+   * VRSystemState is written by the VR Service, but read-only
+   * by the browser.
+   */
+  VRSystemState mSystemState;
+  /**
+   * VRBrowserState contains the most recent state of the browser.
+   * mBrowserState is memcpy'ed from the Shmem atomically
+   */
+  VRBrowserState mBrowserState;
+
+  UniquePtr<VRSession> mSession;
+  nsCOMPtr<nsIThread> mServiceThread;
+  // Only ever accessed on the service thread.
+  UniquePtr<mozilla::BackgroundHangMonitor> mBackgroundHangMonitor;
+
+  Atomic<bool> mShutdownRequested;
+
+  // Note: mShmem doesn't support RefPtr; thus, do not share this private
+  // pointer so that its lifetime can still be controlled by VRService
+  VRShMem* mShmem;
+  VRHapticState mLastHapticState[kVRHapticsMaxCount];
+  TimeStamp mFrameStartTime[kVRFrameTimingHistoryDepth];
+
+  bool IsInServiceThread();
+  void UpdateHaptics();
+
+  /**
+   * The VR Service thread is a state machine that always has one
+   * task queued depending on the state.
+   *
+   * VR Service thread state task functions:
+   */
+  void ServiceInitialize();
+  void ServiceShutdown();
+  void ServiceWaitForImmersive();
+  void ServiceImmersiveMode();
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_VRSERVICE_H
diff --git a/gfx/vr/service/VRSession.cpp b/gfx/vr/service/VRSession.cpp
new file mode 100644
index 0000000000..cf5357be11
--- /dev/null
+++ b/gfx/vr/service/VRSession.cpp
@@ -0,0 +1,200 @@
+/* -*- 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/. */
+
+#include "VRSession.h"
+
+#include "moz_external_vr.h"
+
+#include "mozilla/ipc/FileDescriptor.h"
+
+#if defined(XP_WIN)
+#  include <d3d11.h>
+#endif  // defined(XP_WIN)
+
+#if defined(MOZILLA_INTERNAL_API)
+#  if defined(XP_WIN)
+#    include "mozilla/gfx/Logging.h"
+#  endif
+#else
+#  define NS_WARNING(s)
+#endif
+
+using namespace mozilla::gfx;
+
+VRSession::VRSession()
+    : mShouldQuit(false)
+#ifdef XP_WIN
+      ,
+      mDevice(nullptr),
+      mContext(nullptr),
+      mDeviceContextState(nullptr)
+#endif
+{
+}
+
+#ifdef XP_WIN
+VRSession::~VRSession() {
+  if (mDevice != nullptr) {
+    mDevice->Release();
+    mDevice = nullptr;
+  }
+
+  if (mContext != nullptr) {
+    mContext->Release();
+    mContext = nullptr;
+  }
+
+  if (mDeviceContextState != nullptr) {
+    mDeviceContextState->Release();
+    mDeviceContextState = nullptr;
+  }
+}
+#endif
+
+#if defined(XP_WIN)
+bool VRSession::CreateD3DContext(ID3D11Device* aDevice) {
+  if (!mDevice) {
+    if (!aDevice) {
+      NS_WARNING("VRSession::CreateD3DObjects failed to get a D3D11Device");
+      return false;
+    }
+    if (FAILED(aDevice->QueryInterface(IID_PPV_ARGS(&mDevice)))) {
+      NS_WARNING("VRSession::CreateD3DObjects failed to get a D3D11Device1");
+      return false;
+    }
+  }
+  if (!mContext) {
+    mDevice->GetImmediateContext1(&mContext);
+    if (!mContext) {
+      NS_WARNING(
+          "VRSession::CreateD3DObjects failed to get an immediate context");
+      return false;
+    }
+  }
+  if (!mDeviceContextState) {
+    D3D_FEATURE_LEVEL featureLevels[]{D3D_FEATURE_LEVEL_11_1,
+                                      D3D_FEATURE_LEVEL_11_0};
+    mDevice->CreateDeviceContextState(0, featureLevels, 2, D3D11_SDK_VERSION,
+                                      __uuidof(ID3D11Device1), nullptr,
+                                      &mDeviceContextState);
+  }
+  if (!mDeviceContextState) {
+    NS_WARNING(
+        "VRSession::CreateD3DObjects failed to get a D3D11DeviceContextState");
+    return false;
+  }
+  return true;
+}
+
+ID3D11Device1* VRSession::GetD3DDevice() { return mDevice; }
+
+ID3D11DeviceContext1* VRSession::GetD3DDeviceContext() { return mContext; }
+
+ID3DDeviceContextState* VRSession::GetD3DDeviceContextState() {
+  return mDeviceContextState;
+}
+
+#endif  // defined(XP_WIN)
+
+bool VRSession::SubmitFrame(
+    const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer) {
+#if defined(XP_WIN)
+  bool success = false;
+  if (aLayer.textureType ==
+      VRLayerTextureType::LayerTextureType_D3D10SurfaceDescriptor) {
+    ID3D11Texture2D* dxTexture = nullptr;
+    mozilla::ipc::FileDescriptor::UniquePlatformHandle handle(
+        aLayer.textureHandle);
+    HRESULT hr =
+        mDevice->OpenSharedResource1(handle.get(), IID_PPV_ARGS(&dxTexture));
+    if (SUCCEEDED(hr) && dxTexture != nullptr) {
+      // Similar to LockD3DTexture in TextureD3D11.cpp
+      IDXGIKeyedMutex* mutex = nullptr;
+      hr = dxTexture->QueryInterface(IID_PPV_ARGS(&mutex));
+      if (SUCCEEDED(hr)) {
+        hr = mutex->AcquireSync(0, 1000);
+#  ifdef MOZILLA_INTERNAL_API
+        if (hr == WAIT_TIMEOUT) {
+          gfxDevCrash(LogReason::D3DLockTimeout) << "D3D lock mutex timeout";
+        } else if (hr == WAIT_ABANDONED) {
+          gfxCriticalNote << "GFX: D3D11 lock mutex abandoned";
+        }
+#  endif
+        if (SUCCEEDED(hr)) {
+          success = SubmitFrame(aLayer, dxTexture);
+          hr = mutex->ReleaseSync(0);
+          if (FAILED(hr)) {
+            NS_WARNING("Failed to unlock the texture");
+          }
+        } else {
+          NS_WARNING("Failed to lock the texture");
+        }
+
+        mutex->Release();
+        mutex = nullptr;
+      }
+
+      dxTexture->Release();
+      dxTexture = nullptr;
+    } else {
+      NS_WARNING("Failed to open shared texture");
+    }
+
+    return SUCCEEDED(hr) && success;
+  }
+
+#elif defined(XP_MACOSX)
+
+  if (aLayer.textureType == VRLayerTextureType::LayerTextureType_MacIOSurface) {
+    return SubmitFrame(aLayer, aLayer.textureHandle);
+  }
+
+#endif
+
+  return false;
+}
+
+void VRSession::UpdateTrigger(VRControllerState& aState, uint32_t aButtonIndex,
+                              float aValue, float aThreshold) {
+  // For OpenVR, the threshold value of ButtonPressed and ButtonTouched is 0.55.
+  // We prefer to let developers to set their own threshold for the adjustment.
+  // Therefore, we don't check ButtonPressed and ButtonTouched with ButtonMask
+  // here. we just check the button value is larger than the threshold value or
+  // not.
+  uint64_t mask = (1ULL << aButtonIndex);
+  aState.triggerValue[aButtonIndex] = aValue;
+  if (aValue > aThreshold) {
+    aState.buttonPressed |= mask;
+    aState.buttonTouched |= mask;
+  } else {
+    aState.buttonPressed &= ~mask;
+    aState.buttonTouched &= ~mask;
+  }
+}
+
+void VRSession::SetControllerSelectionAndSqueezeFrameId(
+    VRControllerState& controllerState, uint64_t aFrameId) {
+  // The 1st button, trigger, is its selection action.
+  const bool selectionPressed = controllerState.buttonPressed & 1ULL;
+  if (selectionPressed && controllerState.selectActionStopFrameId >=
+                              controllerState.selectActionStartFrameId) {
+    controllerState.selectActionStartFrameId = aFrameId;
+  } else if (!selectionPressed && controllerState.selectActionStartFrameId >
+                                      controllerState.selectActionStopFrameId) {
+    controllerState.selectActionStopFrameId = aFrameId;
+  }
+  // The 2nd button, squeeze, is its squeeze action.
+  const bool squeezePressed = controllerState.buttonPressed & (1ULL << 1);
+  if (squeezePressed && controllerState.squeezeActionStopFrameId >=
+                            controllerState.squeezeActionStartFrameId) {
+    controllerState.squeezeActionStartFrameId = aFrameId;
+  } else if (!squeezePressed && controllerState.squeezeActionStartFrameId >
+                                    controllerState.squeezeActionStopFrameId) {
+    controllerState.squeezeActionStopFrameId = aFrameId;
+  }
+}
+
+bool VRSession::ShouldQuit() const { return mShouldQuit; }
diff --git a/gfx/vr/service/VRSession.h b/gfx/vr/service/VRSession.h
new file mode 100644
index 0000000000..ab446a26d7
--- /dev/null
+++ b/gfx/vr/service/VRSession.h
@@ -0,0 +1,94 @@
+/* -*- 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 GFX_VR_SERVICE_VRSESSION_H
+#define GFX_VR_SERVICE_VRSESSION_H
+
+#include "moz_external_vr.h"
+
+#if defined(XP_WIN)
+#  include <d3d11_1.h>
+#elif defined(XP_MACOSX)
+class MacIOSurface;
+#endif
+
+namespace mozilla {
+namespace gfx {
+
+class VRSession {
+ public:
+  VRSession();
+
+  // Since this class doesn't use smartpointers for its refcounted
+  // members (so that it can compile outside of mozilla-central),
+  // prevent copying the addresses without increasing the refcount.
+  VRSession(const VRSession&) = delete;
+  VRSession& operator=(const VRSession&) = delete;
+
+#ifdef XP_WIN
+  virtual ~VRSession();
+#else
+  virtual ~VRSession() = default;
+#endif
+
+  static void UpdateTrigger(VRControllerState& aState, uint32_t aButtonIndex,
+                            float aValue, float aThreshold);
+  /**
+   * In order to support WebXR's navigator.xr.IsSessionSupported call without
+   * displaying any permission dialogue, it is necessary to have a safe way to
+   * detect the capability of running a VR or AR session without activating XR
+   * runtimes or powering on hardware.
+   *
+   * API's such as OpenVR make no guarantee that hardware and software won't be
+   * left activated after enumerating devices, so each backend in gfx/vr/service
+   * must allow for more granular detection of capabilities.
+   *
+   * By passing true to bDetectRuntimesOnly, the initialization exits early
+   * after reporting the presence of XR runtime software. The Initialize method
+   * will only enumerate hardware and possibly return true when
+   * aDetectRuntimesOnly is false.
+   */
+  virtual bool Initialize(mozilla::gfx::VRSystemState& aSystemState,
+                          bool aDetectRuntimesOnly) = 0;
+  virtual void Shutdown() = 0;
+  virtual void ProcessEvents(mozilla::gfx::VRSystemState& aSystemState) = 0;
+  virtual void StartFrame(mozilla::gfx::VRSystemState& aSystemState) = 0;
+  virtual bool StartPresentation() = 0;
+  virtual void StopPresentation() = 0;
+  virtual void VibrateHaptic(uint32_t aControllerIdx, uint32_t aHapticIndex,
+                             float aIntensity, float aDuration) = 0;
+  virtual void StopVibrateHaptic(uint32_t aControllerIdx) = 0;
+  virtual void StopAllHaptics() = 0;
+  bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer);
+  bool ShouldQuit() const;
+
+ protected:
+  bool mShouldQuit;
+#if defined(XP_WIN)
+  virtual bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                           ID3D11Texture2D* aTexture) = 0;
+  bool CreateD3DContext(ID3D11Device* aDevice);
+
+  ID3D11Device1* GetD3DDevice();
+  ID3D11DeviceContext1* GetD3DDeviceContext();
+  ID3DDeviceContextState* GetD3DDeviceContextState();
+
+  ID3D11Device1* mDevice;
+  ID3D11DeviceContext1* mContext;
+  ID3DDeviceContextState* mDeviceContextState;
+
+#elif defined(XP_MACOSX)
+  virtual bool SubmitFrame(const mozilla::gfx::VRLayer_Stereo_Immersive& aLayer,
+                           const VRLayerTextureHandle& aTexture) = 0;
+#endif
+  void SetControllerSelectionAndSqueezeFrameId(
+      VRControllerState& controllerState, uint64_t aFrameId);
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_SERVICE_VRSESSION_H
diff --git a/gfx/vr/service/binding/OpenVRCosmosBinding.h b/gfx/vr/service/binding/OpenVRCosmosBinding.h
new file mode 100644
index 0000000000..97980bb087
--- /dev/null
+++ b/gfx/vr/service/binding/OpenVRCosmosBinding.h
@@ -0,0 +1,204 @@
+/* -*- 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 GFX_VR_BLINDING_OPENVRCOSMOSBINDING_H
+#define GFX_VR_BLINDING_OPENVRCOSMOSBINDING_H
+
+namespace mozilla {
+namespace gfx {
+
+struct OpenVRCosmosBinding {
+  const char* binding =
+      // clang-format off
+  "{\n"
+    "  \"version\" : \"0.1\", \n"
+    "  \"controller_type\" : \"vive_cosmos_controller\", \n"
+    "  \"description\" : \"Bindings for Firefox OpenVR for the Vive Cosmos controller\", \n"
+    "  \"name\" : \"Firefox bindings for Vive Cosmos Controller\", \n"
+    "  \"bindings\" : { \n"
+    "     \"/actions/firefox\" : { \n"
+    "         \"poses\" : [        \n"
+    "           {                \n"
+    "             \"output\" : \"/actions/firefox/in/LHand_pose\", \n"
+    "              \"path\" : \"/user/hand/left/pose/raw\"     \n"
+    "            },\n"
+    "            {                                             \n"
+    "              \"output\" : \"/actions/firefox/in/RHand_pose\", \n"
+    "              \"path\" : \"/user/hand/right/pose/raw\"    \n"
+    "            }\n"
+    "         ],\n"
+    "         \"haptics\" : [ \n"
+    "            {\n"
+    "              \"output\" : \"/actions/firefox/out/LHand_haptic\",  \n"
+    "              \"path\" : \"/user/hand/left/output/haptic\"     \n"
+    "            },\n"
+    "            { \n"
+    "              \"output\" : \"/actions/firefox/out/RHand_haptic\", \n"
+    "              \"path\" : \"/user/hand/right/output/haptic\"    \n"
+    "            }\n"
+    "		  ],\n"
+    "       \"sources\" : [ \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"pull\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_trigger_value\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/left/input/trigger\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"pull\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_trigger_value\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/right/input/trigger\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"click\" : { \n"
+    "                \"output\" : \"/actions/firefox/in/LHand_grip_pressed\" \n"
+    "              }, \n"
+    "               \"touch\" : { \n"
+    "                \"output\" : \"/actions/firefox/in/LHand_grip_touched\" \n"
+    "              } \n"
+    "             }, \n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/grip\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"click\" : { \n"
+    "                \"output\" : \"/actions/firefox/in/RHand_grip_pressed\" \n"
+    "              }, \n"
+    "               \"touch\" : { \n"
+    "                 \"output\" : \"/actions/firefox/in/RHand_grip_touched\" \n"
+    "              } \n"
+    "           }, \n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/grip\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_system_pressed\"  \n"
+    "                   }, \n"
+    "                 \"touch\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_system_touched\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/system\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_system_pressed\"  \n"
+    "                   }, \n"
+    "                 \"touch\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_system_touched\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/system\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_a_pressed\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/x\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_a_pressed\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/a\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_b_pressed\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/y\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_b_pressed\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/b\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"position\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_thumbstick_analog\" \n"
+    "               }, \n"
+    "               \"click\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_thumbstick_pressed\" \n"
+    "               }, \n"
+    "               \"touch\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_thumbstick_touched\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"joystick\", \n"
+    "             \"path\" : \"/user/hand/left/input/joystick\" \n"
+    "           },\n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"position\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_thumbstick_analog\" \n"
+    "               }, \n"
+    "               \"click\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_thumbstick_pressed\" \n"
+    "               }, \n"
+    "               \"touch\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_thumbstick_touched\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"joystick\", \n"
+    "             \"path\" : \"/user/hand/right/input/joystick\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_bumper_pressed\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/bumper\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_bumper_pressed\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/bumper\" \n"
+    "           } \n"
+    "         ]\n"
+    "     }\n"
+    "  }\n"
+    "}";
+  // clang-format on
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_BLINDING_OPENVRCOSMOSBINDING_H
diff --git a/gfx/vr/service/binding/OpenVRKnucklesBinding.h b/gfx/vr/service/binding/OpenVRKnucklesBinding.h
new file mode 100644
index 0000000000..508e5f64c7
--- /dev/null
+++ b/gfx/vr/service/binding/OpenVRKnucklesBinding.h
@@ -0,0 +1,300 @@
+/* -*- 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 GFX_VR_BLINDING_OPENVRKNUCKLESBINDING_H
+#define GFX_VR_BLINDING_OPENVRKNUCKLESBINDING_H
+
+namespace mozilla {
+namespace gfx {
+
+struct OpenVRKnucklesBinding {
+  const char* binding =
+      // clang-format off
+  "{\n"
+    "  \"version\" : \"0.1\", \n"
+    "  \"controller_type\" : \"knuckles\", \n"
+    "  \"description\" : \"Bindings for Firefox OpenVR for the Knuckles controller\", \n"
+    "  \"name\" : \"Firefox bindings for Knuckles Controller\", \n"
+    "  \"bindings\" : { \n"
+    "     \"/actions/firefox\" : { \n"
+    "         \"poses\" : [        \n"
+    "           {                \n"
+    "             \"output\" : \"/actions/firefox/in/LHand_pose\", \n"
+    "              \"path\" : \"/user/hand/left/pose/raw\"     \n"
+    "            },\n"
+    "            {                                             \n"
+    "              \"output\" : \"/actions/firefox/in/RHand_pose\", \n"
+    "              \"path\" : \"/user/hand/right/pose/raw\"    \n"
+    "            }\n"
+    "         ],\n"
+    "         \"haptics\" : [ \n"
+    "            {\n"
+    "              \"output\" : \"/actions/firefox/out/LHand_haptic\",  \n"
+    "              \"path\" : \"/user/hand/left/output/haptic\"     \n"
+    "            },\n"
+    "            { \n"
+    "              \"output\" : \"/actions/firefox/out/RHand_haptic\", \n"
+    "              \"path\" : \"/user/hand/right/output/haptic\"    \n"
+    "            }\n"
+    "		  ],\n"
+    "       \"sources\" : [ \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"position\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_analog\" \n"
+    "               }, \n"
+    "               \"click\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_pressed\" \n"
+    "               }, \n"
+    "               \"touch\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_touched\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trackpad\", \n"
+    "             \"path\" : \"/user/hand/left/input/trackpad\" \n"
+    "           },\n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"position\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_analog\" \n"
+    "               }, \n"
+    "               \"click\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_pressed\" \n"
+    "               }, \n"
+    "               \"touch\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_touched\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trackpad\", \n"
+    "             \"path\" : \"/user/hand/right/input/trackpad\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"pull\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_trigger_value\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/left/input/trigger\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"pull\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_trigger_value\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/right/input/trigger\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"click\" : { \n"
+    "                \"output\" : \"/actions/firefox/in/LHand_grip_pressed\" \n"
+    "              }, \n"
+    "               \"touch\" : { \n"
+    "                \"output\" : \"/actions/firefox/in/LHand_grip_touched\" \n"
+    "              } \n"
+    "             }, \n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/grip\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"click\" : { \n"
+    "                \"output\" : \"/actions/firefox/in/RHand_grip_pressed\" \n"
+    "              }, \n"
+    "               \"touch\" : { \n"
+    "                 \"output\" : \"/actions/firefox/in/RHand_grip_touched\" \n"
+    "              } \n"
+    "           }, \n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/grip\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_system_pressed\"  \n"
+    "                   }, \n"
+    "                 \"touch\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_system_touched\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/system\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_system_pressed\"  \n"
+    "                   }, \n"
+    "                 \"touch\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_system_touched\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/system\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_a_pressed\"  \n"
+    "                   }, \n"
+    "                 \"touch\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_a_touched\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/a\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_a_pressed\"  \n"
+    "                   }, \n"
+    "                 \"touch\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_a_touched\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/a\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_b_pressed\"  \n"
+    "                   }, \n"
+    "                 \"touch\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/LHand_b_touched\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/left/input/b\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "                 \"click\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_b_pressed\"  \n"
+    "                   }, \n"
+    "                 \"touch\" : { \n"
+    "                    \"output\" : \"/actions/firefox/in/RHand_b_touched\"  \n"
+    "                   } \n"
+    "              },\n"
+    "             \"mode\" : \"button\", \n"
+    "             \"path\" : \"/user/hand/right/input/b\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"position\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_thumbstick_analog\" \n"
+    "               }, \n"
+    "               \"click\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_thumbstick_pressed\" \n"
+    "               }, \n"
+    "               \"touch\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_thumbstick_touched\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"joystick\", \n"
+    "             \"path\" : \"/user/hand/left/input/thumbstick\" \n"
+    "           },\n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"position\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_thumbstick_analog\" \n"
+    "               }, \n"
+    "               \"click\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_thumbstick_pressed\" \n"
+    "               }, \n"
+    "               \"touch\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_thumbstick_touched\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"joystick\", \n"
+    "             \"path\" : \"/user/hand/right/input/thumbstick\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"pull\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_finger_index_value\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/left/input/finger/index\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"pull\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_finger_index_value\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/right/input/finger/index\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"pull\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_finger_middle_value\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/left/input/finger/middle\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"pull\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_finger_middle_value\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/right/input/finger/middle\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"pull\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_finger_ring_value\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/left/input/finger/ring\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"pull\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_finger_ring_value\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/right/input/finger/ring\" \n"
+    "           }, \n"
+      "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"pull\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/LHand_finger_pinky_value\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/left/input/finger/pinky\" \n"
+    "           }, \n"
+    "           {\n"
+    "             \"inputs\" : { \n"
+    "               \"pull\" : { \n"
+    "                   \"output\" : \"/actions/firefox/in/RHand_finger_pinky_value\" \n"
+    "               } \n"
+    "             }, \n"
+    "             \"mode\" : \"trigger\", \n"
+    "             \"path\" : \"/user/hand/right/input/finger/pinky\" \n"
+    "           } \n"
+    "         ]\n"
+    "     }\n"
+    "  }\n"
+    "}";
+  // clang-format on
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_BLINDING_OPENVRKNUCKLESBINDING_H
diff --git a/gfx/vr/service/binding/OpenVRViveBinding.h b/gfx/vr/service/binding/OpenVRViveBinding.h
new file mode 100644
index 0000000000..c3fb7fd6e1
--- /dev/null
+++ b/gfx/vr/service/binding/OpenVRViveBinding.h
@@ -0,0 +1,174 @@
+/* -*- 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 GFX_VR_BLINDING_OPENVRVIVEBINDING_H
+#define GFX_VR_BLINDING_OPENVRVIVEBINDING_H
+
+namespace mozilla {
+namespace gfx {
+
+struct OpenVRViveBinding {
+  const char* binding =
+      // clang-format off
+  "{\n"
+  "  \"version\" : \"0.1\", \n"
+  "  \"controller_type\" : \"vive_controller\", \n"
+  "  \"description\" : \"Bindings for Firefox OpenVR for the Vive controller\", \n"
+  "  \"name\" : \"Firefox bindings for Vive Controller\", \n"
+  "  \"bindings\" : { \n"
+  "     \"/actions/firefox\" : { \n"
+  "         \"poses\" : [        \n"
+  "           {                \n"
+  "             \"output\" : \"/actions/firefox/in/LHand_pose\", \n"
+  "              \"path\" : \"/user/hand/left/pose/raw\"     \n"
+  "            },\n"
+  "            {                                             \n"
+  "              \"output\" : \"/actions/firefox/in/RHand_pose\", \n"
+  "              \"path\" : \"/user/hand/right/pose/raw\"    \n"
+  "            }\n"
+  "         ],\n"
+  "         \"haptics\" : [ \n"
+  "            {\n"
+  "              \"output\" : \"/actions/firefox/out/LHand_haptic\",  \n"
+  "              \"path\" : \"/user/hand/left/output/haptic\"     \n"
+  "            },\n"
+  "            { \n"
+  "              \"output\" : \"/actions/firefox/out/RHand_haptic\", \n"
+  "              \"path\" : \"/user/hand/right/output/haptic\"    \n"
+  "            }\n"
+  "		  ],\n"
+  "       \"sources\" : [ \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"position\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_analog\" \n"
+  "               }, \n"
+  "               \"click\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_pressed\" \n"
+  "               }, \n"
+  "               \"touch\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_touched\" \n"
+  "               } \n"
+  "             }, \n"
+  "             \"mode\" : \"trackpad\", \n"
+  "             \"path\" : \"/user/hand/left/input/trackpad\" \n"
+  "           },\n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"position\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_analog\" \n"
+  "               }, \n"
+  "               \"click\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_pressed\" \n"
+  "               }, \n"
+  "               \"touch\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_touched\" \n"
+  "               } \n"
+  "             }, \n"
+  "             \"mode\" : \"trackpad\", \n"
+  "             \"path\" : \"/user/hand/right/input/trackpad\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"pull\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_trigger_value\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"trigger\", \n"
+  "             \"path\" : \"/user/hand/left/input/trigger\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"pull\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_trigger_value\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"trigger\", \n"
+  "             \"path\" : \"/user/hand/right/input/trigger\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"click\" : { \n"
+  "                \"output\" : \"/actions/firefox/in/LHand_grip_pressed\" \n"
+  "              }, \n"
+  "               \"touch\" : { \n"
+  "                 \"output\" : \"/actions/firefox/in/LHand_grip_touched\" \n"
+  "              } \n"
+  "             }, \n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/left/input/grip\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"click\" : { \n"
+  "               \"output\" : \"/actions/firefox/in/RHand_grip_pressed\" \n"
+  "              }, \n"
+  "               \"touch\" : { \n"
+  "                \"output\" : \"/actions/firefox/in/RHand_grip_touched\" \n"
+  "              } \n"
+  "           }, \n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/right/input/grip\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"click\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_menu_pressed\"  \n"
+  "                   }, \n"
+  "                 \"touch\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_menu_touched\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/left/input/application_menu\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"click\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_menu_pressed\"  \n"
+  "                   }, \n"
+  "                 \"touch\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_menu_touched\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/right/input/application_menu\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"click\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_system_pressed\"  \n"
+  "                   }, \n"
+  "                 \"touch\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_system_touched\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/left/input/system\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"click\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_system_pressed\"  \n"
+  "                   }, \n"
+  "                 \"touch\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_system_touched\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/right/input/system\" \n"
+  "           } \n"
+  "         ]\n"
+  "     }\n"
+  "  }\n"
+  "}";
+  // clang-format on
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_BLINDING_OPENVRVIVEBINDING_H
diff --git a/gfx/vr/service/binding/OpenVRWMRBinding.h b/gfx/vr/service/binding/OpenVRWMRBinding.h
new file mode 100644
index 0000000000..09d1529b86
--- /dev/null
+++ b/gfx/vr/service/binding/OpenVRWMRBinding.h
@@ -0,0 +1,192 @@
+/* -*- 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 GFX_VR_BLINDING_OPENVRWMRBINDING_H
+#define GFX_VR_BLINDING_OPENVRWMRBINDING_H
+
+namespace mozilla {
+namespace gfx {
+
+struct OpenVRWMRBinding {
+  const char* binding =
+      // clang-format off
+  "{\n"
+  "  \"version\" : \"0.1\", \n"
+  "  \"controller_type\" : \"holographic_controller\", \n"
+  "  \"description\" : \"Bindings for Firefox OpenVR for the Windows Mixed Reality controller\", \n"
+  "  \"name\" : \"Firefox bindings for Windows Mixed Reality Controller\", \n"
+  "  \"bindings\" : { \n"
+  "     \"/actions/firefox\" : { \n"
+  "         \"poses\" : [        \n"
+  "           {                \n"
+  "             \"output\" : \"/actions/firefox/in/LHand_pose\", \n"
+  "              \"path\" : \"/user/hand/left/pose/raw\"     \n"
+  "            },\n"
+  "            {                                             \n"
+  "              \"output\" : \"/actions/firefox/in/RHand_pose\", \n"
+  "              \"path\" : \"/user/hand/right/pose/raw\"    \n"
+  "            }\n"
+  "         ],\n"
+  "         \"haptics\" : [ \n"
+  "            {\n"
+  "              \"output\" : \"/actions/firefox/out/LHand_haptic\",  \n"
+  "              \"path\" : \"/user/hand/left/output/haptic\"     \n"
+  "            },\n"
+  "            { \n"
+  "              \"output\" : \"/actions/firefox/out/RHand_haptic\", \n"
+  "              \"path\" : \"/user/hand/right/output/haptic\"    \n"
+  "            }\n"
+  "		  ],\n"
+  "       \"sources\" : [ \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"position\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_analog\" \n"
+  "               }, \n"
+  "               \"click\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_pressed\" \n"
+  "               }, \n"
+  "               \"touch\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/LHand_trackpad_touched\" \n"
+  "               } \n"
+  "             }, \n"
+  "             \"mode\" : \"trackpad\", \n"
+  "             \"path\" : \"/user/hand/left/input/trackpad\" \n"
+  "           },\n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"position\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_analog\" \n"
+  "               }, \n"
+  "               \"click\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_pressed\" \n"
+  "               }, \n"
+  "               \"touch\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/RHand_trackpad_touched\" \n"
+  "               } \n"
+  "             }, \n"
+  "             \"mode\" : \"trackpad\", \n"
+  "             \"path\" : \"/user/hand/right/input/trackpad\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"pull\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_trigger_value\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"trigger\", \n"
+  "             \"path\" : \"/user/hand/left/input/trigger\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"pull\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_trigger_value\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"trigger\", \n"
+  "             \"path\" : \"/user/hand/right/input/trigger\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"click\" : { \n"
+  "                \"output\" : \"/actions/firefox/in/LHand_grip_pressed\" \n"
+  "              }, \n"
+  "               \"touch\" : { \n"
+  "                 \"output\" : \"/actions/firefox/in/LHand_grip_touched\" \n"
+  "              } \n"
+  "             }, \n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/left/input/grip\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"click\" : { \n"
+  "                \"output\" : \"/actions/firefox/in/RHand_grip_pressed\" \n"
+  "              }, \n"
+  "               \"touch\" : { \n"
+  "                 \"output\" : \"/actions/firefox/in/RHand_grip_touched\" \n"
+  "              } \n"
+  "             }, \n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/right/input/grip\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"click\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_menu_pressed\"  \n"
+  "                   }, \n"
+  "                 \"touch\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_menu_touched\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/left/input/application_menu\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"click\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_menu_pressed\"  \n"
+  "                   }, \n"
+  "                 \"touch\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_menu_touched\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/right/input/application_menu\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"click\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_system_pressed\"  \n"
+  "                   }, \n"
+  "                 \"touch\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/LHand_system_touched\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/left/input/system\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "                 \"click\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_system_pressed\"  \n"
+  "                   }, \n"
+  "                 \"touch\" : { \n"
+  "                    \"output\" : \"/actions/firefox/in/RHand_system_touched\"  \n"
+  "                   } \n"
+  "              },\n"
+  "             \"mode\" : \"button\", \n"
+  "             \"path\" : \"/user/hand/right/input/system\" \n"
+  "           }, \n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"position\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/LHand_thumbstick_analog\" \n"
+  "               } \n"
+  "             }, \n"
+  "             \"mode\" : \"joystick\", \n"
+  "             \"path\" : \"/user/hand/left/input/joystick\" \n"
+  "           },\n"
+  "           {\n"
+  "             \"inputs\" : { \n"
+  "               \"position\" : { \n"
+  "                   \"output\" : \"/actions/firefox/in/RHand_thumbstick_analog\" \n"
+  "               } \n"
+  "             }, \n"
+  "             \"mode\" : \"joystick\", \n"
+  "             \"path\" : \"/user/hand/right/input/joystick\" \n"
+  "           } \n"
+  "         ]\n"
+  "     }\n"
+  "  }\n"
+  "}";
+  // clang-format on
+};
+
+}  // namespace gfx
+}  // namespace mozilla
+
+#endif  // GFX_VR_BLINDING_OPENVRWMRBINDING_H
diff --git a/gfx/vr/service/moz.build b/gfx/vr/service/moz.build
new file mode 100644
index 0000000000..5a90ad71bd
--- /dev/null
+++ b/gfx/vr/service/moz.build
@@ -0,0 +1,51 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+# Build Oculus support on Windows only
+if CONFIG["OS_TARGET"] == "WINNT":
+    SOURCES += [
+        "OculusSession.cpp",
+        "OpenVRWMRMapper.cpp",
+    ]
+
+# Build OSVR on all platforms except Android
+if CONFIG["OS_TARGET"] != "Android":
+    UNIFIED_SOURCES += [
+        "OSVRSession.cpp",
+        "VRService.cpp",
+        "VRSession.cpp",
+    ]
+    # PuppetSession includes MacIOSurface.h which includes Mac headers
+    # which define Size and Points types in the root namespace that
+    # often conflict with our own types.
+    SOURCES += [
+        "PuppetSession.cpp",
+    ]
+    include("/ipc/chromium/chromium-config.mozbuild")
+
+# Build OpenVR on Windows, Linux, and macOS desktop targets.
+# TARGET_OS shadows target.os in our configure system, so we can check that to
+# get Windows and macOS, but not Linux. For Linux we check OS_TARGET which
+# generifies to "Linux" for all Linux distros.
+if CONFIG["TARGET_OS"] in ("WINNT", "OSX") or CONFIG["OS_TARGET"] == "Linux":
+    DIRS += [
+        "openvr",
+    ]
+    LOCAL_INCLUDES += ["/dom/base", "/gfx/layers/d3d11"]
+
+    # OpenVRSession includes MacIOSurface.h which includes Mac headers
+    # which define Size and Points types in the root namespace that
+    # often conflict with our own types.
+    SOURCES += [
+        "OpenVRControllerMapper.cpp",
+        "OpenVRCosmosMapper.cpp",
+        "OpenVRDefaultMapper.cpp",
+        "OpenVRKnucklesMapper.cpp",
+        "OpenVRSession.cpp",
+        "OpenVRViveMapper.cpp",
+    ]
+
+FINAL_LIBRARY = "xul"
diff --git a/gfx/vr/service/oculus/ovr_capi_dynamic.h b/gfx/vr/service/oculus/ovr_capi_dynamic.h
new file mode 100644
index 0000000000..77eb0a3aa0
--- /dev/null
+++ b/gfx/vr/service/oculus/ovr_capi_dynamic.h
@@ -0,0 +1,984 @@
+/* -*- 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/. */
+
+/* This file contains just the needed struct definitions for
+ * interacting with the Oculus VR C API, without needing to #include
+ * OVR_CAPI.h directly.  Note that it uses the same type names as the
+ * CAPI, and cannot be #included at the same time as OVR_CAPI.h.  It
+ * does not include the entire C API, just want's needed.
+ */
+
+#ifdef OVR_CAPI_h
+#  ifdef _MSC_VER
+#    pragma message( \
+        "ovr_capi_dyanmic.h: OVR_CAPI.h included before ovr_capi_dynamic.h, skipping this")
+#  else
+#    warning OVR_CAPI.h included before ovr_capi_dynamic.h, skipping this
+#  endif
+#  define mozilla_ovr_capi_dynamic_h_
+
+#else
+
+#  ifndef mozilla_ovr_capi_dynamic_h_
+#    define mozilla_ovr_capi_dynamic_h_
+
+#    ifdef HAVE_64BIT_BUILD
+#      define OVR_PTR_SIZE 8
+#      define OVR_ON64(x) x
+#    else
+#      define OVR_PTR_SIZE 4
+#      define OVR_ON64(x) /**/
+#    endif
+
+#    if defined(_WIN32)
+#      define OVR_PFN __cdecl
+#    else
+#      define OVR_PFN
+#    endif
+
+#    if !defined(OVR_ALIGNAS)
+#      if defined(__GNUC__) || defined(__clang__)
+#        define OVR_ALIGNAS(n) __attribute__((aligned(n)))
+#      elif defined(_MSC_VER) || defined(__INTEL_COMPILER)
+#        define OVR_ALIGNAS(n) __declspec(align(n))
+#      elif defined(__CC_ARM)
+#        define OVR_ALIGNAS(n) __align(n)
+#      else
+#        error Need to define OVR_ALIGNAS
+#      endif
+#    endif
+
+#    if !defined(OVR_UNUSED_STRUCT_PAD)
+#      define OVR_UNUSED_STRUCT_PAD(padName, size) char padName[size];
+#    endif
+
+#    ifdef __cplusplus
+extern "C" {
+#    endif
+
+typedef int32_t ovrResult;
+
+typedef enum {
+  ovrSuccess = 0,
+} ovrSuccessType;
+
+typedef char ovrBool;
+typedef struct OVR_ALIGNAS(4) {
+  float r, g, b, a;
+} ovrColorf;
+typedef struct OVR_ALIGNAS(4) {
+  int x, y;
+} ovrVector2i;
+typedef struct OVR_ALIGNAS(4) {
+  int w, h;
+} ovrSizei;
+typedef struct OVR_ALIGNAS(4) {
+  ovrVector2i Pos;
+  ovrSizei Size;
+} ovrRecti;
+typedef struct OVR_ALIGNAS(4) {
+  float x, y, z, w;
+} ovrQuatf;
+typedef struct OVR_ALIGNAS(4) {
+  float x, y;
+} ovrVector2f;
+typedef struct OVR_ALIGNAS(4) {
+  float x, y, z;
+} ovrVector3f;
+typedef struct OVR_ALIGNAS(4) {
+  float M[4][4];
+} ovrMatrix4f;
+
+typedef struct OVR_ALIGNAS(4) {
+  ovrQuatf Orientation;
+  ovrVector3f Position;
+} ovrPosef;
+
+typedef struct OVR_ALIGNAS(8) {
+  ovrPosef ThePose;
+  ovrVector3f AngularVelocity;
+  ovrVector3f LinearVelocity;
+  ovrVector3f AngularAcceleration;
+  ovrVector3f LinearAcceleration;
+  OVR_UNUSED_STRUCT_PAD(pad0, 4)
+  double TimeInSeconds;
+} ovrPoseStatef;
+
+typedef struct {
+  float UpTan;
+  float DownTan;
+  float LeftTan;
+  float RightTan;
+} ovrFovPort;
+
+typedef enum {
+  ovrHmd_None = 0,
+  ovrHmd_DK1 = 3,
+  ovrHmd_DKHD = 4,
+  ovrHmd_DK2 = 6,
+  ovrHmd_CB = 8,
+  ovrHmd_Other = 9,
+  ovrHmd_E3_2015 = 10,
+  ovrHmd_ES06 = 11,
+  ovrHmd_ES09 = 12,
+  ovrHmd_ES11 = 13,
+  ovrHmd_CV1 = 14,
+  ovrHmd_EnumSize = 0x7fffffff
+} ovrHmdType;
+
+typedef enum {
+  ovrHmdCap_DebugDevice = 0x0010,
+  ovrHmdCap_EnumSize = 0x7fffffff
+} ovrHmdCaps;
+
+typedef enum {
+  ovrTrackingCap_Orientation = 0x0010,
+  ovrTrackingCap_MagYawCorrection = 0x0020,
+  ovrTrackingCap_Position = 0x0040,
+  ovrTrackingCap_EnumSize = 0x7fffffff
+} ovrTrackingCaps;
+
+typedef enum {
+  ovrExtension_TextureLayout_Octilinear = 0,
+  ovrExtension_Count,
+  ovrExtension_EnumSize = 0x7fffffff
+} ovrExtensions;
+
+typedef enum {
+  ovrEye_Left = 0,
+  ovrEye_Right = 1,
+  ovrEye_Count = 2,
+  ovrEye_EnumSize = 0x7fffffff
+} ovrEyeType;
+
+typedef enum {
+  ovrTrackingOrigin_EyeLevel = 0,
+  ovrTrackingOrigin_FloorLevel = 1,
+  ovrTrackingOrigin_Count = 2,  ///< \internal Count of enumerated elements.
+  ovrTrackingOrigin_EnumSize = 0x7fffffff  ///< \internal Force type int32_t.
+} ovrTrackingOrigin;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  char Reserved[8];
+} ovrGraphicsLuid;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  ovrHmdType Type;
+  OVR_ON64(OVR_UNUSED_STRUCT_PAD(pad0, 4))
+  char ProductName[64];
+  char Manufacturer[64];
+  short VendorId;
+  short ProductId;
+  char SerialNumber[24];
+  short FirmwareMajor;
+  short FirmwareMinor;
+  unsigned int AvailableHmdCaps;
+  unsigned int DefaultHmdCaps;
+  unsigned int AvailableTrackingCaps;
+  unsigned int DefaultTrackingCaps;
+  ovrFovPort DefaultEyeFov[ovrEye_Count];
+  ovrFovPort MaxEyeFov[ovrEye_Count];
+  ovrSizei Resolution;
+  float DisplayRefreshRate;
+  OVR_ON64(OVR_UNUSED_STRUCT_PAD(pad1, 4))
+} ovrHmdDesc;
+
+typedef struct ovrHmdStruct* ovrSession;
+
+#    ifdef XP_WIN
+typedef uint32_t ovrProcessId;
+#    else
+typedef pid_t ovrProcessId;
+#    endif
+
+typedef enum {
+  ovrStatus_OrientationTracked = 0x0001,
+  ovrStatus_PositionTracked = 0x0002,
+  ovrStatus_EnumSize = 0x7fffffff
+} ovrStatusBits;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  float FrustumHFovInRadians;
+  float FrustumVFovInRadians;
+  float FrustumNearZInMeters;
+  float FrustumFarZInMeters;
+} ovrTrackerDesc;
+
+typedef enum {
+  ovrTracker_Connected = 0x0020,
+  ovrTracker_PoseTracked = 0x0004
+} ovrTrackerFlags;
+
+typedef struct OVR_ALIGNAS(8) {
+  unsigned int TrackerFlags;
+  ovrPosef Pose;
+  ovrPosef LeveledPose;
+  OVR_UNUSED_STRUCT_PAD(pad0, 4)
+} ovrTrackerPose;
+
+typedef struct OVR_ALIGNAS(8) {
+  ovrPoseStatef HeadPose;
+  unsigned int StatusFlags;
+  ovrPoseStatef HandPoses[2];
+  unsigned int HandStatusFlags[2];
+  ovrPosef CalibratedOrigin;
+} ovrTrackingState;
+
+typedef struct OVR_ALIGNAS(4) {
+  ovrEyeType Eye;
+  ovrFovPort Fov;
+  ovrRecti DistortedViewport;
+  ovrVector2f PixelsPerTanAngleAtCenter;
+  ovrPosef HmdToEyePose;
+} ovrEyeRenderDesc;
+
+typedef struct OVR_ALIGNAS(4) {
+  float Projection22;
+  float Projection23;
+  float Projection32;
+} ovrTimewarpProjectionDesc;
+
+typedef struct OVR_ALIGNAS(4) {
+  ovrPosef HmdToEyePose[ovrEye_Count];
+  float HmdSpaceToWorldScaleInMeters;
+} ovrViewScaleDesc;
+
+typedef enum {
+  ovrTexture_2D,
+  ovrTexture_2D_External,
+  ovrTexture_Cube,
+  ovrTexture_Count,
+  ovrTexture_EnumSize = 0x7fffffff
+} ovrTextureType;
+
+typedef enum {
+  ovrTextureBind_None,
+  ovrTextureBind_DX_RenderTarget = 0x0001,
+  ovrTextureBind_DX_UnorderedAccess = 0x0002,
+  ovrTextureBind_DX_DepthStencil = 0x0004,
+  ovrTextureBind_EnumSize = 0x7fffffff
+} ovrTextureBindFlags;
+
+typedef enum {
+  OVR_FORMAT_UNKNOWN = 0,
+  OVR_FORMAT_B5G6R5_UNORM = 1,
+  OVR_FORMAT_B5G5R5A1_UNORM = 2,
+  OVR_FORMAT_B4G4R4A4_UNORM = 3,
+  OVR_FORMAT_R8G8B8A8_UNORM = 4,
+  OVR_FORMAT_R8G8B8A8_UNORM_SRGB = 5,
+  OVR_FORMAT_B8G8R8A8_UNORM = 6,
+  OVR_FORMAT_B8G8R8A8_UNORM_SRGB = 7,
+  OVR_FORMAT_B8G8R8X8_UNORM = 8,
+  OVR_FORMAT_B8G8R8X8_UNORM_SRGB = 9,
+  OVR_FORMAT_R16G16B16A16_FLOAT = 10,
+  OVR_FORMAT_R11G11B10_FLOAT = 25,
+  OVR_FORMAT_D16_UNORM = 11,
+  OVR_FORMAT_D24_UNORM_S8_UINT = 12,
+  OVR_FORMAT_D32_FLOAT = 13,
+  OVR_FORMAT_D32_FLOAT_S8X24_UINT = 14,
+  OVR_FORMAT_BC1_UNORM = 15,
+  OVR_FORMAT_BC1_UNORM_SRGB = 16,
+  OVR_FORMAT_BC2_UNORM = 17,
+  OVR_FORMAT_BC2_UNORM_SRGB = 18,
+  OVR_FORMAT_BC3_UNORM = 19,
+  OVR_FORMAT_BC3_UNORM_SRGB = 20,
+  OVR_FORMAT_BC6H_UF16 = 21,
+  OVR_FORMAT_BC6H_SF16 = 22,
+  OVR_FORMAT_BC7_UNORM = 23,
+  OVR_FORMAT_BC7_UNORM_SRGB = 24,
+
+  OVR_FORMAT_ENUMSIZE = 0x7fffffff
+} ovrTextureFormat;
+
+typedef enum {
+  ovrTextureMisc_None,
+  ovrTextureMisc_DX_Typeless = 0x0001,
+  ovrTextureMisc_AllowGenerateMips = 0x0002,
+  ovrTextureMisc_ProtectedContent = 0x0004,
+  ovrTextureMisc_AutoGenerateMips = 0x0008,
+  ovrTextureMisc_EnumSize = 0x7fffffff
+} ovrTextureFlags;
+
+typedef struct {
+  ovrTextureType Type;
+  ovrTextureFormat Format;
+  int ArraySize;
+  int Width;
+  int Height;
+  int MipLevels;
+  int SampleCount;
+  ovrBool StaticImage;
+  unsigned int MiscFlags;
+  unsigned int BindFlags;
+} ovrTextureSwapChainDesc;
+
+typedef struct {
+  ovrTextureFormat Format;
+  int Width;
+  int Height;
+  unsigned int MiscFlags;
+  unsigned int MirrorOptions;
+} ovrMirrorTextureDesc;
+
+typedef struct ovrTextureSwapChainData* ovrTextureSwapChain;
+typedef struct ovrMirrorTextureData* ovrMirrorTexture;
+
+typedef enum {
+  ovrButton_A = 0x00000001,
+  ovrButton_B = 0x00000002,
+  ovrButton_RThumb = 0x00000004,
+  ovrButton_RShoulder = 0x00000008,
+  ovrButton_X = 0x00000100,
+  ovrButton_Y = 0x00000200,
+  ovrButton_LThumb = 0x00000400,
+  ovrButton_LShoulder = 0x00000800,
+  ovrButton_Up = 0x00010000,
+  ovrButton_Down = 0x00020000,
+  ovrButton_Left = 0x00040000,
+  ovrButton_Right = 0x00080000,
+  ovrButton_Enter = 0x00100000,
+  ovrButton_Back = 0x00200000,
+  ovrButton_VolUp = 0x00400000,
+  ovrButton_VolDown = 0x00800000,
+  ovrButton_Home = 0x01000000,
+  ovrButton_Private = ovrButton_VolUp | ovrButton_VolDown | ovrButton_Home,
+  ovrButton_RMask =
+      ovrButton_A | ovrButton_B | ovrButton_RThumb | ovrButton_RShoulder,
+  ovrButton_LMask = ovrButton_X | ovrButton_Y | ovrButton_LThumb |
+                    ovrButton_LShoulder | ovrButton_Enter,
+  ovrButton_EnumSize = 0x7fffffff
+} ovrButton;
+
+typedef enum {
+  ovrTouch_A = ovrButton_A,
+  ovrTouch_B = ovrButton_B,
+  ovrTouch_RThumb = ovrButton_RThumb,
+  ovrTouch_RThumbRest = 0x00000008,
+  ovrTouch_RIndexTrigger = 0x00000010,
+  ovrTouch_RButtonMask = ovrTouch_A | ovrTouch_B | ovrTouch_RThumb |
+                         ovrTouch_RThumbRest | ovrTouch_RIndexTrigger,
+  ovrTouch_X = ovrButton_X,
+  ovrTouch_Y = ovrButton_Y,
+  ovrTouch_LThumb = ovrButton_LThumb,
+  ovrTouch_LThumbRest = 0x00000800,
+  ovrTouch_LIndexTrigger = 0x00001000,
+  ovrTouch_LButtonMask = ovrTouch_X | ovrTouch_Y | ovrTouch_LThumb |
+                         ovrTouch_LThumbRest | ovrTouch_LIndexTrigger,
+  ovrTouch_RIndexPointing = 0x00000020,
+  ovrTouch_RThumbUp = 0x00000040,
+  ovrTouch_LIndexPointing = 0x00002000,
+  ovrTouch_LThumbUp = 0x00004000,
+  ovrTouch_RPoseMask = ovrTouch_RIndexPointing | ovrTouch_RThumbUp,
+  ovrTouch_LPoseMask = ovrTouch_LIndexPointing | ovrTouch_LThumbUp,
+  ovrTouch_EnumSize = 0x7fffffff
+} ovrTouch;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  int SampleRateHz;
+  int SampleSizeInBytes;
+  int QueueMinSizeToAvoidStarvation;
+  int SubmitMinSamples;
+  int SubmitMaxSamples;
+  int SubmitOptimalSamples;
+} ovrTouchHapticsDesc;
+
+typedef enum {
+  ovrControllerType_None = 0x0000,
+  ovrControllerType_LTouch = 0x0001,
+  ovrControllerType_RTouch = 0x0002,
+  ovrControllerType_Touch =
+      (ovrControllerType_LTouch | ovrControllerType_RTouch),
+  ovrControllerType_Remote = 0x0004,
+  ovrControllerType_XBox = 0x0010,
+  ovrControllerType_Object0 = 0x0100,
+  ovrControllerType_Object1 = 0x0200,
+  ovrControllerType_Object2 = 0x0400,
+  ovrControllerType_Object3 = 0x0800,
+  ovrControllerType_Active = 0xffffffff,
+  ovrControllerType_EnumSize = 0x7fffffff
+} ovrControllerType;
+
+typedef enum { ovrHapticsBufferSubmit_Enqueue } ovrHapticsBufferSubmitMode;
+
+#    define OVR_HAPTICS_BUFFER_SAMPLES_MAX 256
+
+typedef struct {
+  const void* Samples;
+  int SamplesCount;
+  ovrHapticsBufferSubmitMode SubmitMode;
+} ovrHapticsBuffer;
+
+typedef struct {
+  int RemainingQueueSpace;
+  int SamplesQueued;
+} ovrHapticsPlaybackState;
+
+typedef enum {
+  ovrTrackedDevice_None = 0x0000,
+  ovrTrackedDevice_HMD = 0x0001,
+  ovrTrackedDevice_LTouch = 0x0002,
+  ovrTrackedDevice_RTouch = 0x0004,
+  ovrTrackedDevice_Touch = (ovrTrackedDevice_LTouch | ovrTrackedDevice_RTouch),
+  ovrTrackedDevice_Object0 = 0x0010,
+  ovrTrackedDevice_Object1 = 0x0020,
+  ovrTrackedDevice_Object2 = 0x0040,
+  ovrTrackedDevice_Object3 = 0x0080,
+  ovrTrackedDevice_All = 0xFFFF,
+} ovrTrackedDeviceType;
+
+typedef enum {
+  ovrBoundary_Outer = 0x0001,
+  ovrBoundary_PlayArea = 0x0100,
+} ovrBoundaryType;
+
+typedef struct {
+  ovrColorf Color;
+} ovrBoundaryLookAndFeel;
+
+typedef struct {
+  ovrBool IsTriggering;
+  float ClosestDistance;
+  ovrVector3f ClosestPoint;
+  ovrVector3f ClosestPointNormal;
+} ovrBoundaryTestResult;
+
+typedef enum {
+  ovrHand_Left = 0,
+  ovrHand_Right = 1,
+  ovrHand_Count = 2,
+  ovrHand_EnumSize = 0x7fffffff
+} ovrHandType;
+
+typedef struct {
+  double TimeInSeconds;
+  unsigned int Buttons;
+  unsigned int Touches;
+  float IndexTrigger[ovrHand_Count];
+  float HandTrigger[ovrHand_Count];
+  ovrVector2f Thumbstick[ovrHand_Count];
+  ovrControllerType ControllerType;
+  float IndexTriggerNoDeadzone[ovrHand_Count];
+  float HandTriggerNoDeadzone[ovrHand_Count];
+  ovrVector2f ThumbstickNoDeadzone[ovrHand_Count];
+  float IndexTriggerRaw[ovrHand_Count];
+  float HandTriggerRaw[ovrHand_Count];
+  ovrVector2f ThumbstickRaw[ovrHand_Count];
+} ovrInputState;
+
+typedef struct {
+  double LastChangedTime;
+  ovrFovPort FOVPort;
+  float VirtualNearPlaneDistanceMeters;
+  float VirtualFarPlaneDistanceMeters;
+  ovrSizei ImageSensorPixelResolution;
+  ovrMatrix4f LensDistortionMatrix;
+  double ExposurePeriodSeconds;
+  double ExposureDurationSeconds;
+} ovrCameraIntrinsics;
+
+typedef enum {
+  ovrCameraStatus_None = 0x0,
+  ovrCameraStatus_Connected = 0x1,
+  ovrCameraStatus_Calibrating = 0x2,
+  ovrCameraStatus_CalibrationFailed = 0x4,
+  ovrCameraStatus_Calibrated = 0x8,
+  ovrCameraStatus_EnumSize = 0x7fffffff
+} ovrCameraStatusFlags;
+
+typedef struct {
+  double LastChangedTimeSeconds;
+  unsigned int CameraStatusFlags;
+  ovrTrackedDeviceType AttachedToDevice;
+  ovrPosef RelativePose;
+  double LastExposureTimeSeconds;
+  double ExposureLatencySeconds;
+  double AdditionalLatencySeconds;
+} ovrCameraExtrinsics;
+
+#    define OVR_EXTERNAL_CAMERA_NAME_SIZE 32
+typedef struct {
+  char Name[OVR_EXTERNAL_CAMERA_NAME_SIZE];
+  ovrCameraIntrinsics Intrinsics;
+  ovrCameraExtrinsics Extrinsics;
+} ovrExternalCamera;
+
+typedef enum {
+  ovrInit_Debug = 0x00000001,
+  ovrInit_RequestVersion = 0x00000004,
+  ovrInit_Invisible = 0x00000010,
+  ovrInit_MixedRendering = 0x00000020,
+  ovrInit_FocusAware = 0x00000040,
+  ovrinit_WritableBits = 0x00ffffff,
+  ovrInit_EnumSize = 0x7fffffff
+} ovrInitFlags;
+
+typedef enum {
+  ovrLogLevel_Debug = 0,
+  ovrLogLevel_Info = 1,
+  ovrLogLevel_Error = 2,
+  ovrLogLevel_EnumSize = 0x7fffffff
+} ovrLogLevel;
+
+typedef void(OVR_PFN* ovrLogCallback)(uintptr_t userData, int level,
+                                      const char* message);
+
+typedef struct OVR_ALIGNAS(8) {
+  uint32_t Flags;
+  uint32_t RequestedMinorVersion;
+  ovrLogCallback LogCallback;
+  uintptr_t UserData;
+  uint32_t ConnectionTimeoutMS;
+  OVR_ON64(OVR_UNUSED_STRUCT_PAD(pad0, 4))
+} ovrInitParams;
+
+typedef ovrResult(OVR_PFN* pfn_ovr_Initialize)(const ovrInitParams* params);
+typedef void(OVR_PFN* pfn_ovr_Shutdown)();
+
+typedef struct {
+  ovrResult Result;
+  char ErrorString[512];
+} ovrErrorInfo;
+
+typedef void(OVR_PFN* pfn_ovr_GetLastErrorInfo)(ovrErrorInfo* errorInfo);
+typedef const char*(OVR_PFN* pfn_ovr_GetVersionString)();
+typedef int(OVR_PFN* pfn_ovr_TraceMessage)(int level, const char* message);
+typedef ovrResult(OVR_PFN* pfn_ovr_IdentifyClient)(const char* identity);
+typedef ovrHmdDesc(OVR_PFN* pfn_ovr_GetHmdDesc)(ovrSession session);
+typedef unsigned int(OVR_PFN* pfn_ovr_GetTrackerCount)(ovrSession session);
+typedef ovrTrackerDesc(OVR_PFN* pfn_ovr_GetTrackerDesc)(
+    ovrSession session, unsigned int trackerDescIndex);
+typedef ovrResult(OVR_PFN* pfn_ovr_Create)(ovrSession* pSession,
+                                           ovrGraphicsLuid* pLuid);
+typedef void(OVR_PFN* pfn_ovr_Destroy)(ovrSession session);
+
+typedef struct {
+  ovrBool IsVisible;
+  ovrBool HmdPresent;
+  ovrBool HmdMounted;
+  ovrBool DisplayLost;
+  ovrBool ShouldQuit;
+  ovrBool ShouldRecenter;
+  ovrBool HasInputFocus;
+  ovrBool OverlayPresent;
+} ovrSessionStatus;
+
+typedef ovrResult(OVR_PFN* pfn_ovr_GetSessionStatus)(
+    ovrSession session, ovrSessionStatus* sessionStatus);
+typedef ovrResult(OVR_PFN* pfn_ovr_IsExtensionSupported)(
+    ovrSession session, ovrExtensions extension,
+    ovrBool* outExtensionSupported);
+typedef ovrResult(OVR_PFN* pfn_ovr_EnableExtension)(ovrSession session,
+                                                    ovrExtensions extension);
+typedef ovrResult(OVR_PFN* pfn_ovr_SetTrackingOriginType)(
+    ovrSession session, ovrTrackingOrigin origin);
+typedef ovrTrackingOrigin(OVR_PFN* pfn_ovr_GetTrackingOriginType)(
+    ovrSession session);
+typedef ovrResult(OVR_PFN* pfn_ovr_RecenterTrackingOrigin)(ovrSession session);
+typedef ovrResult(OVR_PFN* pfn_ovr_SpecifyTrackingOrigin)(ovrSession session,
+                                                          ovrPosef originPose);
+typedef void(OVR_PFN* pfn_ovr_ClearShouldRecenterFlag)(ovrSession session);
+typedef ovrTrackingState(OVR_PFN* pfn_ovr_GetTrackingState)(
+    ovrSession session, double absTime, ovrBool latencyMarker);
+typedef ovrResult(OVR_PFN* pfn_ovr_GetDevicePoses)(
+    ovrSession session, ovrTrackedDeviceType* deviceTypes, int deviceCount,
+    double absTime, ovrPoseStatef* outDevicePoses);
+typedef ovrTrackerPose(OVR_PFN* pfn_ovr_GetTrackerPose)(
+    ovrSession session, unsigned int trackerPoseIndex);
+typedef ovrResult(OVR_PFN* pfn_ovr_GetInputState)(
+    ovrSession session, ovrControllerType controllerType,
+    ovrInputState* inputState);
+typedef unsigned int(OVR_PFN* pfn_ovr_GetConnectedControllerTypes)(
+    ovrSession session);
+typedef ovrTouchHapticsDesc(OVR_PFN* pfn_ovr_GetTouchHapticsDesc)(
+    ovrSession session, ovrControllerType controllerType);
+typedef ovrResult(OVR_PFN* pfn_ovr_SetControllerVibration)(
+    ovrSession session, ovrControllerType controllerType, float frequency,
+    float amplitude);
+typedef ovrResult(OVR_PFN* pfn_ovr_SubmitControllerVibration)(
+    ovrSession session, ovrControllerType controllerType,
+    const ovrHapticsBuffer* buffer);
+typedef ovrResult(OVR_PFN* pfn_ovr_GetControllerVibrationState)(
+    ovrSession session, ovrControllerType controllerType,
+    ovrHapticsPlaybackState* outState);
+typedef ovrResult(OVR_PFN* pfn_ovr_TestBoundary)(
+    ovrSession session, ovrTrackedDeviceType deviceBitmask,
+    ovrBoundaryType boundaryType, ovrBoundaryTestResult* outTestResult);
+typedef ovrResult(OVR_PFN* pfn_ovr_TestBoundaryPoint)(
+    ovrSession session, const ovrVector3f* point,
+    ovrBoundaryType singleBoundaryType, ovrBoundaryTestResult* outTestResult);
+typedef ovrResult(OVR_PFN* pfn_ovr_SetBoundaryLookAndFeel)(
+    ovrSession session, const ovrBoundaryLookAndFeel* lookAndFeel);
+typedef ovrResult(OVR_PFN* pfn_ovr_ResetBoundaryLookAndFeel)(
+    ovrSession session);
+typedef ovrResult(OVR_PFN* pfn_ovr_GetBoundaryGeometry)(
+    ovrSession session, ovrBoundaryType boundaryType,
+    ovrVector3f* outFloorPoints, int* outFloorPointsCount);
+typedef ovrResult(OVR_PFN* pfn_ovr_GetBoundaryDimensions)(
+    ovrSession session, ovrBoundaryType boundaryType,
+    ovrVector3f* outDimensions);
+typedef ovrResult(OVR_PFN* pfn_ovr_GetBoundaryVisible)(ovrSession session,
+                                                       ovrBool* outIsVisible);
+typedef ovrResult(OVR_PFN* pfn_ovr_RequestBoundaryVisible)(ovrSession session,
+                                                           ovrBool visible);
+
+enum { ovrMaxLayerCount = 16 };
+
+typedef enum {
+  ovrLayerType_Disabled = 0,
+  ovrLayerType_EyeFov = 1,
+  ovrLayerType_Quad = 3,
+  ovrLayerType_EyeMatrix = 5,
+  ovrLayerType_EyeFovMultires = 7,
+  ovrLayerType_Cube = 10,
+  ovrLayerType_EnumSize = 0x7fffffff
+} ovrLayerType;
+
+typedef enum {
+  ovrLayerFlag_HighQuality = 0x01,
+  ovrLayerFlag_TextureOriginAtBottomLeft = 0x02,
+  ovrLayerFlag_HeadLocked = 0x04
+} ovrLayerFlags;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  ovrLayerType Type;
+  unsigned Flags;
+} ovrLayerHeader;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  ovrLayerHeader Header;
+  ovrTextureSwapChain ColorTexture[ovrEye_Count];
+  ovrRecti Viewport[ovrEye_Count];
+  ovrFovPort Fov[ovrEye_Count];
+  ovrPosef RenderPose[ovrEye_Count];
+  double SensorSampleTime;
+} ovrLayerEyeFov;
+
+typedef enum {
+  ovrTextureLayout_Rectilinear = 0,
+  ovrTextureLayout_Octilinear = 1,
+  ovrTextureLayout_EnumSize = 0x7fffffff
+} ovrTextureLayout;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  float WarpLeft;
+  float WarpRight;
+  float WarpUp;
+  float WarpDown;
+  float SizeLeft;
+  float SizeRight;
+  float SizeUp;
+  float SizeDown;
+
+} ovrTextureLayoutOctilinear;
+
+typedef union OVR_ALIGNAS(OVR_PTR_SIZE) {
+  ovrTextureLayoutOctilinear Octilinear[ovrEye_Count];
+} ovrTextureLayoutDesc_Union;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  ovrLayerHeader Header;
+  ovrTextureSwapChain ColorTexture[ovrEye_Count];
+  ovrRecti Viewport[ovrEye_Count];
+  ovrFovPort Fov[ovrEye_Count];
+  ovrPosef RenderPose[ovrEye_Count];
+  double SensorSampleTime;
+  ovrTextureLayout TextureLayout;
+  ovrTextureLayoutDesc_Union TextureLayoutDesc;
+} ovrLayerEyeFovMultires;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  ovrLayerHeader Header;
+  ovrTextureSwapChain ColorTexture[ovrEye_Count];
+  ovrRecti Viewport[ovrEye_Count];
+  ovrPosef RenderPose[ovrEye_Count];
+  ovrMatrix4f Matrix[ovrEye_Count];
+  double SensorSampleTime;
+} ovrLayerEyeMatrix;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  ovrLayerHeader Header;
+  ovrTextureSwapChain ColorTexture;
+  ovrRecti Viewport;
+  ovrPosef QuadPoseCenter;
+  ovrVector2f QuadSize;
+} ovrLayerQuad;
+
+typedef struct OVR_ALIGNAS(OVR_PTR_SIZE) {
+  ovrLayerHeader Header;
+  ovrQuatf Orientation;
+  ovrTextureSwapChain CubeMapTexture;
+} ovrLayerCube;
+
+typedef union {
+  ovrLayerHeader Header;
+  ovrLayerEyeFov EyeFov;
+  ovrLayerQuad Quad;
+  ovrLayerEyeFovMultires Multires;
+  ovrLayerCube Cube;
+} ovrLayer_Union;
+
+typedef ovrResult(OVR_PFN* pfn_ovr_GetTextureSwapChainLength)(
+    ovrSession session, ovrTextureSwapChain chain, int* out_Length);
+typedef ovrResult(OVR_PFN* pfn_ovr_GetTextureSwapChainCurrentIndex)(
+    ovrSession session, ovrTextureSwapChain chain, int* out_Index);
+typedef ovrResult(OVR_PFN* pfn_ovr_GetTextureSwapChainDesc)(
+    ovrSession session, ovrTextureSwapChain chain,
+    ovrTextureSwapChainDesc* out_Desc);
+typedef ovrResult(OVR_PFN* pfn_ovr_CommitTextureSwapChain)(
+    ovrSession session, ovrTextureSwapChain chain);
+typedef void(OVR_PFN* pfn_ovr_DestroyTextureSwapChain)(
+    ovrSession session, ovrTextureSwapChain chain);
+typedef void(OVR_PFN* pfn_ovr_DestroyMirrorTexture)(
+    ovrSession session, ovrMirrorTexture mirrorTexture);
+typedef ovrSizei(OVR_PFN* pfn_ovr_GetFovTextureSize)(
+    ovrSession session, ovrEyeType eye, ovrFovPort fov,
+    float pixelsPerDisplayPixel);
+typedef ovrEyeRenderDesc(OVR_PFN* pfn_ovr_GetRenderDesc2)(ovrSession session,
+                                                          ovrEyeType eyeType,
+                                                          ovrFovPort fov);
+typedef ovrResult(OVR_PFN* pfn_ovr_WaitToBeginFrame)(ovrSession session,
+                                                     long long frameIndex);
+typedef ovrResult(OVR_PFN* pfn_ovr_BeginFrame)(ovrSession session,
+                                               long long frameIndex);
+typedef ovrResult(OVR_PFN* pfn_ovr_EndFrame)(
+    ovrSession session, long long frameIndex,
+    const ovrViewScaleDesc* viewScaleDesc,
+    ovrLayerHeader const* const* layerPtrList, unsigned int layerCount);
+typedef ovrResult(OVR_PFN* pfn_ovr_SubmitFrame)(
+    ovrSession session, long long frameIndex,
+    const ovrViewScaleDesc* viewScaleDesc,
+    ovrLayerHeader const* const* layerPtrList, unsigned int layerCount);
+
+typedef struct OVR_ALIGNAS(4) {
+  int HmdVsyncIndex;
+  int AppFrameIndex;
+  int AppDroppedFrameCount;
+  float AppMotionToPhotonLatency;
+  float AppQueueAheadTime;
+  float AppCpuElapsedTime;
+  float AppGpuElapsedTime;
+  int CompositorFrameIndex;
+  int CompositorDroppedFrameCount;
+  float CompositorLatency;
+  float CompositorCpuElapsedTime;
+  float CompositorGpuElapsedTime;
+  float CompositorCpuStartToGpuEndElapsedTime;
+  float CompositorGpuEndToVsyncElapsedTime;
+  ovrBool AswIsActive;
+  int AswActivatedToggleCount;
+  int AswPresentedFrameCount;
+  int AswFailedFrameCount;
+} ovrPerfStatsPerCompositorFrame;
+
+enum { ovrMaxProvidedFrameStats = 5 };
+
+typedef struct OVR_ALIGNAS(4) {
+  ovrPerfStatsPerCompositorFrame FrameStats[ovrMaxProvidedFrameStats];
+  int FrameStatsCount;
+  ovrBool AnyFrameStatsDropped;
+  float AdaptiveGpuPerformanceScale;
+  ovrBool AswIsAvailable;
+  ovrProcessId VisibleProcessId;
+} ovrPerfStats;
+
+typedef ovrResult(OVR_PFN* pfn_ovr_GetPerfStats)(ovrSession session,
+                                                 ovrPerfStats* outStats);
+typedef ovrResult(OVR_PFN* pfn_ovr_ResetPerfStats)(ovrSession session);
+typedef double(OVR_PFN* pfn_ovr_GetPredictedDisplayTime)(ovrSession session,
+                                                         long long frameIndex);
+typedef double(OVR_PFN* pfn_ovr_GetTimeInSeconds)();
+
+typedef enum {
+  ovrPerfHud_Off = 0,
+  ovrPerfHud_PerfSummary = 1,
+  ovrPerfHud_LatencyTiming = 2,
+  ovrPerfHud_AppRenderTiming = 3,
+  ovrPerfHud_CompRenderTiming = 4,
+  ovrPerfHud_AswStats = 6,
+  ovrPerfHud_VersionInfo = 5,
+  ovrPerfHud_Count = 7,
+  ovrPerfHud_EnumSize = 0x7fffffff
+} ovrPerfHudMode;
+
+typedef enum {
+  ovrLayerHud_Off = 0,
+  ovrLayerHud_Info = 1,
+  ovrLayerHud_EnumSize = 0x7fffffff
+} ovrLayerHudMode;
+
+typedef enum {
+  ovrDebugHudStereo_Off = 0,
+  ovrDebugHudStereo_Quad = 1,
+  ovrDebugHudStereo_QuadWithCrosshair = 2,
+  ovrDebugHudStereo_CrosshairAtInfinity = 3,
+  ovrDebugHudStereo_Count,
+  ovrDebugHudStereo_EnumSize = 0x7fffffff
+} ovrDebugHudStereoMode;
+
+typedef ovrBool(OVR_PFN* pfn_ovr_GetBool)(ovrSession session,
+                                          const char* propertyName,
+                                          ovrBool defaultVal);
+typedef ovrBool(OVR_PFN* pfn_ovr_SetBool)(ovrSession session,
+                                          const char* propertyName,
+                                          ovrBool value);
+typedef int(OVR_PFN* pfn_ovr_GetInt)(ovrSession session,
+                                     const char* propertyName, int defaultVal);
+typedef ovrBool(OVR_PFN* pfn_ovr_SetInt)(ovrSession session,
+                                         const char* propertyName, int value);
+typedef float(OVR_PFN* pfn_ovr_GetFloat)(ovrSession session,
+                                         const char* propertyName,
+                                         float defaultVal);
+typedef ovrBool(OVR_PFN* pfn_ovr_SetFloat)(ovrSession session,
+                                           const char* propertyName,
+                                           float value);
+typedef unsigned int(OVR_PFN* pfn_ovr_GetFloatArray)(
+    ovrSession session, const char* propertyName, float values[],
+    unsigned int valuesCapacity);
+typedef ovrBool(OVR_PFN* pfn_ovr_SetFloatArray)(ovrSession session,
+                                                const char* propertyName,
+                                                const float values[],
+                                                unsigned int valuesSize);
+typedef const char*(OVR_PFN* pfn_ovr_GetString)(ovrSession session,
+                                                const char* propertyName,
+                                                const char* defaultVal);
+typedef ovrBool(OVR_PFN* pfn_ovr_SetString)(ovrSession session,
+                                            const char* propertyName,
+                                            const char* value);
+
+typedef ovrResult(OVR_PFN* pfn_ovr_GetExternalCameras)(
+    ovrSession session, ovrExternalCamera* cameras,
+    unsigned int* inoutCameraCount);
+typedef ovrResult(OVR_PFN* pfn_ovr_SetExternalCameraProperties)(
+    ovrSession session, const char* name,
+    const ovrCameraIntrinsics* const intrinsics,
+    const ovrCameraExtrinsics* const extrinsics);
+
+typedef enum {
+  ovrSuccess_NotVisible = 1000,
+  ovrSuccess_BoundaryInvalid = 1001,
+  ovrSuccess_DeviceUnavailable = 1002,
+} ovrSuccessTypes;
+
+typedef enum {
+  ovrError_MemoryAllocationFailure = -1000,
+  ovrError_InvalidSession = -1002,
+  ovrError_Timeout = -1003,
+  ovrError_NotInitialized = -1004,
+  ovrError_InvalidParameter = -1005,
+  ovrError_ServiceError = -1006,
+  ovrError_NoHmd = -1007,
+  ovrError_Unsupported = -1009,
+  ovrError_DeviceUnavailable = -1010,
+  ovrError_InvalidHeadsetOrientation = -1011,
+  ovrError_ClientSkippedDestroy = -1012,
+  ovrError_ClientSkippedShutdown = -1013,
+  ovrError_ServiceDeadlockDetected = -1014,
+  ovrError_InvalidOperation = -1015,
+  ovrError_InsufficientArraySize = -1016,
+  ovrError_NoExternalCameraInfo = -1017,
+  ovrError_LostTracking = -1018,
+  ovrError_AudioDeviceNotFound = -2001,
+  ovrError_AudioComError = -2002,
+  ovrError_Initialize = -3000,
+  ovrError_LibLoad = -3001,
+  ovrError_LibVersion = -3002,
+  ovrError_ServiceConnection = -3003,
+  ovrError_ServiceVersion = -3004,
+  ovrError_IncompatibleOS = -3005,
+  ovrError_DisplayInit = -3006,
+  ovrError_ServerStart = -3007,
+  ovrError_Reinitialization = -3008,
+  ovrError_MismatchedAdapters = -3009,
+  ovrError_LeakingResources = -3010,
+  ovrError_ClientVersion = -3011,
+  ovrError_OutOfDateOS = -3012,
+  ovrError_OutOfDateGfxDriver = -3013,
+  ovrError_IncompatibleGPU = -3014,
+  ovrError_NoValidVRDisplaySystem = -3015,
+  ovrError_Obsolete = -3016,
+  ovrError_DisabledOrDefaultAdapter = -3017,
+  ovrError_HybridGraphicsNotSupported = -3018,
+  ovrError_DisplayManagerInit = -3019,
+  ovrError_TrackerDriverInit = -3020,
+  ovrError_LibSignCheck = -3021,
+  ovrError_LibPath = -3022,
+  ovrError_LibSymbols = -3023,
+  ovrError_RemoteSession = -3024,
+  ovrError_InitializeVulkan = -3025,
+  ovrError_DisplayLost = -6000,
+  ovrError_TextureSwapChainFull = -6001,
+  ovrError_TextureSwapChainInvalid = -6002,
+  ovrError_GraphicsDeviceReset = -6003,
+  ovrError_DisplayRemoved = -6004,
+  ovrError_ContentProtectionNotAvailable = -6005,
+  ovrError_ApplicationInvisible = -6006,
+  ovrError_Disallowed = -6007,
+  ovrError_DisplayPluggedIncorrectly = -6008,
+  ovrError_RuntimeException = -7000,
+  ovrError_NoCalibration = -9000,
+  ovrError_OldVersion = -9001,
+  ovrError_MisformattedBlock = -9002,
+} ovrErrorType;
+
+#    ifdef XP_WIN
+
+struct IUnknown;
+
+typedef ovrResult(OVR_PFN* pfn_ovr_CreateTextureSwapChainDX)(
+    ovrSession session, IUnknown* d3dPtr, const ovrTextureSwapChainDesc* desc,
+    ovrTextureSwapChain* out_TextureSwapChain);
+
+typedef ovrResult(OVR_PFN* pfn_ovr_GetTextureSwapChainBufferDX)(
+    ovrSession session, ovrTextureSwapChain chain, int index, IID iid,
+    void** out_Buffer);
+
+typedef ovrResult(OVR_PFN* pfn_ovr_CreateMirrorTextureDX)(
+    ovrSession session, IUnknown* d3dPtr, const ovrMirrorTextureDesc* desc,
+    ovrMirrorTexture* out_MirrorTexture);
+
+typedef ovrResult(OVR_PFN* pfn_ovr_GetMirrorTextureBufferDX)(
+    ovrSession session, ovrMirrorTexture mirrorTexture, IID iid,
+    void** out_Buffer);
+
+#    endif
+
+typedef ovrResult(OVR_PFN* pfn_ovr_CreateTextureSwapChainGL)(
+    ovrSession session, const ovrTextureSwapChainDesc* desc,
+    ovrTextureSwapChain* out_TextureSwapChain);
+
+typedef ovrResult(OVR_PFN* pfn_ovr_GetTextureSwapChainBufferGL)(
+    ovrSession session, ovrTextureSwapChain chain, int index,
+    unsigned int* out_TexId);
+
+typedef ovrResult(OVR_PFN* pfn_ovr_CreateMirrorTextureGL)(
+    ovrSession session, const ovrMirrorTextureDesc* desc,
+    ovrMirrorTexture* out_MirrorTexture);
+
+typedef ovrResult(OVR_PFN* pfn_ovr_GetMirrorTextureBufferGL)(
+    ovrSession session, ovrMirrorTexture mirrorTexture,
+    unsigned int* out_TexId);
+
+#    define OVR_KEY_EYE_HEIGHT "EyeHeight"  // float meters
+#    define OVR_DEFAULT_EYE_HEIGHT 1.675f
+
+#    if !defined(OVR_SUCCESS)
+#      define OVR_SUCCESS(result) (result >= 0)
+#    endif
+
+#    if !defined(OVR_UNQUALIFIED_SUCCESS)
+#      define OVR_UNQUALIFIED_SUCCESS(result) (result == ovrSuccess)
+#    endif
+
+#    if !defined(OVR_FAILURE)
+#      define OVR_FAILURE(result) (!OVR_SUCCESS(result))
+#    endif
+
+#    ifdef __cplusplus
+}
+#    endif
+
+#  endif /* mozilla_ovr_capi_dynamic_h_ */
+#endif   /* OVR_CAPI_h */
diff --git a/gfx/vr/service/openvr/LICENSE b/gfx/vr/service/openvr/LICENSE
new file mode 100644
index 0000000000..ee83337d7f
--- /dev/null
+++ b/gfx/vr/service/openvr/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2015, Valve Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/gfx/vr/service/openvr/README.md b/gfx/vr/service/openvr/README.md
new file mode 100644
index 0000000000..5976d622f6
--- /dev/null
+++ b/gfx/vr/service/openvr/README.md
@@ -0,0 +1,13 @@
+OpenVR SDK
+---
+
+OpenVR is an API and runtime that allows access to VR hardware from multiple 
+vendors without requiring that applications have specific knowledge of the 
+hardware they are targeting. This repository is an SDK that contains the API 
+and samples. The runtime is under SteamVR in Tools on Steam. 
+
+### Documentation
+
+Documentation for the API is available on the [Github Wiki](https://github.com/ValveSoftware/openvr/wiki/API-Documentation)
+
+More information on OpenVR and SteamVR can be found on http://steamvr.com
diff --git a/gfx/vr/service/openvr/headers/openvr.h b/gfx/vr/service/openvr/headers/openvr.h
new file mode 100644
index 0000000000..bd59ad305d
--- /dev/null
+++ b/gfx/vr/service/openvr/headers/openvr.h
@@ -0,0 +1,5509 @@
+#pragma once
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+
+
+// version.h
+namespace vr
+{
+	static const uint32_t k_nSteamVRVersionMajor = 1;
+	static const uint32_t k_nSteamVRVersionMinor = 11;
+	static const uint32_t k_nSteamVRVersionBuild = 11;
+} // namespace vr
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack( push, 8 )
+
+/** A handle for a spatial anchor.  This handle is only valid during the session it was created in.
+* Anchors that live beyond one session should be saved by their string descriptors. */
+typedef uint32_t SpatialAnchorHandle_t;
+
+typedef void* glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is forward
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix33_t
+{
+	float m[3][3];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdQuaternionf_t
+{
+	float w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[ 4 ];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_Invalid = -1, // Handle has been invalidated
+	TextureType_DirectX = 0, // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef, deprecated in favor of TextureType_Metal on supported platforms
+	TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
+	TextureType_DXGISharedHandle = 5, // Handle is a HANDLE DXGI share handle, only supported for Overlay render targets. 
+									  // this texture is used directly by our renderer, so only perform atomic (copyresource or resolve) on it
+	TextureType_Metal = 6, // Handle is a MTLTexture conforming to the MTLSharedTexture protocol. Textures submitted to IVRCompositor::Submit which
+						   // are of type MTLTextureType2DArray assume layer 0 is the left eye texture (vr::EVREye::Eye_left), layer 1 is the right
+						   // eye texture (vr::EVREye::Eye_Right)
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,	// Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,	// Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,	// Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void* handle; // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE	((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized			= 1,
+
+	TrackingResult_Calibrating_InProgress	= 100,
+	TrackingResult_Calibrating_OutOfRange	= 101,
+
+	TrackingResult_Running_OK				= 200,
+	TrackingResult_Running_OutOfRange		= 201,
+
+	TrackingResult_Fallback_RotationOnly	= 300,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 64;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,				// the ID was not valid.
+	TrackedDeviceClass_HMD = 1,					// Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,			// Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,		// Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,	// Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,		// Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+
+	TrackedDeviceClass_Max
+};
+
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,					// Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,					// Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,				// Tracked device associated with the right hand
+	TrackedControllerRole_OptOut = 3,					// Tracked device is opting out of left/right hand selection
+	TrackedControllerRole_Treadmill = 4,				// Tracked device is a treadmill or other locomotion device
+	TrackedControllerRole_Stylus = 5,					// Tracked device is a stylus
+	TrackedControllerRole_Max = 5
+};
+
+
+/** Returns true if the tracked controller role is allowed to be a hand */
+inline bool IsRoleAllowedAsHand( ETrackedControllerRole eRole )
+{
+	switch ( eRole )
+	{
+	case TrackedControllerRole_Invalid:
+	case TrackedControllerRole_LeftHand:
+	case TrackedControllerRole_RightHand:
+		return true;
+	default:
+		return false;
+	}
+}
+
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;				// velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;		// angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,		// Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,	// Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,	// Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+enum EAdditionalRadioFeatures
+{
+	AdditionalRadioFeatures_None           = 0x00000000,
+	AdditionalRadioFeatures_HTCLinkBox     = 0x00000001,
+	AdditionalRadioFeatures_InternalDongle = 0x00000002,
+	AdditionalRadioFeatures_ExternalDongle = 0x00000004,
+};
+
+typedef uint64_t WebConsoleHandle_t;
+#define INVALID_WEB_CONSOLE_HANDLE	((vr::WebConsoleHandle_t)0)
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+typedef PropertyContainerHandle_t DriverHandle_t;
+static const PropertyContainerHandle_t k_ulInvalidDriverHandle = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+static const PropertyTypeTag_t k_unErrorPropertyTag = 6;
+static const PropertyTypeTag_t k_unDoublePropertyTag = 7;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+static const PropertyTypeTag_t k_unHmdVector2PropertyTag = 24;
+static const PropertyTypeTag_t k_unHmdQuadPropertyTag = 25;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+static const PropertyTypeTag_t k_unPathHandleInfoTag = 31;
+static const PropertyTypeTag_t k_unActionPropertyTag = 32;
+static const PropertyTypeTag_t k_unInputValuePropertyTag = 33;
+static const PropertyTypeTag_t k_unWildcardPropertyTag = 34;
+static const PropertyTypeTag_t k_unHapticVibrationPropertyTag = 35;
+static const PropertyTypeTag_t k_unSkeletonPropertyTag = 36;
+
+static const PropertyTypeTag_t k_unSpatialAnchorPosePropertyTag = 40;
+static const PropertyTypeTag_t k_unJsonPropertyTag = 41;
+static const PropertyTypeTag_t k_unActiveActionSetPropertyTag = 42;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid								= 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String				= 1000,
+	Prop_ModelNumber_String						= 1001,
+	Prop_SerialNumber_String					= 1002,
+	Prop_RenderModelName_String					= 1003,
+	Prop_WillDriftInYaw_Bool					= 1004,
+	Prop_ManufacturerName_String				= 1005,
+	Prop_TrackingFirmwareVersion_String			= 1006,
+	Prop_HardwareRevision_String				= 1007,
+	Prop_AllWirelessDongleDescriptions_String	= 1008,
+	Prop_ConnectedWirelessDongle_String			= 1009,
+	Prop_DeviceIsWireless_Bool					= 1010,
+	Prop_DeviceIsCharging_Bool					= 1011,
+	Prop_DeviceBatteryPercentage_Float			= 1012, // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34		= 1013,
+	Prop_Firmware_UpdateAvailable_Bool			= 1014,
+	Prop_Firmware_ManualUpdate_Bool				= 1015,
+	Prop_Firmware_ManualUpdateURL_String		= 1016,
+	Prop_HardwareRevision_Uint64				= 1017,
+	Prop_FirmwareVersion_Uint64					= 1018,
+	Prop_FPGAVersion_Uint64						= 1019,
+	Prop_VRCVersion_Uint64						= 1020,
+	Prop_RadioVersion_Uint64					= 1021,
+	Prop_DongleVersion_Uint64					= 1022,
+	Prop_BlockServerShutdown_Bool				= 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool	= 1024,
+	Prop_ContainsProximitySensor_Bool			= 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool		= 1026,
+	Prop_DeviceCanPowerOff_Bool					= 1027,
+	Prop_Firmware_ProgrammingTarget_String		= 1028,
+	Prop_DeviceClass_Int32						= 1029,
+	Prop_HasCamera_Bool							= 1030,
+	Prop_DriverVersion_String                   = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool      = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool		= 1033,
+	Prop_ParentDriver_Uint64					= 1034,
+	Prop_ResourceRoot_String					= 1035,
+	Prop_RegisteredDeviceType_String			= 1036,
+	Prop_InputProfilePath_String				= 1037, // input profile to use for this device in the input system. Will default to tracking system name if this isn't provided
+	Prop_NeverTracked_Bool						= 1038, // Used for devices that will never have a valid pose by design
+	Prop_NumCameras_Int32						= 1039,
+	Prop_CameraFrameLayout_Int32				= 1040, // EVRTrackedCameraFrameLayout value
+	Prop_CameraStreamFormat_Int32				= 1041, // ECameraVideoStreamFormat value
+	Prop_AdditionalDeviceSettingsPath_String	= 1042, // driver-relative path to additional device and global configuration settings
+	Prop_Identifiable_Bool						= 1043, // Whether device supports being identified from vrmonitor (e.g. blink LED, vibrate haptics, etc)
+	Prop_BootloaderVersion_Uint64			    = 1044,
+	Prop_AdditionalSystemReportData_String		= 1045, // additional string to include in system reports about a tracked device
+	Prop_CompositeFirmwareVersion_String        = 1046, // additional FW components from a device that gets propagated into reports
+	Prop_Firmware_RemindUpdate_Bool             = 1047,
+	Prop_PeripheralApplicationVersion_Uint64	= 1048,
+	Prop_ManufacturerSerialNumber_String		= 1049,
+	Prop_ComputedSerialNumber_String			= 1050,
+	Prop_EstimatedDeviceFirstUseTime_Int32		= 1051,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool				= 2000,
+	Prop_SecondsFromVsyncToPhotons_Float		= 2001,
+	Prop_DisplayFrequency_Float					= 2002,
+	Prop_UserIpdMeters_Float					= 2003,
+	Prop_CurrentUniverseId_Uint64				= 2004, 
+	Prop_PreviousUniverseId_Uint64				= 2005, 
+	Prop_DisplayFirmwareVersion_Uint64			= 2006,
+	Prop_IsOnDesktop_Bool						= 2007,
+	Prop_DisplayMCType_Int32					= 2008,
+	Prop_DisplayMCOffset_Float					= 2009,
+	Prop_DisplayMCScale_Float					= 2010,
+	Prop_EdidVendorID_Int32						= 2011,
+	Prop_DisplayMCImageLeft_String              = 2012,
+	Prop_DisplayMCImageRight_String             = 2013,
+	Prop_DisplayGCBlackClamp_Float				= 2014,
+	Prop_EdidProductID_Int32					= 2015,
+	Prop_CameraToHeadTransform_Matrix34			= 2016,
+	Prop_DisplayGCType_Int32					= 2017,
+	Prop_DisplayGCOffset_Float					= 2018,
+	Prop_DisplayGCScale_Float					= 2019,
+	Prop_DisplayGCPrescale_Float				= 2020,
+	Prop_DisplayGCImage_String					= 2021,
+	Prop_LensCenterLeftU_Float					= 2022,
+	Prop_LensCenterLeftV_Float					= 2023,
+	Prop_LensCenterRightU_Float					= 2024,
+	Prop_LensCenterRightV_Float					= 2025,
+	Prop_UserHeadToEyeDepthMeters_Float			= 2026,
+	Prop_CameraFirmwareVersion_Uint64			= 2027,
+	Prop_CameraFirmwareDescription_String		= 2028,
+	Prop_DisplayFPGAVersion_Uint64				= 2029,
+	Prop_DisplayBootloaderVersion_Uint64		= 2030,
+	Prop_DisplayHardwareVersion_Uint64			= 2031,
+	Prop_AudioFirmwareVersion_Uint64			= 2032,
+	Prop_CameraCompatibilityMode_Int32			= 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool					= 2036,
+	Prop_DisplayAllowNightMode_Bool				= 2037,
+	Prop_DisplayMCImageWidth_Int32				= 2038,
+	Prop_DisplayMCImageHeight_Int32				= 2039,
+	Prop_DisplayMCImageNumChannels_Int32		= 2040,
+	Prop_DisplayMCImageData_Binary				= 2041,
+	Prop_SecondsFromPhotonsToVblank_Float		= 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool	= 2043,
+	Prop_DisplayDebugMode_Bool					= 2044,
+	Prop_GraphicsAdapterLuid_Uint64				= 2045,
+	Prop_DriverProvidedChaperonePath_String		= 2048,
+	Prop_ExpectedTrackingReferenceCount_Int32	= 2049, // expected number of sensors or basestations to reserve UI space for
+	Prop_ExpectedControllerCount_Int32			= 2050, // expected number of tracked controllers to reserve UI space for
+	Prop_NamedIconPathControllerLeftDeviceOff_String	= 2051, // placeholder icon for "left" controller if not yet detected/loaded
+	Prop_NamedIconPathControllerRightDeviceOff_String	= 2052, // placeholder icon for "right" controller if not yet detected/loaded
+	Prop_NamedIconPathTrackingReferenceDeviceOff_String	= 2053, // placeholder icon for sensor/base if not yet detected/loaded
+	Prop_DoNotApplyPrediction_Bool				= 2054, // currently no effect. was used to disable HMD pose prediction on MR, which is now done by MR driver setting velocity=0
+	Prop_CameraToHeadTransforms_Matrix34_Array	= 2055,
+	Prop_DistortionMeshResolution_Int32			= 2056, // custom resolution of compositor calls to IVRSystem::ComputeDistortion
+	Prop_DriverIsDrawingControllers_Bool		= 2057,
+	Prop_DriverRequestsApplicationPause_Bool	= 2058,
+	Prop_DriverRequestsReducedRendering_Bool	= 2059,
+	Prop_MinimumIpdStepMeters_Float				= 2060,
+	Prop_AudioBridgeFirmwareVersion_Uint64		= 2061,
+	Prop_ImageBridgeFirmwareVersion_Uint64		= 2062,
+	Prop_ImuToHeadTransform_Matrix34			= 2063,
+	Prop_ImuFactoryGyroBias_Vector3				= 2064,
+	Prop_ImuFactoryGyroScale_Vector3			= 2065,
+	Prop_ImuFactoryAccelerometerBias_Vector3	= 2066,
+	Prop_ImuFactoryAccelerometerScale_Vector3	= 2067,
+	// reserved 2068
+	Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069,
+	Prop_AdditionalRadioFeatures_Uint64         = 2070,
+	Prop_CameraWhiteBalance_Vector4_Array		= 2071, // Prop_NumCameras_Int32-sized array of float[4] RGBG white balance calibration data (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionFunction_Int32_Array	= 2072, // Prop_NumCameras_Int32-sized array of vr::EVRDistortionFunctionType values (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionCoefficients_Float_Array = 2073, // Prop_NumCameras_Int32-sized array of double[vr::k_unMaxDistortionFunctionParameters] (max size is vr::k_unMaxCameras)
+	Prop_ExpectedControllerType_String			= 2074,
+	Prop_HmdTrackingStyle_Int32					= 2075, // one of EHmdTrackingStyle
+	Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
+	Prop_HmdColumnCorrectionSettingPrefix_String = 2077,
+	Prop_CameraSupportsCompatibilityModes_Bool	= 2078,
+
+	Prop_DisplayAvailableFrameRates_Float_Array = 2080, // populated by compositor from actual EDID list when available from GPU driver
+	Prop_DisplaySupportsMultipleFramerates_Bool = 2081, // if this is true but Prop_DisplayAvailableFrameRates_Float_Array is empty, explain to user
+	Prop_DisplayColorMultLeft_Vector3			= 2082,
+	Prop_DisplayColorMultRight_Vector3			= 2083,
+	Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084,
+	Prop_DisplaySupportsAnalogGain_Bool 		= 2085,
+	Prop_DisplayMinAnalogGain_Float 			= 2086,
+	Prop_DisplayMaxAnalogGain_Float 			= 2087,
+
+	// Prop_DashboardLayoutPathName_String 		= 2090, // DELETED
+	Prop_DashboardScale_Float 					= 2091,
+	Prop_IpdUIRangeMinMeters_Float 				= 2100,
+	Prop_IpdUIRangeMaxMeters_Float 				= 2101,
+
+	// Driver requested mura correction properties
+	Prop_DriverRequestedMuraCorrectionMode_Int32		= 2200,
+	Prop_DriverRequestedMuraFeather_InnerLeft_Int32		= 2201,
+	Prop_DriverRequestedMuraFeather_InnerRight_Int32	= 2202,
+	Prop_DriverRequestedMuraFeather_InnerTop_Int32		= 2203,
+	Prop_DriverRequestedMuraFeather_InnerBottom_Int32	= 2204,
+	Prop_DriverRequestedMuraFeather_OuterLeft_Int32		= 2205,
+	Prop_DriverRequestedMuraFeather_OuterRight_Int32	= 2206,
+	Prop_DriverRequestedMuraFeather_OuterTop_Int32		= 2207,
+	Prop_DriverRequestedMuraFeather_OuterBottom_Int32	= 2208,
+
+	Prop_Audio_DefaultPlaybackDeviceId_String		= 2300,
+	Prop_Audio_DefaultRecordingDeviceId_String		= 2301,
+	Prop_Audio_DefaultPlaybackDeviceVolume_Float	= 2302,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String				= 3000,
+	Prop_SupportedButtons_Uint64				= 3001,
+	Prop_Axis0Type_Int32						= 3002, // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32						= 3003, // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32						= 3004, // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32						= 3005, // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32						= 3006, // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32				= 3007, // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float			= 4000,
+	Prop_FieldOfViewRightDegrees_Float			= 4001,
+	Prop_FieldOfViewTopDegrees_Float			= 4002,
+	Prop_FieldOfViewBottomDegrees_Float			= 4003,
+	Prop_TrackingRangeMinimumMeters_Float		= 4004,
+	Prop_TrackingRangeMaximumMeters_Float		= 4005,
+	Prop_ModeLabel_String						= 4006,
+	Prop_CanWirelessIdentify_Bool               = 4007, // volatile, based on radio presence and fw discovery
+	Prop_Nonce_Int32                            = 4008,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String						= 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String				= 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String		= 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String	= 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String			= 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String		= 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String			= 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String			= 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String			= 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandbyAlert_String		= 5009, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start				= 5100,
+	Prop_DisplayHiddenArea_Binary_End				= 5150,
+	Prop_ParentContainer							= 5151,
+	Prop_OverrideContainer_Uint64					= 5152,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String					= 6000,
+	Prop_InstallPath_String						= 6001,
+	Prop_HasDisplayComponent_Bool				= 6002,
+	Prop_HasControllerComponent_Bool			= 6003,
+	Prop_HasCameraComponent_Bool				= 6004,
+	Prop_HasDriverDirectModeComponent_Bool		= 6005,
+	Prop_HasVirtualDisplayComponent_Bool		= 6006,
+	Prop_HasSpatialAnchorsSupport_Bool		    = 6007,
+
+	// Properties that are set internally based on other information provided by drivers
+	Prop_ControllerType_String					= 7000,
+	//Prop_LegacyInputProfile_String				= 7001, // This is no longer used. See "legacy_binding" in the input profile instead.
+	Prop_ControllerHandSelectionPriority_Int32	= 7002, // Allows hand assignments to prefer some controllers over others. High numbers are selected over low numbers
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start			= 10000,
+	Prop_VendorSpecific_Reserved_End			= 10999,
+	
+	Prop_TrackedDeviceProperty_Max				= 1000000,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success						= 0,
+	TrackedProp_WrongDataType				= 1,
+	TrackedProp_WrongDeviceClass			= 2,
+	TrackedProp_BufferTooSmall				= 3,
+	TrackedProp_UnknownProperty				= 4, // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice				= 5,
+	TrackedProp_CouldNotContactServer		= 6,
+	TrackedProp_ValueNotProvidedByDevice	= 7,
+	TrackedProp_StringExceedsMaximumLength	= 8,
+	TrackedProp_NotYetAvailable				= 9, // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied			= 10,
+	TrackedProp_InvalidOperation			= 11,
+	TrackedProp_CannotWriteToWildcards		= 12,
+	TrackedProp_IPCReadFailure				= 13,
+	TrackedProp_OutOfMemory					= 14,
+	TrackedProp_InvalidContainer			= 15,
+};
+
+/** Used to drive certain text in the UI when talking about the tracking system for the HMD */
+enum EHmdTrackingStyle
+{
+	HmdTrackingStyle_Unknown				= 0,
+
+	HmdTrackingStyle_Lighthouse				= 1, // base stations and lasers
+	HmdTrackingStyle_OutsideInCameras		= 2, // Cameras and LED, Rift 1 style
+	HmdTrackingStyle_InsideOutCameras		= 3, // Cameras on HMD looking at the world
+};
+
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+
+static const VRActionHandle_t k_ulInvalidActionHandle = 0;
+static const VRActionSetHandle_t k_ulInvalidActionSetHandle = 0;
+static const VRInputValueHandle_t k_ulInvalidInputValueHandle = 0;
+
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking; // Actual pose used to render scene textures.
+};
+
+struct VRTextureDepthInfo_t
+{
+	void* handle; // See ETextureType definition above
+	HmdMatrix44_t mProjection;
+	HmdVector2_t vRange; // 0..1
+};
+
+struct VRTextureWithDepth_t : public Texture_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+struct VRTextureWithPoseAndDepth_t : public VRTextureWithPose_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	// This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithPose = 0x08,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
+	// This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithDepth = 0x10,
+
+	// Set to indicate a discontinuity between this and the last frame.
+	// This will prevent motion smoothing from attempting to extrapolate using the pair.
+	Submit_FrameDiscontinuty = 0x20,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. 
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage; // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated		= 100,
+	VREvent_TrackedDeviceDeactivated	= 101,
+	VREvent_TrackedDeviceUpdated		= 102,
+	VREvent_TrackedDeviceUserInteractionStarted	= 103,
+	VREvent_TrackedDeviceUserInteractionEnded	= 104,
+	VREvent_IpdChanged					= 105,
+	VREvent_EnterStandbyMode			= 106,
+	VREvent_LeaveStandbyMode			= 107,
+	VREvent_TrackedDeviceRoleChanged	= 108,
+	VREvent_WatchdogWakeUpRequested		= 109,
+	VREvent_LensDistortionChanged		= 110,
+	VREvent_PropertyChanged				= 111,
+	VREvent_WirelessDisconnect			= 112,
+	VREvent_WirelessReconnect			= 113,
+
+	VREvent_ButtonPress					= 200, // data is controller
+	VREvent_ButtonUnpress				= 201, // data is controller
+	VREvent_ButtonTouch					= 202, // data is controller
+	VREvent_ButtonUntouch				= 203, // data is controller
+
+	// VREvent_DualAnalog_Press			= 250, // No longer sent
+	// VREvent_DualAnalog_Unpress		= 251, // No longer sent
+	// VREvent_DualAnalog_Touch			= 252, // No longer sent
+	// VREvent_DualAnalog_Untouch		= 253, // No longer sent
+	// VREvent_DualAnalog_Move			= 254, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch1	= 255, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch2	= 256, // No longer sent
+	VREvent_Modal_Cancel				= 257, // Sent to overlays with the 
+
+	VREvent_MouseMove					= 300, // data is mouse
+	VREvent_MouseButtonDown				= 301, // data is mouse
+	VREvent_MouseButtonUp				= 302, // data is mouse
+	VREvent_FocusEnter					= 303, // data is overlay
+	VREvent_FocusLeave					= 304, // data is overlay
+	VREvent_ScrollDiscrete				= 305, // data is scroll
+	VREvent_TouchPadMove				= 306, // data is mouse
+	VREvent_OverlayFocusChanged			= 307, // data is overlay, global event
+	VREvent_ReloadOverlays				= 308, 
+	VREvent_ScrollSmooth				= 309, // data is scroll
+	VREvent_LockMousePosition			= 310,
+	VREvent_UnlockMousePosition			= 311,
+
+	VREvent_InputFocusCaptured			= 400, // data is process DEPRECATED
+	VREvent_InputFocusReleased			= 401, // data is process DEPRECATED
+	// VREvent_SceneFocusLost			= 402, // data is process
+	// VREvent_SceneFocusGained			= 403, // data is process
+	VREvent_SceneApplicationChanged		= 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged			= 405, // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged			= 406, // data is process
+	// VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, // data is process
+	VREvent_ActionBindingReloaded		 = 409, // data is process - The App that action binds reloaded for
+
+	VREvent_HideRenderModels			= 410, // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels			= 411, // Sent to the scene application to request restoring render model visibility
+
+	VREvent_SceneApplicationStateChanged = 412, // No data; but query VRApplications()->GetSceneApplicationState();
+
+	VREvent_ConsoleOpened               = 420,
+	VREvent_ConsoleClosed               = 421,
+
+	VREvent_OverlayShown				= 500,
+	VREvent_OverlayHidden				= 501,
+	VREvent_DashboardActivated			= 502,
+	VREvent_DashboardDeactivated		= 503,
+	//VREvent_DashboardThumbSelected		= 504, // Sent to the overlay manager - data is overlay - No longer sent
+	VREvent_DashboardRequested			= 505, // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard				= 506, // Send to the overlay manager
+	//VREvent_RenderToast					= 507, // Send to the dashboard to render a toast - data is the notification ID -- no longer sent
+	VREvent_ImageLoaded					= 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard				= 509, // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard				= 510, // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained	= 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost		= 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	//VREvent_DashboardGuideButtonDown	= 514, // These are no longer sent
+	//VREvent_DashboardGuideButtonUp		= 515,
+	VREvent_ScreenshotTriggered			= 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed					= 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated		= 518,
+	VREvent_SwitchGamepadFocus			= 519,
+
+	// Screenshot API
+	VREvent_RequestScreenshot				= 520, // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken					= 521, // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed				= 522, // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard		= 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard	= 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged	= 525,
+	VREvent_RoomViewShown					= 526, // Sent by compositor whenever room-view is enabled
+	VREvent_RoomViewHidden					= 527, // Sent by compositor whenever room-view is disabled
+	VREvent_ShowUI							= 528, // data is showUi
+	VREvent_ShowDevTools					= 529, // data is showDevTools
+
+	VREvent_Notification_Shown				= 600,
+	VREvent_Notification_Hidden				= 601,
+	VREvent_Notification_BeginInteraction	= 602,
+	VREvent_Notification_Destroyed			= 603,
+
+	VREvent_Quit							= 700, // data is process
+	VREvent_ProcessQuit						= 701, // data is process
+	//VREvent_QuitAborted_UserPrompt			= 702, // data is process
+	VREvent_QuitAcknowledged				= 703, // data is process
+	VREvent_DriverRequestedQuit				= 704, // The driver has requested that SteamVR shut down
+	VREvent_RestartRequested				= 705, // A driver or other component wants the user to restart SteamVR
+
+	VREvent_ChaperoneDataHasChanged			= 800, // this will never happen with the new chaperone system
+	VREvent_ChaperoneUniverseHasChanged		= 801,
+	VREvent_ChaperoneTempDataHasChanged		= 802, // this will never happen with the new chaperone system
+	VREvent_ChaperoneSettingsHaveChanged	= 803,
+	VREvent_SeatedZeroPoseReset				= 804,
+	VREvent_ChaperoneFlushCache				= 805, // Sent when the process needs to reload any cached data it retrieved from VRChaperone()
+	VREvent_ChaperoneRoomSetupStarting	    = 806, // Triggered by CVRChaperoneClient::RoomSetupStarting
+	VREvent_ChaperoneRoomSetupFinished	    = 807, // Triggered by CVRChaperoneClient::CommitWorkingCopy
+
+	VREvent_AudioSettingsHaveChanged		= 820,
+
+	VREvent_BackgroundSettingHasChanged				= 850,
+	VREvent_CameraSettingsHaveChanged				= 851,
+	VREvent_ReprojectionSettingHasChanged			= 852,
+	VREvent_ModelSkinSettingsHaveChanged			= 853,
+	VREvent_EnvironmentSettingsHaveChanged			= 854,
+	VREvent_PowerSettingsHaveChanged				= 855,
+	VREvent_EnableHomeAppSettingsHaveChanged		= 856,
+	VREvent_SteamVRSectionSettingChanged			= 857,
+	VREvent_LighthouseSectionSettingChanged			= 858,
+	VREvent_NullSectionSettingChanged				= 859,
+	VREvent_UserInterfaceSectionSettingChanged		= 860,
+	VREvent_NotificationsSectionSettingChanged		= 861,
+	VREvent_KeyboardSectionSettingChanged			= 862,
+	VREvent_PerfSectionSettingChanged				= 863,
+	VREvent_DashboardSectionSettingChanged			= 864,
+	VREvent_WebInterfaceSectionSettingChanged		= 865,
+	VREvent_TrackersSectionSettingChanged			= 866,
+	VREvent_LastKnownSectionSettingChanged			= 867,
+	VREvent_DismissedWarningsSectionSettingChanged	= 868,
+	VREvent_GpuSpeedSectionSettingChanged			= 869,
+	VREvent_WindowsMRSectionSettingChanged			= 870,
+	VREvent_OtherSectionSettingChanged				= 871,
+
+	VREvent_StatusUpdate					= 900,
+
+	VREvent_WebInterface_InstallDriverCompleted = 950,
+
+	VREvent_MCImageUpdated					= 1000,
+
+	VREvent_FirmwareUpdateStarted			= 1100,
+	VREvent_FirmwareUpdateFinished			= 1101,
+
+	VREvent_KeyboardClosed					= 1200,
+	VREvent_KeyboardCharInput				= 1201,
+	VREvent_KeyboardDone					= 1202, // Sent when DONE button clicked on keyboard
+
+	//VREvent_ApplicationTransitionStarted		= 1300,
+	//VREvent_ApplicationTransitionAborted		= 1301,
+	//VREvent_ApplicationTransitionNewAppStarted	= 1302,
+	VREvent_ApplicationListUpdated				= 1303,
+	VREvent_ApplicationMimeTypeLoad				= 1304,
+	// VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected					= 1306,
+	VREvent_ProcessDisconnected					= 1307,
+
+	//VREvent_Compositor_MirrorWindowShown		= 1400, // DEPRECATED
+	//VREvent_Compositor_MirrorWindowHidden		= 1401, // DEPRECATED
+	VREvent_Compositor_ChaperoneBoundsShown		= 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden	= 1411,
+	VREvent_Compositor_DisplayDisconnected		= 1412,
+	VREvent_Compositor_DisplayReconnected		= 1413,
+	VREvent_Compositor_HDCPError				= 1414, // data is hdcpError
+	VREvent_Compositor_ApplicationNotResponding	= 1415,
+	VREvent_Compositor_ApplicationResumed		= 1416,
+	VREvent_Compositor_OutOfVideoMemory			= 1417,
+	VREvent_Compositor_DisplayModeNotSupported	= 1418, // k_pch_SteamVR_PreferredRefreshRate
+	VREvent_Compositor_StageOverrideReady		= 1419,
+
+	VREvent_TrackedCamera_StartVideoStream  = 1500,
+	VREvent_TrackedCamera_StopVideoStream   = 1501,
+	VREvent_TrackedCamera_PauseVideoStream  = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface    = 1550,
+
+	VREvent_PerformanceTest_EnableCapture	= 1600,
+	VREvent_PerformanceTest_DisableCapture	= 1601,
+	VREvent_PerformanceTest_FidelityLevel	= 1602,
+
+	VREvent_MessageOverlay_Closed			= 1650,
+	VREvent_MessageOverlayCloseRequested	= 1651,
+	
+	VREvent_Input_HapticVibration			= 1700, // data is hapticVibration
+	VREvent_Input_BindingLoadFailed			= 1701, // data is inputBinding
+	VREvent_Input_BindingLoadSuccessful		= 1702, // data is inputBinding
+	VREvent_Input_ActionManifestReloaded	= 1703, // no data
+	VREvent_Input_ActionManifestLoadFailed	= 1704, // data is actionManifest
+	VREvent_Input_ProgressUpdate			= 1705, // data is progressUpdate
+	VREvent_Input_TrackerActivated			= 1706,
+	VREvent_Input_BindingsUpdated			= 1707,
+	VREvent_Input_BindingSubscriptionChanged = 1708,
+
+	VREvent_SpatialAnchors_PoseUpdated		= 1800,        // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_DescriptorUpdated = 1801,       // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_RequestPoseUpdate = 1802,       // data is spatialAnchor. sent to specific driver
+	VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, // data is spatialAnchor. sent to specific driver
+
+	VREvent_SystemReport_Started			= 1900, // user or system initiated generation of a system report. broadcast
+
+	VREvent_Monitor_ShowHeadsetView			= 2000, // data is process
+	VREvent_Monitor_HideHeadsetView			= 2001, // data is process
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start	= 10000,
+	VREvent_VendorSpecific_Reserved_End		= 19999,
+};
+
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{	
+	k_EDeviceActivityLevel_Unknown = -1,									
+	k_EDeviceActivityLevel_Idle = 0,						// No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,				// Activity (movement or prox sensor) is happening now	
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,		// No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,						// Idle for at least 5 seconds (configurable in Settings -> Power Management)
+	k_EDeviceActivityLevel_Idle_Timeout = 4,
+};
+
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System			= 0,
+	k_EButton_ApplicationMenu	= 1,
+	k_EButton_Grip				= 2,
+	k_EButton_DPad_Left			= 3,
+	k_EButton_DPad_Up			= 4,
+	k_EButton_DPad_Right		= 5,
+	k_EButton_DPad_Down			= 6,
+	k_EButton_A					= 7,
+	
+	k_EButton_ProximitySensor   = 31,
+
+	k_EButton_Axis0				= 32,
+	k_EButton_Axis1				= 33,
+	k_EButton_Axis2				= 34,
+	k_EButton_Axis3				= 35,
+	k_EButton_Axis4				= 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad	= k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger	= k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back	= k_EButton_Grip,
+
+	k_EButton_IndexController_A		= k_EButton_Grip,
+	k_EButton_IndexController_B		= k_EButton_ApplicationMenu,
+	k_EButton_IndexController_JoyStick	= k_EButton_Axis3,
+
+	k_EButton_Max				= 64
+};
+
+inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button; // EVRButtonId enum
+};
+
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left					= 0x0001,
+	VRMouseButton_Right					= 0x0002,
+	VRMouseButton_Middle				= 0x0004,
+};
+
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button; // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;
+	uint32_t unused;
+	float viewportscale; // For scrolling on an overlay with laser mouse, this is the overlay's vertical size relative to the overlay height. Range: [0,1]
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it). These events are sent to overlays with the VROverlayFlags_SendVRTouchpadEvents
+   flag set.
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+	// If the associated event was triggered by a connection loss
+	bool bConnectionLost;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+	uint64_t devicePath;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState; // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];	// Up to 11 bytes of new input
+	uint64_t uUserValue;	// Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+	uint64_t reserved2;
+	uint64_t reserved3;
+	uint64_t reserved4;
+	uint64_t reserved5;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+struct VREvent_HapticVibration_t
+{
+	uint64_t containerHandle; // property container handle of the device with the haptic component
+	uint64_t componentHandle; // Which haptic component needs to vibrate
+	float fDurationSeconds;
+	float fFrequency;
+	float fAmplitude;
+};
+
+struct VREvent_WebConsole_t
+{
+	WebConsoleHandle_t webConsoleHandle;
+};
+
+struct VREvent_InputBindingLoad_t
+{
+	vr::PropertyContainerHandle_t ulAppContainer;
+	uint64_t pathMessage;
+	uint64_t pathUrl;
+	uint64_t pathControllerType;
+};
+
+struct VREvent_InputActionManifestLoad_t
+{
+	uint64_t pathAppKey;
+	uint64_t pathMessage;
+	uint64_t pathMessageParam;
+	uint64_t pathManifestPath;
+};
+
+struct VREvent_SpatialAnchor_t
+{
+	SpatialAnchorHandle_t unHandle;
+};
+
+struct VREvent_ProgressUpdate_t
+{
+	uint64_t ulApplicationPropertyContainer;
+	uint64_t pathDevice;
+	uint64_t pathInputSource;
+	uint64_t pathProgressAction;
+	uint64_t pathIcon;
+	float fProgress;
+};
+
+enum EShowUIType
+{
+	ShowUI_ControllerBinding = 0,
+	ShowUI_ManageTrackers = 1,
+	// ShowUI_QuickStart = 2, // Deprecated
+	ShowUI_Pairing = 3,
+	ShowUI_Settings = 4,
+	ShowUI_DebugCommands = 5,
+	ShowUI_FullControllerBinding = 6,
+	ShowUI_ManageDrivers = 7,
+};
+
+struct VREvent_ShowUI_t
+{
+	EShowUIType eType;
+};
+
+struct VREvent_ShowDevTools_t
+{
+	int32_t nBrowserIdentifier;
+};
+
+enum EHDCPError
+{
+	HDCPError_None = 0,
+	HDCPError_LinkLost = 1,
+	HDCPError_Tampered = 2,
+	HDCPError_DeviceRevoked = 3,
+	HDCPError_Unknown = 4
+};
+
+struct VREvent_HDCPError_t
+{
+	EHDCPError eCode;
+};
+
+typedef union
+{
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+	VREvent_HapticVibration_t hapticVibration;
+	VREvent_WebConsole_t webConsole;
+	VREvent_InputBindingLoad_t inputBinding;
+	VREvent_InputActionManifestLoad_t actionManifest;
+	VREvent_SpatialAnchor_t spatialAnchor;
+	VREvent_ProgressUpdate_t progressUpdate;
+	VREvent_ShowUI_t showUi;
+	VREvent_ShowDevTools_t showDevTools;
+	VREvent_HDCPError_t hdcpError;
+    /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+} VREvent_Data_t;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType; // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+	VRComponentProperty_IsHighlighted = (1 << 5),
+};
+
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+
+enum EVRInputError
+{
+	VRInputError_None = 0,
+	VRInputError_NameNotFound = 1,
+	VRInputError_WrongType = 2,
+	VRInputError_InvalidHandle = 3,
+	VRInputError_InvalidParam = 4,
+	VRInputError_NoSteam = 5,
+	VRInputError_MaxCapacityReached = 6,
+	VRInputError_IPCError = 7,
+	VRInputError_NoActiveActionSet = 8,
+	VRInputError_InvalidDevice = 9,
+	VRInputError_InvalidSkeleton = 10,
+	VRInputError_InvalidBoneCount = 11,
+	VRInputError_InvalidCompressedData = 12,
+	VRInputError_NoData = 13,
+	VRInputError_BufferTooSmall = 14,
+	VRInputError_MismatchedActionManifest = 15,
+	VRInputError_MissingSkeletonData = 16,
+	VRInputError_InvalidBoneIndex = 17,
+	VRInputError_InvalidPriority = 18,
+	VRInputError_PermissionDenied = 19,
+	VRInputError_InvalidRenderModel = 20,
+};
+
+enum EVRSpatialAnchorError
+{
+	VRSpatialAnchorError_Success = 0,
+	VRSpatialAnchorError_Internal = 1,
+	VRSpatialAnchorError_UnknownHandle = 2,
+	VRSpatialAnchorError_ArrayTooSmall = 3,
+	VRSpatialAnchorError_InvalidDescriptorChar = 4,
+	VRSpatialAnchorError_NotYetAvailable = 5,
+	VRSpatialAnchorError_NotAvailableInThisUniverse = 6,
+	VRSpatialAnchorError_PermanentlyUnavailable = 7,
+	VRSpatialAnchorError_WrongDriver = 8,
+	VRSpatialAnchorError_DescriptorTooLong = 9,
+	VRSpatialAnchorError_Unknown = 10,
+	VRSpatialAnchorError_NoRoomCalibration = 11,
+	VRSpatialAnchorError_InvalidArgument = 12,
+	VRSpatialAnchorError_UnknownDriver = 13,
+};
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
+};
+
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since 
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+typedef VRControllerState001_t VRControllerState_t;
+
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None						= 0,
+
+	VROverlayError_UnknownOverlay			= 10,
+	VROverlayError_InvalidHandle			= 11,
+	VROverlayError_PermissionDenied			= 12,
+	VROverlayError_OverlayLimitExceeded		= 13, // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType		= 14,
+	VROverlayError_KeyTooLong				= 15,
+	VROverlayError_NameTooLong				= 16,
+	VROverlayError_KeyInUse					= 17,
+	VROverlayError_WrongTransformType		= 18,
+	VROverlayError_InvalidTrackedDevice		= 19,
+	VROverlayError_InvalidParameter			= 20,
+	VROverlayError_ThumbnailCantBeDestroyed	= 21,
+	VROverlayError_ArrayTooSmall			= 22,
+	VROverlayError_RequestFailed			= 23,
+	VROverlayError_InvalidTexture			= 24,
+	VROverlayError_UnableToLoadFile			= 25,
+	VROverlayError_KeyboardAlreadyInUse		= 26,
+	VROverlayError_NoNeighbor				= 27,
+	VROverlayError_TooManyMaskPrimitives	= 29,
+	VROverlayError_BadMaskPrimitive			= 30,
+	VROverlayError_TextureAlreadyLocked		= 31,
+	VROverlayError_TextureLockCapacityReached = 32,
+	VROverlayError_TextureNotLocked			= 33,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,		// Some other kind of application that isn't covered by the other entries 
+	VRApplication_Scene	= 1,		// Application will submit 3D frames 
+	VRApplication_Overlay = 2,		// Application only interacts with overlays
+	VRApplication_Background = 3,	// Application should not start SteamVR if it's not already running, and should not
+									// keep it running if everything else quits.
+	VRApplication_Utility = 4,		// Init should not try to load any drivers. The application needs access to utility
+									// interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,	// Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,// Reserved for Steam
+	VRApplication_Bootstrapper = 7, // reserved for vrstartup
+	VRApplication_WebHelper = 8,	// reserved for vrwebhelper
+
+	VRApplication_Max
+};
+
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+
+enum EVRSkeletalMotionRange
+{
+	// The range of motion of the skeleton takes into account any physical limits imposed by
+	// the controller itself.  This will tend to be the most accurate pose compared to the user's
+	// actual hand pose, but might not allow a closed fist for example
+	VRSkeletalMotionRange_WithController = 0,
+
+	// Retarget the range of motion provided by the input device to make the hand appear to move
+	// as if it was not holding a controller.  eg: map "hand grasping controller" to "closed fist"
+	VRSkeletalMotionRange_WithoutController = 1,
+};
+
+enum EVRSkeletalTrackingLevel
+{
+	// body part location can't be directly determined by the device. Any skeletal pose provided by
+	// the device is estimated by assuming the position required to active buttons, triggers, joysticks, 
+	// or other input sensors. 
+	// E.g. Vive Controller, Gamepad
+	VRSkeletalTracking_Estimated = 0,
+
+	// body part location can be measured directly but with fewer degrees of freedom than the actual body 
+	// part. Certain body part positions may be unmeasured by the device and estimated from other input data. 
+	// E.g. Index Controllers, gloves that only measure finger curl
+	VRSkeletalTracking_Partial = 1,
+
+	// Body part location can be measured directly throughout the entire range of motion of the body part. 
+	// E.g. Mocap suit for the full body, gloves that measure rotation of each finger segment
+	VRSkeletalTracking_Full = 2,
+
+	VRSkeletalTrackingLevel_Count,
+	VRSkeletalTrackingLevel_Max = VRSkeletalTrackingLevel_Count - 1
+};
+
+
+
+/** Holds the transform for a single bone */
+struct VRBoneTransform_t
+{
+	HmdVector4_t position;
+	HmdQuaternionf_t orientation;
+};
+
+/** Type used for referring to bones by their index */
+typedef int32_t BoneIndex_t;
+const BoneIndex_t k_unInvalidBoneIndex = -1;
+
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None	= 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound			= 100,
+	VRInitError_Init_InstallationCorrupt			= 101,
+	VRInitError_Init_VRClientDLLNotFound			= 102,
+	VRInitError_Init_FileNotFound					= 103,
+	VRInitError_Init_FactoryNotFound				= 104,
+	VRInitError_Init_InterfaceNotFound				= 105,
+	VRInitError_Init_InvalidInterface				= 106,
+	VRInitError_Init_UserConfigDirectoryInvalid		= 107,
+	VRInitError_Init_HmdNotFound					= 108,
+	VRInitError_Init_NotInitialized					= 109,
+	VRInitError_Init_PathRegistryNotFound			= 110,
+	VRInitError_Init_NoConfigPath					= 111,
+	VRInitError_Init_NoLogPath						= 112,
+	VRInitError_Init_PathRegistryNotWritable		= 113,
+	VRInitError_Init_AppInfoInitFailed				= 114,
+	VRInitError_Init_Retry							= 115, // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser				= 116, // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching			= 117, 
+	VRInitError_Init_SettingsInitFailed				= 118, 
+	VRInitError_Init_ShuttingDown					= 119,
+	VRInitError_Init_TooManyObjects					= 120,
+	VRInitError_Init_NoServerForBackgroundApp		= 121,
+	VRInitError_Init_NotSupportedWithCompositor		= 122,
+	VRInitError_Init_NotAvailableToUtilityApps		= 123,
+	VRInitError_Init_Internal				 		= 124,
+	VRInitError_Init_HmdDriverIdIsNone		 		= 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed 		= 126,
+	VRInitError_Init_VRMonitorNotFound				= 127,
+	VRInitError_Init_VRMonitorStartupFailed			= 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported	= 129, 
+	VRInitError_Init_InvalidApplicationType			= 130,
+	VRInitError_Init_NotAvailableToWatchdogApps		= 131,
+	VRInitError_Init_WatchdogDisabledInSettings		= 132,
+	VRInitError_Init_VRDashboardNotFound			= 133,
+	VRInitError_Init_VRDashboardStartupFailed		= 134,
+	VRInitError_Init_VRHomeNotFound					= 135,
+	VRInitError_Init_VRHomeStartupFailed			= 136,
+	VRInitError_Init_RebootingBusy					= 137,
+	VRInitError_Init_FirmwareUpdateBusy				= 138,
+	VRInitError_Init_FirmwareRecoveryBusy			= 139,
+	VRInitError_Init_USBServiceBusy					= 140,
+	VRInitError_Init_VRWebHelperStartupFailed		= 141,
+	VRInitError_Init_TrackerManagerInitFailed		= 142,
+	VRInitError_Init_AlreadyRunning					= 143,
+	VRInitError_Init_FailedForVrMonitor				= 144,
+	VRInitError_Init_PropertyManagerInitFailed		= 145,
+	VRInitError_Init_WebServerFailed				= 146,
+
+	VRInitError_Driver_Failed						= 200,
+	VRInitError_Driver_Unknown						= 201,
+	VRInitError_Driver_HmdUnknown					= 202,
+	VRInitError_Driver_NotLoaded					= 203,
+	VRInitError_Driver_RuntimeOutOfDate				= 204,
+	VRInitError_Driver_HmdInUse						= 205,
+	VRInitError_Driver_NotCalibrated				= 206,
+	VRInitError_Driver_CalibrationInvalid			= 207,
+	VRInitError_Driver_HmdDisplayNotFound			= 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds		= 211,
+	VRInitError_Driver_HmdDisplayMirrored			= 212,
+	VRInitError_Driver_HmdDisplayNotFoundLaptop		= 213,
+	// Never make error 259 because we return it from main and it would conflict with STILL_ACTIVE
+
+	VRInitError_IPC_ServerInitFailed				= 300,
+	VRInitError_IPC_ConnectFailed					= 301,
+	VRInitError_IPC_SharedStateInitFailed			= 302,
+	VRInitError_IPC_CompositorInitFailed			= 303,
+	VRInitError_IPC_MutexInitFailed					= 304,
+	VRInitError_IPC_Failed							= 305,
+	VRInitError_IPC_CompositorConnectFailed			= 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
+	VRInitError_IPC_NamespaceUnavailable			 = 310,
+
+	VRInitError_Compositor_Failed												= 400,
+	VRInitError_Compositor_D3D11HardwareRequired								= 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate								= 402,
+	VRInitError_Compositor_OverlayInitFailed									= 403,
+	VRInitError_Compositor_ScreenshotsInitFailed								= 404,
+	VRInitError_Compositor_UnableToCreateDevice									= 405,
+	VRInitError_Compositor_SharedStateIsNull									= 406,
+	VRInitError_Compositor_NotificationManagerIsNull							= 407,
+	VRInitError_Compositor_ResourceManagerClientIsNull							= 408,
+	VRInitError_Compositor_MessageOverlaySharedStateInitFailure					= 409,
+	VRInitError_Compositor_PropertiesInterfaceIsNull							= 410,
+	VRInitError_Compositor_CreateFullscreenWindowFailed							= 411,
+	VRInitError_Compositor_SettingsInterfaceIsNull								= 412,
+	VRInitError_Compositor_FailedToShowWindow									= 413,
+	VRInitError_Compositor_DistortInterfaceIsNull								= 414,
+	VRInitError_Compositor_DisplayFrequencyFailure								= 415,
+	VRInitError_Compositor_RendererInitializationFailed							= 416,
+	VRInitError_Compositor_DXGIFactoryInterfaceIsNull							= 417,
+	VRInitError_Compositor_DXGIFactoryCreateFailed								= 418,
+	VRInitError_Compositor_DXGIFactoryQueryFailed								= 419,
+	VRInitError_Compositor_InvalidAdapterDesktop								= 420,
+	VRInitError_Compositor_InvalidHmdAttachment									= 421,
+	VRInitError_Compositor_InvalidOutputDesktop									= 422,
+	VRInitError_Compositor_InvalidDeviceProvided								= 423,
+	VRInitError_Compositor_D3D11RendererInitializationFailed					= 424,
+	VRInitError_Compositor_FailedToFindDisplayMode								= 425,
+	VRInitError_Compositor_FailedToCreateSwapChain								= 426,
+	VRInitError_Compositor_FailedToGetBackBuffer								= 427,
+	VRInitError_Compositor_FailedToCreateRenderTarget							= 428,
+	VRInitError_Compositor_FailedToCreateDXGI2SwapChain							= 429,
+	VRInitError_Compositor_FailedtoGetDXGI2BackBuffer							= 430,
+	VRInitError_Compositor_FailedToCreateDXGI2RenderTarget						= 431,
+	VRInitError_Compositor_FailedToGetDXGIDeviceInterface						= 432,
+	VRInitError_Compositor_SelectDisplayMode									= 433,
+	VRInitError_Compositor_FailedToCreateNvAPIRenderTargets						= 434,
+	VRInitError_Compositor_NvAPISetDisplayMode									= 435,
+	VRInitError_Compositor_FailedToCreateDirectModeDisplay						= 436,
+	VRInitError_Compositor_InvalidHmdPropertyContainer							= 437,
+	VRInitError_Compositor_UpdateDisplayFrequency								= 438,
+	VRInitError_Compositor_CreateRasterizerState								= 439,
+	VRInitError_Compositor_CreateWireframeRasterizerState						= 440,
+	VRInitError_Compositor_CreateSamplerState									= 441,
+	VRInitError_Compositor_CreateClampToBorderSamplerState						= 442,
+	VRInitError_Compositor_CreateAnisoSamplerState								= 443,
+	VRInitError_Compositor_CreateOverlaySamplerState							= 444,
+	VRInitError_Compositor_CreatePanoramaSamplerState							= 445,
+	VRInitError_Compositor_CreateFontSamplerState								= 446,
+	VRInitError_Compositor_CreateNoBlendState									= 447,
+	VRInitError_Compositor_CreateBlendState										= 448,
+	VRInitError_Compositor_CreateAlphaBlendState								= 449,
+	VRInitError_Compositor_CreateBlendStateMaskR								= 450,
+	VRInitError_Compositor_CreateBlendStateMaskG								= 451,
+	VRInitError_Compositor_CreateBlendStateMaskB								= 452,
+	VRInitError_Compositor_CreateDepthStencilState								= 453,
+	VRInitError_Compositor_CreateDepthStencilStateNoWrite						= 454,
+	VRInitError_Compositor_CreateDepthStencilStateNoDepth						= 455,
+	VRInitError_Compositor_CreateFlushTexture									= 456,
+	VRInitError_Compositor_CreateDistortionSurfaces								= 457,
+	VRInitError_Compositor_CreateConstantBuffer									= 458,
+	VRInitError_Compositor_CreateHmdPoseConstantBuffer							= 459,
+	VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer					= 460,
+	VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer					= 461,
+	VRInitError_Compositor_CreateOverlayConstantBuffer							= 462,
+	VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer				= 463,
+	VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer		= 464,
+	VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer		= 465,
+	VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer			= 466,
+	VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer	= 467,
+	VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer					= 468,
+	VRInitError_Compositor_CreateGeomConstantBuffer								= 469,
+	VRInitError_Compositor_CreatePanelMaskConstantBuffer						= 470,
+	VRInitError_Compositor_CreatePixelSimUBO									= 471,
+	VRInitError_Compositor_CreateMSAARenderTextures								= 472,
+	VRInitError_Compositor_CreateResolveRenderTextures							= 473,
+	VRInitError_Compositor_CreateComputeResolveRenderTextures					= 474,
+	VRInitError_Compositor_CreateDriverDirectModeResolveTextures				= 475,
+	VRInitError_Compositor_OpenDriverDirectModeResolveTextures					= 476,
+	VRInitError_Compositor_CreateFallbackSyncTexture							= 477,
+	VRInitError_Compositor_ShareFallbackSyncTexture								= 478,
+	VRInitError_Compositor_CreateOverlayIndexBuffer								= 479,
+	VRInitError_Compositor_CreateOverlayVertexBuffer							= 480,
+	VRInitError_Compositor_CreateTextVertexBuffer								= 481,
+	VRInitError_Compositor_CreateTextIndexBuffer								= 482,
+	VRInitError_Compositor_CreateMirrorTextures									= 483,
+	VRInitError_Compositor_CreateLastFrameRenderTexture							= 484,
+	VRInitError_Compositor_CreateMirrorOverlay									= 485,
+	VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer				= 486,
+	VRInitError_Compositor_DisplayModeNotSupported								= 487,
+	VRInitError_Compositor_CreateOverlayInvalidCall								= 488,
+	VRInitError_Compositor_CreateOverlayAlreadyInitialized						= 489,
+	VRInitError_Compositor_FailedToCreateMailbox								= 490,
+	
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime		= 1000,
+	VRInitError_VendorSpecific_WindowsNotInDevMode					= 1001,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice 				= 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart	= 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig 				= 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig 				= 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall 				= 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib 			= 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion 	= 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart	= 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart	= 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext		= 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange		= 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError				= 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck		= 1113,
+	VRInitError_VendorSpecific_OculusRuntimeBadInstall				= 1114,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+
+	// Strictly a placeholder
+	VRInitError_LastError
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1, // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None                       = 0,
+	VRTrackedCameraError_OperationFailed            = 100,
+	VRTrackedCameraError_InvalidHandle              = 101,	
+	VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
+	VRTrackedCameraError_OutOfHandles               = 103,
+	VRTrackedCameraError_IPCFailure                 = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice  = 105,
+	VRTrackedCameraError_SharedMemoryFailure        = 106,
+	VRTrackedCameraError_FrameBufferingFailure      = 107,
+	VRTrackedCameraError_StreamSetupFailure         = 108,
+	VRTrackedCameraError_InvalidGLTextureId         = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId     = 111,
+	VRTrackedCameraError_SharedTextureFailure       = 112,
+	VRTrackedCameraError_NoFrameAvailable           = 113,
+	VRTrackedCameraError_InvalidArgument            = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize     = 115,
+};
+
+enum EVRTrackedCameraFrameLayout
+{
+	EVRTrackedCameraFrameLayout_Mono				= 0x0001,
+	EVRTrackedCameraFrameLayout_Stereo				= 0x0002,
+	EVRTrackedCameraFrameLayout_VerticalLayout		= 0x0010,	// Stereo frames are Top/Bottom (left/right)
+	EVRTrackedCameraFrameLayout_HorizontalLayout	= 0x0020,	// Stereo frames are Left/Right
+};
+	
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,			// This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,			// In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,	// In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+enum EVRDistortionFunctionType
+{
+	VRDistortionFunctionType_None,
+	VRDistortionFunctionType_FTheta,
+	VRDistortionFunctionType_Extended_FTheta,
+	MAX_DISTORTION_FUNCTION_TYPES,
+};
+
+static const uint32_t k_unMaxDistortionFunctionParameters = 8;
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE	((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t trackedDevicePose;
+	
+	uint64_t ulFrameExposureTime;						// mid-point of the exposure of the image in host system ticks
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+/** Compositor frame timing reprojection flags. */
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;	// This flag indicates the async reprojection mode is active,
+															// but does not indicate if reprojection actually happened or not.
+															// Use the ReprojectionReason flags above to check if reprojection
+															// was actually applied (i.e. scene texture was reused).
+															// NumFramePresents > 1 also indicates the scene texture was reused,
+															// and also the number of times that it was presented in total.
+
+const uint32_t VRCompositor_ReprojectionMotion = 0x08;	// This flag indicates whether or not motion smoothing was triggered for this frame
+
+const uint32_t VRCompositor_PredictionMask = 0x30;	// The runtime may predict more than one frame (up to four) ahead if
+															// it detects the application is taking too long to render. These two
+															// bits will contain the count of additional frames (normally zero).
+															// Use the VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+const uint32_t VRCompositor_ThrottleMask = 0xC0;	// Number of frames the compositor is throttling the application.
+															// Use the VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+#define VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_PredictionMask ) >> 4 )
+#define VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_ThrottleMask ) >> 6 )
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents; // number of times this frame was presented
+	uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
+
+	uint32_t m_nNumVSyncsReadyForUse;
+	uint32_t m_nNumVSyncsToFirstView;
+};
+
+/** Provides compositor benchmark results to the app */
+struct Compositor_BenchmarkResults
+{
+	float m_flMegaPixelsPerSecond; // Measurement of GPU MP/s performed by compositor benchmark
+	float m_flHmdRecommendedMegaPixelsPerSecond; // Recommended default MP/s given the HMD resolution, refresh, and panel mask.
+};
+
+/** Frame timing data provided by direct mode drivers. */
+struct DriverDirectMode_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( DriverDirectMode_FrameTiming )
+	uint32_t m_nNumFramePresents; // number of times frame was presented
+	uint32_t m_nNumMisPresented; // number of times frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out (i.e. compositor missed vsync)
+	uint32_t m_nReprojectionFlags;
+};
+
+/** These flags will be set on DriverDirectMode_FrameTiming::m_nReprojectionFlags when IVRDriverDirectModeComponent::GetFrameTiming is called for drivers to optionally respond to. */
+const uint32_t VRCompositor_ReprojectionMotion_Enabled = 0x100; // Motion Smoothing is enabled in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_ForcedOn = 0x200; // Motion Smoothing is forced on in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_AppThrottled = 0x400; // Application is requesting throttling via ForceInterleavedReprojectionOn
+
+
+enum EVSync
+{
+	VSync_None,
+	VSync_WaitRender,	// block following render work until vsync
+	VSync_NoWaitRender,	// do not block following render work (allow to get started early)
+};
+
+enum EVRMuraCorrectionMode
+{
+	EVRMuraCorrectionMode_Default = 0,
+	EVRMuraCorrectionMode_NoCorrection
+};
+
+/** raw IMU data provided by IVRIOBuffer from paths to tracked devices with IMUs */
+enum Imu_OffScaleFlags
+{
+	OffScale_AccelX	= 0x01,
+	OffScale_AccelY	= 0x02,
+	OffScale_AccelZ	= 0x04,
+	OffScale_GyroX	= 0x08,
+	OffScale_GyroY	= 0x10,
+	OffScale_GyroZ	= 0x20,
+};
+	
+struct ImuSample_t
+{
+	double fSampleTime;
+	HmdVector3d_t vAccel;
+	HmdVector3d_t vGyro;
+	uint32_t unOffScaleFlags;
+};
+
+#pragma pack( pop )
+
+#define VR_INTERFACE
+
+// Mozilla: see mozilla.patch for more details
+// figure out how to import from the VR API dll
+// #if defined(_WIN32)
+
+//   #if !defined(OPENVR_BUILD_STATIC)
+//     #ifdef VR_API_EXPORT
+//       #define VR_INTERFACE extern "C" __declspec( dllexport )
+//     #else
+//       #define VR_INTERFACE extern "C" __declspec( dllimport )
+//     #endif
+//   #else
+//     #define VR_INTERFACE extern "C"
+//   #endif
+
+// #elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+// #ifdef VR_API_EXPORT
+//   #define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+// #else
+//   #define VR_INTERFACE extern "C" 
+// #endif
+
+// #else
+//   #error "Unsupported Platform."
+// #endif
+
+
+#if defined( _WIN32 )
+  #define VR_CALLTYPE __cdecl
+#else
+  #define VR_CALLTYPE 
+#endif
+
+} // namespace vr
+
+#endif // _INCLUDE_VRTYPES_H
+
+
+// vrannotation.h
+#ifdef API_GEN
+# define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
+#else
+# define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
+#define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
+#define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
+#define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
+#define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
+
+// ivrsystem.h
+namespace vr
+{
+
+class IVRSystem
+{
+public:
+
+
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+	/** The projection matrix for the specified eye */
+	virtual HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+	* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
+
+	/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
+	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+	* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+	virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) = 0;
+
+	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
+	* Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
+	*/
+	virtual HmdMatrix34_t GetEyeToHeadTransform( EVREye eEye ) = 0;
+
+	/** Returns the number of elapsed seconds since the last recorded vsync event. This 
+	*	will come from a vsync timer event in the timer if possible or from the application-reported
+	*   time if that is not available. If no vsync times are available the function will 
+	*   return zero for vsync time and frame counter and return false from the method. */
+	virtual bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) = 0;
+
+	/** [D3D9 Only]
+	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+	*/
+	virtual int32_t GetD3D9AdapterIndex() = 0;
+
+	/** [D3D10/11 Only]
+	* Returns the adapter index that the user should pass into EnumAdapters to create the device 
+	* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+	*/
+	virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex ) = 0;
+	
+	/**
+	 * Returns platform- and texture-type specific adapter identification so that applications and the
+	 * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+	 * will be set to 0.
+	 * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+	 * [D3D10/11/12 Only (D3D9 Not Supported)]
+	 *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+	 *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+	 *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+	 *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+	 * [Vulkan Only]
+	 *  Returns the VkPhysicalDevice that should be used by the application.
+	 *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+	 *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+	 * [macOS Only]
+	 *  For TextureType_IOSurface returns the id<MTLDevice> that should be used by the application.
+	 *  On 10.13+ for TextureType_OpenGL returns the 'registryId' of the renderer which should be used
+	 *   by the application. See Apple Technical Q&A QA1168 for information on enumerating GL Renderers, and the
+	 *   new kCGLRPRegistryIDLow and kCGLRPRegistryIDHigh CGLRendererProperty values in the 10.13 SDK.
+	 *  Pre 10.13 for TextureType_OpenGL returns 0, as there is no dependable way to correlate the HMDs MTLDevice
+	 *   with a GL Renderer.
+	 */
+	virtual void GetOutputDevice( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr ) = 0;
+
+	// ------------------------------------
+	// Display Mode methods
+	// ------------------------------------
+
+	/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+	virtual bool SetDisplayVisibility( bool bIsVisibleOnDesktop ) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+
+	/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
+	* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+	* calculate the time until the photons will be emitted from the display and pass that time into the method.
+	*
+	* This is roughly analogous to the inverse of the view matrix in most applications, though 
+	* many games will need to do some additional rotation or translation on top of the rotation
+	* and translation provided by the head pose.
+	*
+	* For devices where bPoseIsValid is true the application can use the pose to position the device
+	* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
+	*
+	* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+	* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
+	* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
+	* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+	* poses relative to the hardware-specific coordinate system in the driver.
+	*/
+	virtual void GetDeviceToAbsoluteTrackingPose( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) = 0;
+
+	/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+	* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+	* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+	* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+	* ResetSeatedZeroPose may not be exactly an identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+	* Users are also able to set their seated zero pose via the OpenVR Dashboard.
+	**/
+	virtual void ResetSeatedZeroPose() = 0;
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other. 
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	virtual uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) = 0;
+
+	/** Returns the level of activity on the device. */
+	virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) = 0;
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	virtual void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) = 0;
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. This function is deprecated in favor of the new IVRInput system. */
+	virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) = 0;
+
+	/** Returns the controller type associated with a device index. This function is deprecated in favor of the new IVRInput system. */
+	virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class. 
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+	* actual tracked device. */
+	virtual ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	/** Returns true if there is a device connected in this slot. */
+	virtual bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	virtual bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	virtual float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	virtual int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	virtual uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+	
+	/** Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
+	* this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
+	* greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties. */
+	virtual uint32_t GetArrayTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name 
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) = 0;
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+	* This pose will always be older than the call to this function and should not be used to render the device. 
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+	/** returns the name of an EVREvent enum value */
+	virtual const char *GetEventTypeNameFromEnum( EVREventType eType ) = 0;
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) = 0;
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. This function is deprecated in favor of the new IVRInput system. */
+	virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) = 0;
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. This function is deprecated in favor of the new IVRInput system. */
+	virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. This function is deprecated in favor of the new IVRInput system. */
+	virtual void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) = 0;
+
+	/** returns the name of an EVRButtonId enum value. This function is deprecated in favor of the new IVRInput system.  */
+	virtual const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) = 0;
+
+	/** returns the name of an EVRControllerAxisType enum value. This function is deprecated in favor of the new IVRInput system. */
+	virtual const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) = 0;
+
+	/** Returns true if this application is receiving input from the system. This would return false if 
+	* system-related functionality is consuming the input stream. */
+	virtual bool IsInputAvailable() = 0;
+
+	/** Returns true SteamVR is drawing controllers on top of the application. Applications should consider
+	* not drawing anything attached to the user's hands in this case. */
+	virtual bool IsSteamVRDrawingControllers() = 0;
+
+	/** Returns true if the user has put SteamVR into a mode that is distracting them from the application.
+	* For applications where this is appropriate, the application should pause ongoing activity. */
+	virtual bool ShouldApplicationPause() = 0;
+
+	/** Returns true if SteamVR is doing significant rendering work and the game should do what it can to reduce
+	* its own workload. One common way to do this is to reduce the size of the render target provided for each eye. */
+	virtual bool ShouldApplicationReduceRenderingWork() = 0;
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+	
+	/** Performs the actual firmware update if applicable. 
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	virtual vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	virtual void AcknowledgeQuit_Exiting() = 0;
+
+	// -------------------------------------
+	// App container sandbox methods
+	// -------------------------------------
+
+	/** Retrieves a null-terminated, semicolon-delimited list of UTF8 file paths that an application 
+	* must have read access to when running inside of an app container. Returns the number of bytes
+	* needed to hold the list. */
+	virtual uint32_t GetAppContainerFilePaths( VR_OUT_STRING() char *pchBuffer, uint32_t unBufferSize ) = 0;
+
+	// -------------------------------------
+	// System methods
+	// -------------------------------------
+
+	/** Returns the current version of the SteamVR runtime. The returned string will remain valid until VR_Shutdown is called.
+	*
+	* NOTE: Is it not appropriate to use this version to test for the presence of any SteamVR feature. Only use this version
+	* number for logging or showing to a user, and not to try to detect anything at runtime. When appropriate, feature-specific
+	* presence information is provided by other APIs. */
+	virtual const char *GetRuntimeVersion() = 0;
+
+};
+
+static const char * const IVRSystem_Version = "IVRSystem_021";
+
+}
+
+
+// ivrapplications.h
+namespace vr
+{
+
+	/** Used for all errors reported by the IVRApplications interface */
+	enum EVRApplicationError
+	{
+		VRApplicationError_None = 0,
+
+		VRApplicationError_AppKeyAlreadyExists = 100,	// Only one application can use any given key
+		VRApplicationError_NoManifest = 101,			// the running application does not have a manifest
+		VRApplicationError_NoApplication = 102,			// No application is running
+		VRApplicationError_InvalidIndex = 103,
+		VRApplicationError_UnknownApplication = 104,	// the application could not be found
+		VRApplicationError_IPCFailed = 105,				// An IPC failure caused the request to fail
+		VRApplicationError_ApplicationAlreadyRunning = 106, 
+		VRApplicationError_InvalidManifest = 107,
+		VRApplicationError_InvalidApplication = 108,
+		VRApplicationError_LaunchFailed = 109,			// the process didn't start
+		VRApplicationError_ApplicationAlreadyStarting = 110, // the system was already starting the same application
+		VRApplicationError_LaunchInProgress = 111,		// The system was already starting a different application
+		VRApplicationError_OldApplicationQuitting = 112, 
+		VRApplicationError_TransitionAborted = 113,
+		VRApplicationError_IsTemplate = 114, // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+		VRApplicationError_SteamVRIsExiting = 115,
+
+		VRApplicationError_BufferTooSmall = 200,		// The provided buffer was too small to fit the requested data
+		VRApplicationError_PropertyNotSet = 201,		// The requested property was not set
+		VRApplicationError_UnknownProperty = 202,
+		VRApplicationError_InvalidParameter = 203,
+	};
+
+	/** The maximum length of an application key */
+	static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+	/** these are the properties available on applications. */
+	enum EVRApplicationProperty
+	{
+		VRApplicationProperty_Name_String				= 0,
+
+		VRApplicationProperty_LaunchType_String			= 11,
+		VRApplicationProperty_WorkingDirectory_String	= 12,
+		VRApplicationProperty_BinaryPath_String			= 13,
+		VRApplicationProperty_Arguments_String			= 14,
+		VRApplicationProperty_URL_String				= 15,
+
+		VRApplicationProperty_Description_String		= 50,
+		VRApplicationProperty_NewsURL_String			= 51,
+		VRApplicationProperty_ImagePath_String			= 52,
+		VRApplicationProperty_Source_String				= 53,
+		VRApplicationProperty_ActionManifestURL_String	= 54,
+
+		VRApplicationProperty_IsDashboardOverlay_Bool	= 60,
+		VRApplicationProperty_IsTemplate_Bool			= 61,
+		VRApplicationProperty_IsInstanced_Bool			= 62,
+		VRApplicationProperty_IsInternal_Bool			= 63,
+		VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+		VRApplicationProperty_IsHidden_Bool				= 65,
+
+		VRApplicationProperty_LastLaunchTime_Uint64		= 70,
+	};
+
+	enum EVRSceneApplicationState
+	{
+		EVRSceneApplicationState_None						      = 0, // Scene Application is not running
+		EVRSceneApplicationState_Starting					      = 1, // Scene Application is starting
+		EVRSceneApplicationState_Quitting					      = 2, // Scene Application is quitting
+		EVRSceneApplicationState_Running						  = 3, // Scene Application is running, and submitting frames, a custom skybox, or a visible overlay
+		EVRSceneApplicationState_Waiting						  = 4, // Scene Application is running, but not drawing anything
+	};
+
+	struct AppOverrideKeys_t
+	{
+		const char *pchKey;
+		const char *pchValue;
+	};
+
+	/** Currently recognized mime types */
+	static const char * const k_pch_MimeType_HomeApp		= "vr/home";
+	static const char * const k_pch_MimeType_GameTheater	= "vr/game_theater";
+
+	class IVRApplications
+	{
+	public:
+
+		// ---------------  Application management  --------------- //
+
+		/** Adds an application manifest to the list to load when building the list of installed applications. 
+		* Temporary manifests are not automatically loaded */
+		virtual EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) = 0;
+
+		/** Removes an application manifest from the list to load when building the list of installed applications. */
+		virtual EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) = 0;
+
+		/** Returns true if an application is installed */
+		virtual bool IsApplicationInstalled( const char *pchAppKey ) = 0;
+
+		/** Returns the number of applications available in the list */
+		virtual uint32_t GetApplicationCount() = 0;
+
+		/** Returns the key of the specified application. The index is at least 0 and is less than the return 
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+		* fit the key. */
+		virtual EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Returns the key of the application for the specified Process Id. The buffer should be at least 
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+		virtual EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+		virtual EVRApplicationError LaunchApplication( const char *pchAppKey ) = 0;
+
+		/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+		virtual EVRApplicationError LaunchTemplateApplication( const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT( unKeys ) const AppOverrideKeys_t *pKeys, uint32_t unKeys ) = 0;
+
+		/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+		virtual vr::EVRApplicationError LaunchApplicationFromMimeType( const char *pchMimeType, const char *pchArgs ) = 0;
+
+		/** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+		* dashboard overlay applications. */
+		virtual EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) = 0;
+
+		/** Cancel a pending launch for an application */
+		virtual bool CancelApplicationLaunch( const char *pchAppKey ) = 0;
+
+		/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+		* for the now running application. Passing a process ID of 0 identifies the calling process. 
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+		virtual EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) = 0;
+
+		/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+		virtual uint32_t GetApplicationProcessId( const char *pchAppKey ) = 0;
+
+		/** Returns a string for an applications error */
+		virtual const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) = 0;
+
+		// ---------------  Application properties  --------------- //
+
+		/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+		virtual uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Returns a bool value for an application property. Returns false in all error cases. */
+		virtual bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+		virtual uint64_t GetApplicationPropertyUint64( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		virtual EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) = 0;
+
+		/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		virtual bool GetApplicationAutoLaunch( const char *pchAppKey ) = 0;
+
+		/** Adds this mime-type to the list of supported mime types for this application*/
+		virtual EVRApplicationError SetDefaultApplicationForMimeType( const char *pchAppKey, const char *pchMimeType ) = 0;
+
+		/** return the app key that will open this mime type */
+		virtual bool GetDefaultApplicationForMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Get the list of supported mime types for this application, comma-delimited */
+		virtual bool GetApplicationSupportedMimeTypes( const char *pchAppKey, VR_OUT_STRING() char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer ) = 0;
+
+		/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+		virtual uint32_t GetApplicationsThatSupportMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer ) = 0;
+
+		/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+		virtual uint32_t GetApplicationLaunchArguments( uint32_t unHandle, VR_OUT_STRING() char *pchArgs, uint32_t unArgs ) = 0;
+
+		// ---------------  Transition methods --------------- //
+
+		/** Returns the app key for the application that is starting up */
+		virtual EVRApplicationError GetStartingApplication( VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Returns the application transition state */
+		virtual EVRSceneApplicationState GetSceneApplicationState() = 0;
+
+		/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+		virtual EVRApplicationError PerformApplicationPrelaunchCheck( const char *pchAppKey ) = 0;
+
+		/** Returns a string for an application transition state */
+		virtual const char *GetSceneApplicationStateNameFromEnum( EVRSceneApplicationState state ) = 0;
+
+		/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable 
+		* as part of the same application. On success the calling process should exit immediately. 
+		* If working directory is NULL or "" the directory portion of the binary path will be 
+		* the working directory. */
+		virtual EVRApplicationError LaunchInternalProcess( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory ) = 0;
+
+		/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+		virtual uint32_t GetCurrentSceneProcessId() = 0;
+	};
+
+	static const char * const IVRApplications_Version = "IVRApplications_007";
+
+} // namespace vr
+
+// ivrsettings.h
+#include <string>
+
+namespace vr
+{
+	enum EVRSettingsError
+	{
+		VRSettingsError_None = 0,
+		VRSettingsError_IPCFailed = 1,
+		VRSettingsError_WriteFailed = 2,
+		VRSettingsError_ReadFailed = 3,
+		VRSettingsError_JsonParseFailed = 4,
+		VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
+	};
+
+	// The maximum length of a settings key
+	static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+	class IVRSettings
+	{
+	public:
+		virtual const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) = 0;
+
+		virtual void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) = 0;
+
+		// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+		// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+		virtual bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) = 0;
+
+		virtual void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+	};
+
+	//-----------------------------------------------------------------------------
+	static const char * const IVRSettings_Version = "IVRSettings_003";
+
+	class CVRSettingHelper
+	{
+		IVRSettings *m_pSettings;
+	public:
+	  // Mozilla: see mozilla.patch for more details
+		explicit CVRSettingHelper( IVRSettings *pSettings ) 
+		{ 
+			m_pSettings = pSettings; 
+		}
+
+		const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) 
+		{ 
+			return m_pSettings->GetSettingsErrorNameFromEnum( eError ); 
+		}
+
+		void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetBool( pchSection, pchSettingsKey, bValue, peError );
+		}
+
+		void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetInt32( pchSection, pchSettingsKey, nValue, peError );
+		}
+		void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetFloat( pchSection, pchSettingsKey, flValue, peError );
+		}
+		void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( pchSection, pchSettingsKey, pchValue, peError );
+		}
+		void SetString( const std::string & sSection, const std::string &  sSettingsKey, const std::string & sValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( sSection.c_str(), sSettingsKey.c_str(), sValue.c_str(), peError );
+		}
+
+		bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetBool( pchSection, pchSettingsKey, peError );
+		}
+		int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetInt32( pchSection, pchSettingsKey, peError );
+		}
+		float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetFloat( pchSection, pchSettingsKey, peError );
+		}
+		void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->GetString( pchSection, pchSettingsKey, pchValue, unValueLen, peError );
+		}
+		std::string GetString( const std::string & sSection, const std::string & sSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			char buf[4096];
+			vr::EVRSettingsError eError;
+			m_pSettings->GetString( sSection.c_str(), sSettingsKey.c_str(), buf, sizeof( buf ), &eError );
+			if ( peError )
+				*peError = eError;
+			if ( eError == vr::VRSettingsError_None )
+				return buf;
+			else
+				return "";
+		}
+
+		void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveSection( pchSection, peError );
+		}
+		void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveKeyInSection( pchSection, pchSettingsKey, peError );
+		}
+	};
+
+
+	//-----------------------------------------------------------------------------
+	// steamvr keys
+	static const char * const k_pch_SteamVR_Section = "steamvr";
+	static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+	static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+	static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+	static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+	static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+	static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+	static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+	static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
+	static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+	static const char * const k_pch_SteamVR_IPD_Float = "ipd";
+	static const char * const k_pch_SteamVR_Background_String = "background";
+	static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+	static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+	static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+	static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
+	static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+	static const char * const k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+	static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
+	static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+	static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+	static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+	static const char * const k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+	static const char * const k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+	static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+	static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+	static const char * const k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+	static const char * const k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+	static const char * const k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+	static const char * const k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+	static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+	static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+	static const char * const k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+	static const char * const k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+	static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+	static const char * const k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+	static const char * const k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph";
+	static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+	static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+	static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+	static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+	static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+	static const char * const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+	static const char * const k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride";
+	static const char * const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+	static const char * const k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
+	static const char * const k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
+	static const char * const k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
+	static const char * const k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
+	static const char * const k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
+	static const char * const k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
+	static const char * const k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
+	static const char * const k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
+	static const char * const k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
+	static const char * const k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
+	static const char * const k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
+	static const char * const k_pch_SteamVR_CustomIconStyle_String = "customIconStyle";
+	static const char * const k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle";
+	static const char * const k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
+	static const char * const k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
+	static const char * const k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+
+	//-----------------------------------------------------------------------------
+	// direct mode keys
+	static const char * const k_pch_DirectMode_Section = "direct_mode";
+	static const char * const k_pch_DirectMode_Enable_Bool = "enable";
+	static const char * const k_pch_DirectMode_Count_Int32 = "count";
+	static const char * const k_pch_DirectMode_EdidVid_Int32 = "edidVid";
+	static const char * const k_pch_DirectMode_EdidPid_Int32 = "edidPid";
+
+	//-----------------------------------------------------------------------------
+	// lighthouse keys
+	static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
+	static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+	static const char * const k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
+	static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+	static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+	static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+	static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+	static const char * const k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2";
+	static const char * const k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations";
+	static const char * const k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback";
+
+	//-----------------------------------------------------------------------------
+	// null keys
+	static const char * const k_pch_Null_Section = "driver_null";
+	static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
+	static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
+	static const char * const k_pch_Null_WindowX_Int32 = "windowX";
+	static const char * const k_pch_Null_WindowY_Int32 = "windowY";
+	static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+	static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+	static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+	static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+	static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+	static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+	//-----------------------------------------------------------------------------
+	// Windows MR keys
+	static const char * const k_pch_WindowsMR_Section = "driver_holographic";
+
+	//-----------------------------------------------------------------------------
+	// user interface keys
+	static const char * const k_pch_UserInterface_Section = "userinterface";
+	static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+	static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+	static const char * const k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized";
+	static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+	static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+	//-----------------------------------------------------------------------------
+	// notification keys
+	static const char * const k_pch_Notifications_Section = "notifications";
+	static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+	//-----------------------------------------------------------------------------
+	// keyboard keys
+	static const char * const k_pch_Keyboard_Section = "keyboard";
+	static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+	static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
+	static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
+	static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+	static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+	static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
+	static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
+
+	//-----------------------------------------------------------------------------
+	// perf keys
+	static const char * const k_pch_Perf_Section = "perfcheck";
+	static const char * const k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD";
+	static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+	static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+	static const char * const k_pch_Perf_TestData_Float = "perfTestData";
+	static const char * const k_pch_Perf_GPUProfiling_Bool = "GPUProfiling";
+
+	//-----------------------------------------------------------------------------
+	// collision bounds keys
+	static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
+	static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+	static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+	static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+	static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+	static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+	static const char * const k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight";
+	static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+	static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+	static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+	static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+	static const char * const k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+
+	//-----------------------------------------------------------------------------
+	// camera keys
+	static const char * const k_pch_Camera_Section = "camera";
+	static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+	static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+	static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+	static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+	static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+	static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+	static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+	static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+	static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+	static const char * const k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode";
+
+	//-----------------------------------------------------------------------------
+	// audio keys
+	static const char * const k_pch_audio_Section = "audio";
+	static const char * const k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+	static const char * const k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+	static const char * const k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+	static const char * const k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+	static const char * const k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+	static const char * const k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+	static const char * const k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+	static const char * const k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+	static const char * const k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice";
+	static const char * const k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume";
+	static const char * const k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+	static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+	//-----------------------------------------------------------------------------
+	// power management keys
+	static const char * const k_pch_Power_Section = "power";
+	static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+	static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+	static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+	static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+	static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+	static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+	//-----------------------------------------------------------------------------
+	// dashboard keys
+	static const char * const k_pch_Dashboard_Section = "dashboard";
+	static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+	static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+	static const char * const k_pch_Dashboard_Position = "position";
+	static const char * const k_pch_Dashboard_DesktopScale = "desktopScale";
+	static const char * const k_pch_Dashboard_DashboardScale = "dashboardScale";
+
+	//-----------------------------------------------------------------------------
+	// model skin keys
+	static const char * const k_pch_modelskin_Section = "modelskins";
+
+	//-----------------------------------------------------------------------------
+	// driver keys - These could be checked in any driver_<name> section
+	static const char * const k_pch_Driver_Enable_Bool = "enable";
+	static const char * const k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode";
+	static const char * const k_pch_Driver_LoadPriority_Int32 = "loadPriority";
+
+	//-----------------------------------------------------------------------------
+	// web interface keys
+	static const char* const k_pch_WebInterface_Section = "WebInterface";
+
+	//-----------------------------------------------------------------------------
+	// vrwebhelper keys
+	static const char* const k_pch_VRWebHelper_Section = "VRWebHelper";
+	static const char* const k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled";
+	static const char* const k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort";
+
+	//-----------------------------------------------------------------------------
+	// tracking overrides - keys are device paths, values are the device paths their
+	//  tracking/pose information overrides
+	static const char* const k_pch_TrackingOverride_Section = "TrackingOverrides";
+
+	//-----------------------------------------------------------------------------
+	// per-app keys - the section name for these is the app key itself. Some of these are prefixed by the controller type
+	static const char* const k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL";
+	static const char* const k_pch_App_BindingLegacyAPISuffix_String = "_legacy";
+	static const char* const k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput";
+	static const char* const k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
+	static const char* const k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
+	static const char* const k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+	static const char* const k_pch_App_DominantHand_Int32 = "DominantHand";
+
+	//-----------------------------------------------------------------------------
+	// configuration for trackers
+	static const char * const k_pch_Trackers_Section = "trackers";
+
+	//-----------------------------------------------------------------------------
+	// configuration for desktop UI windows
+	static const char * const k_pch_DesktopUI_Section = "DesktopUI";
+
+	//-----------------------------------------------------------------------------
+	// Last known keys for righting recovery
+	static const char * const k_pch_LastKnown_Section = "LastKnown";
+	static const char* const k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer";
+	static const char* const k_pch_LastKnown_HMDModel_String = "HMDModel";
+
+	//-----------------------------------------------------------------------------
+	// Dismissed warnings
+	static const char * const k_pch_DismissedWarnings_Section = "DismissedWarnings";
+
+	//-----------------------------------------------------------------------------
+	// Input Settings
+	static const char * const k_pch_Input_Section = "input";
+	static const char* const k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
+	static const char* const k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
+	static const char* const k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
+
+	//-----------------------------------------------------------------------------
+	// Log of GPU performance
+	static const char * const k_pch_GpuSpeed_Section = "GpuSpeed";
+
+} // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,									// Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,	// A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,			// There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,		// Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,								// The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,		// Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,			// Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,				// Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,		// Collision Bounds haven't been calibrated for the current tracking center
+};
+
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	virtual bool GetPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	virtual void ReloadInfo( void ) = 0;
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	virtual void SetSceneColor( HmdColor_t color ) = 0;
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	virtual void GetBoundsColor( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor ) = 0;
+
+	/** Determine whether the bounds are showing right now **/
+	virtual bool AreBoundsVisible() = 0;
+
+	/** Force the bounds to show, mostly for utilities **/
+	virtual void ForceBoundsVisible( bool bForce ) = 0;
+};
+
+static const char * const IVRChaperone_Version = "IVRChaperone_003";
+
+#pragma pack( pop )
+
+}
+
+// ivrchaperonesetup.h
+namespace vr
+{
+
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,		// The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,		// The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+
+	/** Saves the current working copy to disk */
+	virtual bool CommitWorkingCopy( EChaperoneConfigFile configFile ) = 0;
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	virtual void RevertWorkingCopy() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	virtual bool GetWorkingPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetWorkingPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified from the working copy. */
+	virtual bool GetWorkingCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified. */
+	virtual bool GetLiveCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+	/** Returns the preferred seated position from the working copy. */
+	virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	/** Returns the standing origin from the working copy. */
+	virtual bool GetWorkingStandingZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose ) = 0;
+
+	/** Sets the Play Area in the working copy. */
+	virtual void SetWorkingPlayAreaSize( float sizeX, float sizeZ ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. Note: ceiling height is ignored. */
+	virtual void SetWorkingCollisionBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. */
+	virtual void SetWorkingPerimeter( VR_ARRAY_COUNT( unPointCount ) HmdVector2_t *pPointBuffer, uint32_t unPointCount ) = 0;
+
+	/** Sets the preferred seated position in the working copy. */
+	virtual void SetWorkingSeatedZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	/** Sets the preferred standing position in the working copy. */
+	virtual void SetWorkingStandingZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose ) = 0;
+
+	/** Tear everything down and reload it from the file on disk */
+	virtual void ReloadFromDisk( EChaperoneConfigFile configFile ) = 0;
+
+	/** Returns the preferred seated position. */
+	virtual bool GetLiveSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	virtual bool ExportLiveToBuffer( VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength ) = 0;
+	virtual bool ImportFromBufferToWorking( const char *pBuffer, uint32_t nImportFlags ) = 0;
+
+	/** Shows the chaperone data in the working set to preview in the compositor.*/
+	virtual void ShowWorkingSetPreview() = 0;
+
+	/** Hides the chaperone data in the working set to preview in the compositor (if it was visible).*/
+	virtual void HideWorkingSetPreview() = 0;
+
+	/** Fire an event that the tracking system can use to know room setup is about to begin. This lets the tracking
+	 * system make any last minute adjustments that should be incorporated into the new setup.  If the user is adjusting
+	 * live in HMD using a tweak tool, keep in mind that calling this might cause the user to see the room jump. */
+	virtual void RoomSetupStarting() = 0;
+};
+
+static const char * const IVRChaperoneSetup_Version = "IVRChaperoneSetup_006";
+
+
+}
+
+// ivrcompositor.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+	VRCompositorError_None						= 0,
+	VRCompositorError_RequestFailed				= 1,
+	VRCompositorError_IncompatibleVersion		= 100,
+	VRCompositorError_DoNotHaveFocus			= 101,
+	VRCompositorError_InvalidTexture			= 102,
+	VRCompositorError_IsNotSceneApplication		= 103,
+	VRCompositorError_TextureIsOnWrongDevice	= 104,
+	VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	VRCompositorError_SharedTexturesNotSupported = 106,
+	VRCompositorError_IndexOutOfRange			= 107,
+	VRCompositorError_AlreadySubmitted			= 108,
+	VRCompositorError_InvalidBounds				= 109,
+	VRCompositorError_AlreadySet				= 110,
+};
+
+/** Timing mode passed to SetExplicitTimingMode(); see that function for documentation */
+enum EVRCompositorTimingMode
+{
+	VRCompositorTimingMode_Implicit											= 0,
+	VRCompositorTimingMode_Explicit_RuntimePerformsPostPresentHandoff		= 1,
+	VRCompositorTimingMode_Explicit_ApplicationPerformsPostPresentHandoff	= 2,
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid; // Process id associated with these stats (may no longer be running).
+	uint32_t m_nNumFramePresents; // total number of times we called present (includes reprojected frames)
+	uint32_t m_nNumDroppedFrames; // total number of times an old frame was re-scanned out (without reprojection)
+	uint32_t m_nNumReprojectedFrames; // total number of times a frame was scanned out a second time (with reprojection)
+
+	/** Values recorded at startup before application has fully faded in the first time. */
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+
+	/** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+	* system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+
+	/** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+	* fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+	* Does not include values recorded during start up or loading. */
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+struct Compositor_StageRenderSettings
+{
+	/** Primary color is applied as a tint to (i.e. multiplied with) the model's texture */
+	HmdColor_t m_PrimaryColor;
+	HmdColor_t m_SecondaryColor;
+
+	/** Vignette radius is in meters and is used to fade to the specified secondary solid color over
+	* that 3D distance from the origin of the playspace. */
+	float m_flVignetteInnerRadius;
+	float m_flVignetteOuterRadius;
+
+	/** Fades to the secondary color based on view incidence.  This variable controls the linearity
+	* of the effect.  It is mutually exclusive with vignette.  Additionally, it treats the mesh as faceted. */
+	float m_flFresnelStrength;
+
+	/** Controls backface culling. */
+	bool m_bBackfaceCulling;
+
+	/** Converts the render model's texture to luma and applies to rgb equally.  This is useful to
+	* combat compression artifacts that can occur on desaturated source material. */
+	bool m_bGreyscale;
+
+	/** Renders mesh as a wireframe. */
+	bool m_bWireframe;
+};
+
+static inline Compositor_StageRenderSettings DefaultStageRenderSettings()
+{
+	Compositor_StageRenderSettings settings;
+	settings.m_PrimaryColor.r = 1.0f;
+	settings.m_PrimaryColor.g = 1.0f;
+	settings.m_PrimaryColor.b = 1.0f;
+	settings.m_PrimaryColor.a = 1.0f;
+	settings.m_SecondaryColor.r = 1.0f;
+	settings.m_SecondaryColor.g = 1.0f;
+	settings.m_SecondaryColor.b = 1.0f;
+	settings.m_SecondaryColor.a = 1.0f;
+	settings.m_flVignetteInnerRadius = 0.0f;
+	settings.m_flVignetteOuterRadius = 0.0f;
+	settings.m_flFresnelStrength = 0.0f;
+	settings.m_bBackfaceCulling = false;
+	settings.m_bGreyscale = false;
+	settings.m_bWireframe = false;
+	return settings;
+}
+
+#pragma pack( pop )
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	virtual void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) = 0;
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	virtual EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	virtual EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) = 0;
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	virtual EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) = 0;
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the 
+	* compositor to show the grid until Submit is called again. */
+	virtual void ClearLastSubmittedFrame() = 0;
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	virtual void PostPresentHandoff() = 0;
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings( VR_ARRAY_COUNT( nFrames ) Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0;
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	virtual float GetFrameTimeRemaining() = 0;
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	virtual void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) = 0;
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) = 0;
+
+	/** Get current fade color value. */
+	virtual HmdColor_t GetCurrentFadeColor( bool bBackground = false ) = 0;
+
+	/** Fading the Grid in or out in fSeconds */
+	virtual void FadeGrid( float fSeconds, bool bFadeIn ) = 0;
+
+	/** Get current alpha value of grid. */
+	virtual float GetCurrentGridAlpha() = 0;
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	virtual EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) = 0;
+
+	/** Resets compositor skybox back to defaults. */
+	virtual void ClearSkyboxOverride() = 0;
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	virtual void CompositorBringToFront() = 0;
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	virtual void CompositorGoToBack() = 0;
+
+	/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+	* circumstances the compositor will manage its own life cycle based on what applications are running. */
+	virtual void CompositorQuit() = 0;
+	
+	/** Return whether the compositor is fullscreen */
+	virtual bool IsFullscreen() = 0;
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	virtual uint32_t GetLastFrameRenderer() = 0;
+
+	/** Returns true if the current process has the scene focus */
+	virtual bool CanRenderScene() = 0;
+
+	/** DEPRECATED: Opens the headset view (as either a window or docked widget depending on user's preferences) that displays what the user
+	* sees in the headset. */
+	virtual void ShowMirrorWindow() = 0;
+
+	/** DEPRECATED: Closes the headset view, either as a window or docked widget. */
+	virtual void HideMirrorWindow() = 0;
+
+	/** DEPRECATED: Returns true if the headset view (either as a window or docked widget) is shown. */
+	virtual bool IsMirrorWindowVisible() = 0;
+
+	/** Writes back buffer and stereo left/right pair from the application to a 'screenshots' folder in the SteamVR runtime root. */
+	virtual void CompositorDumpImages() = 0;
+
+	/** Let an app know it should be rendering with low resources. */
+	virtual bool ShouldAppRenderWithLowResources() = 0;
+
+	/** Override interleaved reprojection logic to force on. */
+	virtual void ForceInterleavedReprojectionOn( bool bOverride ) = 0;
+
+	/** Force reconnecting to the compositor process. */
+	virtual void ForceReconnectProcess() = 0;
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	virtual void SuspendRendering( bool bSuspend ) = 0;
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	virtual vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) = 0;
+	virtual void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) = 0;
+
+	/** Access to mirror textures from OpenGL. */
+	virtual vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) = 0;
+	virtual bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+	virtual void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+	virtual void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	virtual uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	virtual uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application should set the timing mode to Explicit_ApplicationPerformsPostPresentHandoff and *MUST* call PostPresentHandoff
+	* itself. If these conditions are met, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	virtual void SetExplicitTimingMode( EVRCompositorTimingMode eTimingMode ) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+
+	/** Indicates whether or not motion smoothing is enabled by the user settings.
+	* If you want to know if motion smoothing actually triggered due to a late frame, check Compositor_FrameTiming
+	* m_nReprojectionFlags & VRCompositor_ReprojectionMotion instead. */
+	virtual bool IsMotionSmoothingEnabled() = 0;
+
+	/** Indicates whether or not motion smoothing is supported by the current hardware. */
+	virtual bool IsMotionSmoothingSupported() = 0;
+
+	/** Indicates whether or not the current scene focus app is currently loading.  This is inferred from its use of FadeGrid to
+	* explicitly fade to the compositor to cover up the fact that it cannot render at a sustained full framerate during this time. */
+	virtual bool IsCurrentSceneFocusAppLoading() = 0;
+
+	/** Override the stage model used in the compositor to replace the grid.  RenderModelPath is a full path the an OBJ file to load.
+	* This file will be loaded asynchronously from disk and uploaded to the gpu by the runtime.  Once ready for rendering, the
+	* VREvent StageOverrideReady will be sent.  Use FadeToGrid to reveal.  Call ClearStageOverride to free the associated resources when finished. */
+	virtual EVRCompositorError SetStageOverride_Async( const char *pchRenderModelPath, const HmdMatrix34_t *pTransform = 0,
+		const Compositor_StageRenderSettings *pRenderSettings = 0, uint32_t nSizeOfRenderSettings = 0 ) = 0;
+
+	/** Resets the stage to its default user specified setting. */
+	virtual void ClearStageOverride() = 0;
+
+	/** Returns true if pBenchmarkResults is filled it.  Sets pBenchmarkResults with the result of the compositor benchmark.
+	* nSizeOfBenchmarkResults should be set to sizeof(Compositor_BenchmarkResults) */
+	virtual bool GetCompositorBenchmarkResults( Compositor_BenchmarkResults *pBenchmarkResults, uint32_t nSizeOfBenchmarkResults ) = 0;
+
+	/** Returns the frame id associated with the poses last returned by WaitGetPoses.  Deltas between IDs correspond to number of headset vsync intervals. */
+	virtual EVRCompositorError GetLastPosePredictionIDs( uint32_t *pRenderPosePredictionID, uint32_t *pGamePosePredictionID ) = 0;
+
+	/** Get the most up-to-date predicted (or recorded - up to 100ms old) set of poses for a given frame id. */
+	virtual EVRCompositorError GetPosesForFrame( uint32_t unPosePredictionID, VR_ARRAY_COUNT( unPoseArrayCount ) TrackedDevicePose_t* pPoseArray, uint32_t unPoseArrayCount ) = 0;
+};
+
+static const char * const IVRCompositor_Version = "IVRCompositor_026";
+
+} // namespace vr
+
+
+
+// ivrheadsetview.h
+namespace vr
+{
+	enum HeadsetViewMode_t
+	{
+		HeadsetViewMode_Left = 0,
+		HeadsetViewMode_Right,
+		HeadsetViewMode_Both
+	};
+
+	class IVRHeadsetView
+	{
+	public:
+		/** Sets the resolution in pixels to render the headset view. These values are clamped to k_unHeadsetViewMaxWidth
+		* and k_unHeadsetViewMaxHeight respectively. For cropped views, the rendered output will be fit to aspect ratio
+		* defined by the the specified dimensions. For uncropped views, the caller should use GetHeadsetViewAspectRation
+		* to adjust the requested render size to avoid squashing or stretching, and then apply letterboxing to compensate
+		* when displaying the results. */
+		virtual void SetHeadsetViewSize( uint32_t nWidth, uint32_t nHeight ) = 0;
+
+		/** Gets the current resolution used to render the headset view. */
+		virtual void GetHeadsetViewSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** Set the mode used to render the headset view. */
+		virtual void SetHeadsetViewMode( HeadsetViewMode_t eHeadsetViewMode ) = 0;
+
+		/** Get the current mode used to render the headset view. */
+		virtual HeadsetViewMode_t GetHeadsetViewMode() = 0;
+
+		/** Set whether or not the headset view should be rendered cropped to hide the hidden area mesh or not. */
+		virtual void SetHeadsetViewCropped( bool bCropped ) = 0;
+
+		/** Get the current cropping status of the headset view. */
+		virtual bool GetHeadsetViewCropped() = 0;
+
+		/** Get the aspect ratio (width:height) of the uncropped headset view (accounting for the current set mode). */
+		virtual float GetHeadsetViewAspectRatio() = 0;
+
+		/** Set the range [0..1] that the headset view blends across the stereo overlapped area in cropped both mode. */
+		virtual void SetHeadsetViewBlendRange( float flStartPct, float flEndPct ) = 0;
+
+		/** Get the current range [0..1] that the headset view blends across the stereo overlapped area in cropped both mode. */
+		virtual void GetHeadsetViewBlendRange( float *pStartPct, float *pEndPct ) = 0;
+	};
+
+	static const uint32_t k_unHeadsetViewMaxWidth = 3840;
+	static const uint32_t k_unHeadsetViewMaxHeight = 2160;
+	static const char * const k_pchHeadsetViewOverlayKey = "system.HeadsetView";
+
+	static const char * const IVRHeadsetView_Version = "IVRHeadsetView_001";
+
+	/** Returns the current IVRHeadsetView pointer or NULL the interface could not be found. */
+	VR_INTERFACE vr::IVRHeadsetView *VR_CALLTYPE VRHeadsetView();
+
+} // namespace vr
+
+
+// ivrnotifications.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+	NotificationBitmap_t()
+		: m_pImageData( nullptr )
+		, m_nWidth( 0 )
+		, m_nHeight( 0 )
+		, m_nBytesPerPixel( 0 )
+	{
+	}
+
+	void *m_pImageData;
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+};
+
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+	/** Transient notifications are automatically hidden after a period of time set by the user. 
+	* They are used for things like information and chat messages that do not require user interaction. */
+	EVRNotificationType_Transient = 0,
+
+	/** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+	* They are used for things like phone calls and alarms that require user interaction. */
+	EVRNotificationType_Persistent = 1,
+
+	/** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+	 * If there is already a system notification in the queue with that ID it is not accepted into the queue
+	 * to prevent spamming with system notification */
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+	/** Creates a notification with minimal external styling. */
+	EVRNotificationStyle_None = 0,
+
+	/** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+	EVRNotificationStyle_Application = 100,
+
+	/** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+	EVRNotificationStyle_Contact_Disabled = 200,
+
+	/** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+	EVRNotificationStyle_Contact_Enabled = 201,
+
+	/** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+	EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+
+
+#pragma pack( pop )
+
+/** Allows notification sources to interact with the VR system
+	This current interface is not yet implemented. Do not use yet. */
+class IVRNotifications
+{
+public:
+	/** Create a notification and enqueue it to be shown to the user.
+	* An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+	* To create a two-line notification, use a line break ('\n') to split the text into two lines.
+	* The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+	virtual EVRNotificationError CreateNotification( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId ) = 0;
+
+	/** Destroy a notification, hiding it first if it currently shown to the user. */
+	virtual EVRNotificationError RemoveNotification( VRNotificationId notificationId ) = 0;
+
+};
+
+static const char * const IVRNotifications_Version = "IVRNotifications_002";
+
+} // namespace vr
+
+
+
+// ivroverlay.h
+namespace vr
+{
+
+	/** The maximum length of an overlay key in bytes, counting the terminating null character. */
+	static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+	/** The maximum length of an overlay name in bytes, counting the terminating null character. */
+	static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+	/** The maximum number of overlays that can exist in the system at one time. */
+	static const uint32_t k_unMaxOverlayCount = 128;
+
+	/** The maximum number of overlay intersection mask primitives per overlay */
+	static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+	/** Types of input supported by VR Overlays */
+	enum VROverlayInputMethod
+	{
+		VROverlayInputMethod_None		= 0, // No input events will be generated automatically for this overlay
+		VROverlayInputMethod_Mouse		= 1, // Tracked controllers will get mouse events automatically
+		// VROverlayInputMethod_DualAnalog = 2, // No longer supported
+	};
+
+	/** Allows the caller to figure out which overlay transform getter to call. */
+	enum VROverlayTransformType
+	{
+		VROverlayTransform_Invalid					= -1,
+		VROverlayTransform_Absolute					= 0,
+		VROverlayTransform_TrackedDeviceRelative	= 1,
+		VROverlayTransform_SystemOverlay			= 2,
+		VROverlayTransform_TrackedComponent 		= 3,
+		VROverlayTransform_Cursor					= 4,
+		VROverlayTransform_DashboardTab				= 5,
+		VROverlayTransform_DashboardThumb			= 6,
+		VROverlayTransform_Mountable				= 7,
+	};
+
+	/** Overlay control settings */
+	enum VROverlayFlags
+	{
+		// Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+		VROverlayFlags_NoDashboardTab = 1 << 3,
+
+		// When this is set the overlay will receive VREvent_ScrollDiscrete events like a mouse wheel. 
+		// Requires mouse input mode.
+		VROverlayFlags_SendVRDiscreteScrollEvents = 1 << 6,
+
+		// Indicates that the overlay would like to receive
+		VROverlayFlags_SendVRTouchpadEvents = 1 << 7,
+
+		// If set this will render a vertical scroll wheel on the primary controller, 
+		//  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+		VROverlayFlags_ShowTouchPadScrollWheel = 1 << 8,
+
+		// If this is set ownership and render access to the overlay are transferred 
+		// to the new scene process on a call to IVRApplications::LaunchInternalProcess
+		VROverlayFlags_TransferOwnershipToInternalProcess = 1 << 9,
+
+		// If set, renders 50% of the texture in each eye, side by side
+		VROverlayFlags_SideBySide_Parallel = 1 << 10, // Texture is left/right
+		VROverlayFlags_SideBySide_Crossed = 1 << 11, // Texture is crossed and right/left
+
+		VROverlayFlags_Panorama = 1 << 12, // Texture is a panorama
+		VROverlayFlags_StereoPanorama = 1 << 13, // Texture is a stereo panorama
+
+		// If this is set on an overlay owned by the scene application that overlay
+		// will be sorted with the "Other" overlays on top of all other scene overlays
+		VROverlayFlags_SortWithNonSceneOverlays = 1 << 14,
+
+		// If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+		VROverlayFlags_VisibleInDashboard = 1 << 15,
+
+		// If this is set and the overlay's input method is not none, the system-wide laser mouse
+		// mode will be activated whenever this overlay is visible.
+		VROverlayFlags_MakeOverlaysInteractiveIfVisible = 1 << 16,
+
+		// If this is set the overlay will receive smooth VREvent_ScrollSmooth that emulate trackpad scrolling.
+		// Requires mouse input mode.
+		VROverlayFlags_SendVRSmoothScrollEvents = 1 << 17,
+
+		// If this is set, the overlay texture will be protected content, preventing unauthorized reads.
+		VROverlayFlags_ProtectedContent = 1 << 18,
+
+		// If this is set, the laser mouse splat will not be drawn over this overlay. The overlay will
+		// be responsible for drawing its own "cursor".
+		VROverlayFlags_HideLaserIntersection = 1 << 19,
+
+		// If this is set, clicking away from the overlay will cause it to receive a VREvent_Modal_Cancel event.
+		// This is ignored for dashboard overlays.
+		VROverlayFlags_WantsModalBehavior = 1 << 20,
+
+		// If this is set, alpha composition assumes the texture is pre-multiplied
+		VROverlayFlags_IsPremultiplied = 1 << 21,
+	};
+
+	enum VRMessageOverlayResponse
+	{
+		VRMessageOverlayResponse_ButtonPress_0 = 0,
+		VRMessageOverlayResponse_ButtonPress_1 = 1,
+		VRMessageOverlayResponse_ButtonPress_2 = 2,
+		VRMessageOverlayResponse_ButtonPress_3 = 3,
+		VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+		VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay= 5,
+		VRMessageOverlayResponse_ApplicationQuit = 6
+	};
+
+	struct VROverlayIntersectionParams_t
+	{
+		HmdVector3_t vSource;
+		HmdVector3_t vDirection;
+		ETrackingUniverseOrigin eOrigin;
+	};
+
+	struct VROverlayIntersectionResults_t
+	{
+		HmdVector3_t vPoint;
+		HmdVector3_t vNormal;
+		HmdVector2_t vUVs;
+		float fDistance;
+	};
+
+	// Input modes for the Big Picture gamepad text entry
+	enum EGamepadTextInputMode
+	{
+		k_EGamepadTextInputModeNormal = 0,
+		k_EGamepadTextInputModePassword = 1,
+		k_EGamepadTextInputModeSubmit = 2,
+	};
+
+	// Controls number of allowed lines for the Big Picture gamepad text entry
+	enum EGamepadTextInputLineMode
+	{
+		k_EGamepadTextInputLineModeSingleLine = 0,
+		k_EGamepadTextInputLineModeMultipleLines = 1
+	};
+
+	enum EVROverlayIntersectionMaskPrimitiveType
+	{
+		OverlayIntersectionPrimitiveType_Rectangle,
+		OverlayIntersectionPrimitiveType_Circle,
+	};
+
+	struct IntersectionMaskRectangle_t
+	{
+		float m_flTopLeftX;
+		float m_flTopLeftY;
+		float m_flWidth;
+		float m_flHeight;
+	};
+
+	struct IntersectionMaskCircle_t
+	{
+		float m_flCenterX;
+		float m_flCenterY;
+		float m_flRadius;
+	};
+
+	/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+	typedef union
+	{
+		IntersectionMaskRectangle_t m_Rectangle;
+		IntersectionMaskCircle_t m_Circle;
+	} VROverlayIntersectionMaskPrimitive_Data_t;
+
+	struct VROverlayIntersectionMaskPrimitive_t
+	{
+		EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+		VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+	};
+
+	enum EKeyboardFlags
+	{
+		KeyboardFlag_Minimal		= 1 << 0, // makes the keyboard send key events immediately instead of accumulating a buffer
+		KeyboardFlag_Modal			= 2 << 0, // makes the keyboard take all focus and dismiss when clicking off the panel
+	};
+
+
+	class IVROverlay
+	{
+	public:
+
+		// ---------------------------------------------
+		// Overlay management methods
+		// ---------------------------------------------
+
+		/** Finds an existing overlay with the specified key. */
+		virtual EVROverlayError FindOverlay( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle ) = 0;
+
+		/** Creates a new named overlay. All overlays start hidden and with default settings. */
+		virtual EVROverlayError CreateOverlay( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle ) = 0;
+
+		/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+		* automatically destroyed. */
+		virtual EVROverlayError DestroyOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+		virtual uint32_t GetOverlayKey( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
+
+		/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+		virtual uint32_t GetOverlayName( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
+
+		/** set the name to use for this overlay */
+		virtual EVROverlayError SetOverlayName( VROverlayHandle_t ulOverlayHandle, const char *pchName ) = 0;
+
+		/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
+		* will be set and VROverlayError_ArrayTooSmall is returned. */
+		virtual EVROverlayError GetOverlayImageData( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight ) = 0;
+
+		/** returns a string that corresponds with the specified overlay error. The string will be the name 
+		* of the error enum value for all valid error codes */
+		virtual const char *GetOverlayErrorNameFromEnum( EVROverlayError error ) = 0;
+
+		// ---------------------------------------------
+		// Overlay rendering methods
+		// ---------------------------------------------
+
+		/** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+		*	by default this is the pid of the process that made the overlay */
+		virtual EVROverlayError SetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle, uint32_t unPID ) = 0;
+
+		/** Gets the pid that is allowed to render to this overlay */
+		virtual uint32_t GetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Specify flag setting for a given overlay */
+		virtual EVROverlayError SetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled ) = 0;
+
+		/** Sets flag setting for a given overlay */
+		virtual EVROverlayError GetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled ) = 0;
+
+		/** Gets all the flags for a given overlay */
+		virtual EVROverlayError GetOverlayFlags( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags ) = 0;
+
+		/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+		virtual EVROverlayError SetOverlayColor( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue ) = 0;
+
+		/** Gets the color tint of the overlay quad. */
+		virtual EVROverlayError GetOverlayColor( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue ) = 0;
+
+		/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+		virtual EVROverlayError SetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float fAlpha ) = 0;
+
+		/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+		virtual EVROverlayError GetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float *pfAlpha ) = 0;
+
+		/** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+		* are twice as wide as they are tall. Defaults to 1.0. */
+		virtual EVROverlayError SetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float fTexelAspect ) = 0;
+
+		/** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+		virtual EVROverlayError GetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect ) = 0;
+
+		/** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+		*      Overlays owned by the scene application
+		*      Overlays owned by some other application
+		*
+		*	Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
+		*	sort order are rendered back to front base on distance from the HMD.
+		*
+		*	Sort order defaults to 0. */
+		virtual EVROverlayError SetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder ) = 0;
+
+		/** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+		virtual EVROverlayError GetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder ) = 0;
+
+		/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+		virtual EVROverlayError SetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters ) = 0;
+
+		/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+		virtual EVROverlayError GetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters ) = 0;
+
+		/** Use to draw overlay as a curved surface. Curvature is a percentage from (0..1] where 1 is a fully closed cylinder.
+		* For a specific radius, curvature can be computed as: overlay.width / (2 PI r). */
+		virtual EVROverlayError SetOverlayCurvature( VROverlayHandle_t ulOverlayHandle, float fCurvature ) = 0;
+
+		/** Returns the curvature of the overlay as a percentage from (0..1] where 1 is a fully closed cylinder. */
+		virtual EVROverlayError GetOverlayCurvature( VROverlayHandle_t ulOverlayHandle, float *pfCurvature ) = 0;
+
+		/** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+		* If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+		virtual EVROverlayError SetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace ) = 0;
+
+		/** Gets the overlay's current colorspace setting. */
+		virtual EVROverlayError GetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace ) = 0;
+
+		/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+		virtual EVROverlayError SetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds ) = 0;
+
+		/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+		virtual EVROverlayError GetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds ) = 0;
+
+		/** Returns the transform type of this overlay. */
+		virtual EVROverlayError GetOverlayTransformType( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType ) = 0;
+
+		/** Sets the transform to absolute tracking origin. */
+		virtual EVROverlayError SetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
+
+		/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+		virtual EVROverlayError GetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
+
+		/** Sets the transform to relative to the transform of the specified tracked device. */
+		virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
+
+		/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+		virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
+
+		/** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+		* drawing the device. Overlays with this transform type cannot receive mouse events. */
+		virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName ) = 0;
+
+		/** Gets the transform information when the overlay is rendering on a component. */
+		virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameSize ) = 0;
+
+		/** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+		virtual vr::EVROverlayError GetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
+		
+		/** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+		virtual vr::EVROverlayError SetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
+
+		/** Sets the hotspot for the specified overlay when that overlay is used as a cursor. These are in texture space with 0,0 in the upper left corner of
+		* the texture and 1,1 in the lower right corner of the texture. */
+		virtual EVROverlayError SetOverlayTransformCursor( VROverlayHandle_t ulCursorOverlayHandle, const HmdVector2_t *pvHotspot ) = 0;
+
+		/** Gets cursor hotspot/transform for the specified overlay */
+		virtual vr::EVROverlayError GetOverlayTransformCursor( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvHotspot ) = 0;
+
+		/** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+		virtual EVROverlayError ShowOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+		virtual EVROverlayError HideOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Returns true if the overlay is visible. */
+		virtual bool IsOverlayVisible( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+		virtual EVROverlayError GetTransformForOverlayCoordinates( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform ) = 0;
+
+		// ---------------------------------------------
+		// Overlay input methods
+		// ---------------------------------------------
+
+		/** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
+		* If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+		virtual bool PollNextOverlayEvent( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+		/** Returns the current input settings for the specified overlay. */
+		virtual EVROverlayError GetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod ) = 0;
+
+		/** Sets the input settings for the specified overlay. */
+		virtual EVROverlayError SetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod ) = 0;
+
+		/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels. */
+		virtual EVROverlayError GetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale ) = 0;
+
+		/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels (not in world space). */
+		virtual EVROverlayError SetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale ) = 0;
+
+		/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+		* specified settings. Returns false if there is no intersection. */
+		virtual bool ComputeOverlayIntersection( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults ) = 0;
+
+		/** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
+		* by the virtual mouse pointer */
+		virtual bool IsHoverTargetOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Sets a list of primitives to be used for controller ray intersection
+		* typically the size of the underlying UI in pixels (not in world space). */
+		virtual EVROverlayError SetOverlayIntersectionMask( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof( VROverlayIntersectionMaskPrimitive_t ) ) = 0;
+
+		/** Triggers a haptic event on the laser mouse controller for the specified overlay */
+		virtual EVROverlayError TriggerLaserMouseHapticVibration( VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude ) = 0;
+
+		/** Sets the cursor to use for the specified overlay. This will be drawn instead of the generic blob when the laser mouse is pointed at the specified overlay */
+		virtual EVROverlayError SetOverlayCursor( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle ) = 0;
+
+		/** Sets the override cursor position to use for this overlay in overlay mouse coordinates. This position will be used to draw the cursor
+		* instead of whatever the laser mouse cursor position is. */
+		virtual EVROverlayError SetOverlayCursorPositionOverride( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvCursor ) = 0;
+
+		/** Clears the override cursor position for this overlay */
+		virtual EVROverlayError ClearOverlayCursorPositionOverride( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		// ---------------------------------------------
+		// Overlay texture methods
+		// ---------------------------------------------
+
+		/** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+		*
+		* OpenGL dirty state:
+		*	glBindTexture
+		*/
+		virtual EVROverlayError SetOverlayTexture( VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture ) = 0;
+
+		/** Use this to tell the overlay system to release the texture set for this overlay. */
+		virtual EVROverlayError ClearOverlayTexture( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data 
+		* that can be sent. This function can only be called by the overlay's renderer process. */
+		virtual EVROverlayError SetOverlayRaw( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel ) = 0;
+
+		/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+		* This function can only be called by the overlay's renderer process */
+		virtual EVROverlayError SetOverlayFromFile( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath ) = 0;
+
+		/** Get the native texture handle/device for an overlay you have created.
+		* On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+		*
+		* The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+		*
+		* You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+		*
+		* pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+		* pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+		*/
+		virtual EVROverlayError GetOverlayTexture( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds ) = 0;
+
+		/** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+		* so only do it once you stop rendering this texture.
+		*/
+		virtual EVROverlayError ReleaseNativeOverlayHandle( VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle ) = 0;
+
+		/** Get the size of the overlay texture */
+		virtual EVROverlayError GetOverlayTextureSize( VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight ) = 0;
+
+		// ----------------------------------------------
+		// Dashboard Overlay Methods
+		// ----------------------------------------------
+
+		/** Creates a dashboard overlay and returns its handle */
+		virtual EVROverlayError CreateDashboardOverlay( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle ) = 0;
+
+		/** Returns true if the dashboard is visible */
+		virtual bool IsDashboardVisible() = 0;
+
+		/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+		virtual bool IsActiveDashboardOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+		virtual EVROverlayError SetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId ) = 0;
+
+		/** Gets the process ID that this dashboard overlay requires to have scene focus */
+		virtual EVROverlayError GetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId ) = 0;
+
+		/** Shows the dashboard. */
+		virtual void ShowDashboard( const char *pchOverlayToShow ) = 0;
+
+		/** Returns the tracked device that has the laser pointer in the dashboard */
+		virtual vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() = 0;
+
+		// ---------------------------------------------
+		// Keyboard methods
+		// ---------------------------------------------
+		
+		/** Show the virtual keyboard to accept input. In most cases, you should pass KeyboardFlag_Modal to enable modal overlay 
+		* behavior on the keyboard itself. See EKeyboardFlags for more. */
+		virtual EVROverlayError ShowKeyboard( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, 
+			const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, uint64_t uUserValue ) = 0;
+
+		/** Show the virtual keyboard to accept input for an overlay. In most cases, you should pass KeyboardFlag_Modal to enable modal 
+		* overlay behavior on the keyboard itself. See EKeyboardFlags for more. */
+		virtual EVROverlayError ShowKeyboardForOverlay( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode,
+			EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char *pchDescription, uint32_t unCharMax, 
+			const char *pchExistingText, uint64_t uUserValue ) = 0;
+
+		/** Get the text that was entered into the text input **/
+		virtual uint32_t GetKeyboardText( VR_OUT_STRING() char *pchText, uint32_t cchText ) = 0;
+
+		/** Hide the virtual keyboard **/
+		virtual void HideKeyboard() = 0;
+
+		/** Set the position of the keyboard in world space **/
+		virtual void SetKeyboardTransformAbsolute( ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform ) = 0;
+
+		/** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+		virtual void SetKeyboardPositionForOverlay( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect ) = 0;
+
+		// ---------------------------------------------
+		// Message box methods
+		// ---------------------------------------------
+
+		/** Show the message overlay. This will block and return you a result. **/
+		virtual VRMessageOverlayResponse ShowMessageOverlay( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text = nullptr, const char* pchButton2Text = nullptr, const char* pchButton3Text = nullptr ) = 0;
+
+		/** If the calling process owns the overlay and it's open, this will close it. **/
+		virtual void CloseMessageOverlay() = 0;
+	};
+
+	static const char * const IVROverlay_Version = "IVROverlay_024";
+
+} // namespace vr
+
+// ivroverlayview.h
+namespace vr
+{
+	struct VROverlayView_t
+	{
+		VROverlayHandle_t overlayHandle;
+		Texture_t texture;
+		VRTextureBounds_t textureBounds;
+	};
+
+	enum EDeviceType
+	{
+		DeviceType_Invalid           = -1, // Invalid handle
+		DeviceType_DirectX11         = 0, // Handle is an ID3D11Device
+		DeviceType_Vulkan            = 1, // Handle is a pointer to a VRVulkanDevice_t structure
+	};
+
+	struct VRVulkanDevice_t
+	{
+		VkInstance_T *m_pInstance;
+		VkDevice_T *m_pDevice;
+		VkPhysicalDevice_T *m_pPhysicalDevice;
+		VkQueue_T *m_pQueue;
+		uint32_t m_uQueueFamilyIndex;
+	};
+
+	struct VRNativeDevice_t
+	{
+		void *handle; // See EDeviceType definition above
+		EDeviceType eType;
+	};
+
+	class IVROverlayView
+	{
+	public:
+		/** Acquire an OverlayView_t from an overlay handle
+		*
+		* The overlay view can be used to sample the contents directly by a native API. The
+		* contents of the OverlayView_t will remain unchanged through the lifetime of the
+		* OverlayView_t.
+		*
+		* The caller acquires read privileges over the OverlayView_t, but should not
+		* write to it.
+		*
+		* AcquireOverlayView() may be called on the same ulOverlayHandle multiple times to
+		* refresh the image contents. In this case the caller is strongly encouraged to re-use
+		* the same pOverlayView for all re-acquisition calls.
+		*
+		* If the producer has not yet queued an image, AcquireOverlayView will return success,
+		* and the Texture_t will have the expected ETextureType. However, the Texture_t->handle
+		* will be nullptr. Once the producer generates the first overlay frame, Texture_t->handle
+		* will become a valid handle.
+		*/
+		virtual EVROverlayError AcquireOverlayView(VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t *pNativeDevice, VROverlayView_t *pOverlayView, uint32_t unOverlayViewSize ) = 0;
+
+		/** Release an acquired OverlayView_t
+		*
+		* Denotes that pOverlayView will no longer require access to the resources it acquired in
+		* all previous calls to AcquireOverlayView().
+		*
+		* All OverlayView_t*'s provided to AcquireOverlayView() as pOverlayViews must be
+		* passed into ReleaseOverlayView() in order for the underlying GPU resources to be freed.
+		*/
+		virtual EVROverlayError ReleaseOverlayView(VROverlayView_t *pOverlayView) = 0;
+
+		/** Posts an overlay event */
+		virtual void PostOverlayEvent(VROverlayHandle_t ulOverlayHandle, const VREvent_t *pvrEvent) = 0;
+
+		/** Determines whether this process is permitted to view an overlay's content. */
+		virtual bool IsViewingPermitted( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+	};
+
+	static const char * const IVROverlayView_Version = "IVROverlayView_003";
+
+}
+
+// ivrrendermodels.h
+namespace vr
+{
+
+static const char * const k_pch_Controller_Component_GDC2015 = "gdc2015";   // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char * const k_pch_Controller_Component_Base = "base";         // For controllers with an unambiguous 'base'.
+static const char * const k_pch_Controller_Component_Tip = "tip";           // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char * const k_pch_Controller_Component_HandGrip = "handgrip"; // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char * const k_pch_Controller_Component_Status = "status";		// 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+	VRRenderModelError_None = 0,
+	VRRenderModelError_Loading = 100,
+	VRRenderModelError_NotSupported = 200,
+	VRRenderModelError_InvalidArg = 300,
+	VRRenderModelError_InvalidModel = 301,
+	VRRenderModelError_NoShapes = 302,
+	VRRenderModelError_MultipleShapes = 303,
+	VRRenderModelError_TooManyVertices = 304,
+	VRRenderModelError_MultipleTextures = 305,
+	VRRenderModelError_BufferTooSmall = 306,
+	VRRenderModelError_NotEnoughNormals = 307,
+	VRRenderModelError_NotEnoughTexCoords = 308,
+
+	VRRenderModelError_InvalidTexture = 400,
+};
+
+enum EVRRenderModelTextureFormat
+{
+	VRRenderModelTextureFormat_RGBA8_SRGB = 0, // RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+	VRRenderModelTextureFormat_BC2,
+	VRRenderModelTextureFormat_BC4,
+	VRRenderModelTextureFormat_BC7,
+	VRRenderModelTextureFormat_BC7_SRGB
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+	HmdVector3_t vPosition;		// position in meters in device space
+	HmdVector3_t vNormal;
+	float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth, unHeight; // width and height of the texture map in pixels
+	const uint8_t *rubTextureMapData;	// Map texture data.
+	EVRRenderModelTextureFormat format; // Refer to EVRRenderModelTextureFormat
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_t
+{
+	const RenderModel_Vertex_t *rVertexData;	// Vertex data for the mesh
+	uint32_t unVertexCount;						// Number of vertices in the vertex data
+	const uint16_t *rIndexData;					// Indices into the vertex data for each triangle
+	uint32_t unTriangleCount;					// Number of triangles in the mesh. Index count is 3 * TriangleCount
+	TextureID_t diffuseTextureId;				// Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible; // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack( pop )
+
+class IVRRenderModels
+{
+public:
+
+	/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+	* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk. 
+	*
+	* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the 
+	* application is finished with the render model it should call FreeRenderModel() to free the memory associated
+	* with the model.
+	*
+	* The method returns VRRenderModelError_Loading while the render model is still being loaded.
+	* The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+	virtual EVRRenderModelError LoadRenderModel_Async( const char *pchRenderModelName, RenderModel_t **ppRenderModel ) = 0;
+
+	/** Frees a previously returned render model
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeRenderModel( RenderModel_t *pRenderModel ) = 0;
+
+	/** Loads and returns a texture for use in the application. */
+	virtual EVRRenderModelError LoadTexture_Async( TextureID_t textureId, RenderModel_TextureMap_t **ppTexture ) = 0;
+
+	/** Frees a previously returned texture
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeTexture( RenderModel_TextureMap_t *pTexture ) = 0;
+
+	/** Creates a D3D11 texture and loads data into it. */
+	virtual EVRRenderModelError LoadTextureD3D11_Async( TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D ) = 0;
+
+	/** Helper function to copy the bits into an existing texture. */
+	virtual EVRRenderModelError LoadIntoTextureD3D11_Async( TextureID_t textureId, void *pDstTexture ) = 0;
+
+	/** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+	virtual void FreeTextureD3D11( void *pD3D11Texture2D ) = 0;
+
+	/** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetRenderModelName( uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen ) = 0;
+
+	/** Returns the number of available render models. */
+	virtual uint32_t GetRenderModelCount() = 0;
+
+
+	/** Returns the number of components of the specified render model.
+	*  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+	*  Examples controller components:
+	*   renderable things such as triggers, buttons
+	*   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+	*   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+	*   Returns 0 if components not supported, >0 otherwise */
+	virtual uint32_t GetComponentCount( const char *pchRenderModelName ) = 0;
+
+	/** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentName( const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING( ) char *pchComponentName, uint32_t unComponentNameLen ) = 0;
+
+	/** Get the button mask for all buttons associated with this component
+	*   If no buttons (or axes) are associated with this component, return 0
+	*   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+	*   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+	virtual uint64_t GetComponentButtonMask( const char *pchRenderModelName, const char *pchComponentName ) = 0;
+
+	/** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+	* If the component name is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentRenderModelName( const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING( ) char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen ) = 0;
+
+	/** Use this to query information about the component, as a function of the controller state.
+	*
+	* For dynamic controller components (ex: trigger) values will reflect component motions
+	* For static components this will return a consistent value independent of the VRControllerState_t
+	*
+	* If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+	* Otherwise, return true
+	* Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+	virtual bool GetComponentStateForDevicePath( const char *pchRenderModelName, const char *pchComponentName, vr::VRInputValueHandle_t devicePath, const vr::RenderModel_ControllerMode_State_t *pState, vr::RenderModel_ComponentState_t *pComponentState ) = 0;
+
+	/** This version of GetComponentState takes a controller state block instead of an action origin. This function is deprecated. You should use the new input system and GetComponentStateForDevicePath instead. */
+	virtual bool GetComponentState( const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState ) = 0;
+
+	/** Returns true if the render model has a component with the specified name */
+	virtual bool RenderModelHasComponent( const char *pchRenderModelName, const char *pchComponentName ) = 0;
+
+	/** Returns the URL of the thumbnail image for this rendermodel */
+	virtual uint32_t GetRenderModelThumbnailURL( const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError ) = 0;
+
+	/** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+	* hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+	* model. */
+	virtual uint32_t GetRenderModelOriginalPath( const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError ) = 0;
+
+	/** Returns a string for a render model error */
+	virtual const char *GetRenderModelErrorNameFromEnum( vr::EVRRenderModelError error ) = 0;
+};
+
+static const char * const IVRRenderModels_Version = "IVRRenderModels_006";
+
+}
+
+
+// ivrextendeddisplay.h
+namespace vr
+{
+
+	/** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+	* direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+	class IVRExtendedDisplay
+	{
+	public:
+
+		/** Size and position that the window needs to be on the VR display. */
+		virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+		virtual void GetEyeOutputViewport( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** [D3D10/11 Only]
+		* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+		* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+		*/
+		virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) = 0;
+
+	};
+
+	static const char * const IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+
+}
+
+
+// ivrtrackedcamera.h
+namespace vr
+{
+
+class IVRTrackedCamera
+{
+public:
+	/** Returns a string for an error */
+	virtual const char *GetCameraErrorNameFromEnum( vr::EVRTrackedCameraError eCameraError ) = 0;
+
+	/** For convenience, same as tracked property request Prop_HasCamera_Bool */
+	virtual vr::EVRTrackedCameraError HasCamera( vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera ) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetCameraFrameSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize ) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraIntrinsics( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter ) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraProjection( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) = 0;
+
+	/** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+	* If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+	* The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+	* The camera may go inactive due to lack of active consumers or headset idleness. */
+	virtual vr::EVRTrackedCameraError AcquireVideoStreamingService( vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle ) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamingService( vr::TrackedCameraHandle_t hTrackedCamera ) = 0;
+
+	/** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+	* A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+	* the caller to determine if the frame as advanced per the frame header sequence. 
+	* If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+	* Ideally a caller should be polling at ~16ms intervals */
+	virtual vr::EVRTrackedCameraError GetVideoStreamFrameBuffer( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight ) = 0; 
+
+	/** Access a shared D3D11 texture for the specified tracked camera stream.
+	* The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+	* Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+	* VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+	* by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted 
+	* guarantees a rectangle where all pixels are valid. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+
+	/** Access a shared GL texture for the specified tracked camera stream */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId ) = 0;
+	virtual void SetCameraTrackingSpace( vr::ETrackingUniverseOrigin eUniverse ) = 0;
+	virtual vr::ETrackingUniverseOrigin GetCameraTrackingSpace( ) = 0;
+};
+
+static const char * const IVRTrackedCamera_Version = "IVRTrackedCamera_006";
+
+} // namespace vr
+
+
+// ivrscreenshots.h
+namespace vr
+{
+
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+	VRScreenshotError_None							= 0,
+	VRScreenshotError_RequestFailed					= 1,
+	VRScreenshotError_IncompatibleVersion			= 100,
+	VRScreenshotError_NotFound						= 101,
+	VRScreenshotError_BufferTooSmall				= 102,
+	VRScreenshotError_ScreenshotAlreadyInProgress	= 108,
+};
+
+/** Allows the application to generate screenshots */
+class IVRScreenshots
+{
+public:
+	/** Request a screenshot of the requested type.
+	 *  A request of the VRScreenshotType_Stereo type will always
+	 *  work. Other types will depend on the underlying application
+	 *  support.
+	 *  The first file name is for the preview image and should be a
+	 *  regular screenshot (ideally from the left eye). The second
+	 *  is the VR screenshot in the correct format. They should be
+	 *  in the same aspect ratio.  Formats per type:
+	 *  VRScreenshotType_Mono: the VR filename is ignored (can be
+	 *  nullptr), this is a normal flat single shot.
+	 *  VRScreenshotType_Stereo:  The VR image should be a
+	 *  side-by-side with the left eye image on the left.
+	 *  VRScreenshotType_Cubemap: The VR image should be six square
+	 *  images composited horizontally.
+	 *  VRScreenshotType_StereoPanorama: above/below with left eye
+	 *  panorama being the above image.  Image is typically square
+	 *  with the panorama being 2x horizontal.
+	 *  
+	 *  Note that the VR dashboard will call this function when
+	 *  the user presses the screenshot binding (currently System
+	 *  Button + Trigger).  If Steam is running, the destination
+	 *  file names will be in %TEMP% and will be copied into
+	 *  Steam's screenshot library for the running application
+	 *  once SubmitScreenshot() is called.
+	 *  If Steam is not running, the paths will be in the user's
+	 *  documents folder under Documents\SteamVR\Screenshots.
+	 *  Other VR applications can call this to initiate a
+	 *  screenshot outside of user control.
+	 *  The destination file names do not need an extension,
+	 *  will be replaced with the correct one for the format
+	 *  which is currently .png. */
+	virtual vr::EVRScreenshotError RequestScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename ) = 0;
+
+	/** Called by the running VR application to indicate that it
+	 *  wishes to be in charge of screenshots.  If the
+	 *  application does not call this, the Compositor will only
+	 *  support VRScreenshotType_Stereo screenshots that will be
+	 *  captured without notification to the running app.
+	 *  Once hooked your application will receive a
+	 *  VREvent_RequestScreenshot event when the user presses the
+	 *  buttons to take a screenshot. */
+	virtual vr::EVRScreenshotError HookScreenshot( VR_ARRAY_COUNT( numTypes ) const vr::EVRScreenshotType *pSupportedTypes, int numTypes ) = 0;
+
+	/** When your application receives a
+	 *  VREvent_RequestScreenshot event, call these functions to get
+	 *  the details of the screenshot request. */
+	virtual vr::EVRScreenshotType GetScreenshotPropertyType( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError ) = 0;
+
+	/** Get the filename for the preview or vr image (see
+	 *  vr::EScreenshotPropertyFilenames).  The return value is
+	 *  the size of the string.   */
+ 	virtual uint32_t GetScreenshotPropertyFilename( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError ) = 0;
+
+	/** Call this if the application is taking the screen shot
+	 *  will take more than a few ms processing. This will result
+	 *  in an overlay being presented that shows a completion
+	 *  bar. */
+	virtual vr::EVRScreenshotError UpdateScreenshotProgress( vr::ScreenshotHandle_t screenshotHandle, float flProgress ) = 0;
+
+	/** Tells the compositor to take an internal screenshot of
+	 *  type VRScreenshotType_Stereo. It will take the current
+	 *  submitted scene textures of the running application and
+	 *  write them into the preview image and a side-by-side file
+	 *  for the VR image.
+	 *  This is similar to request screenshot, but doesn't ever
+	 *  talk to the application, just takes the shot and submits. */
+	virtual vr::EVRScreenshotError TakeStereoScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename ) = 0;
+
+	/** Submit the completed screenshot.  If Steam is running
+	 *  this will call into the Steam client and upload the
+	 *  screenshot to the screenshots section of the library for
+	 *  the running application.  If Steam is not running, this
+	 *  function will display a notification to the user that the
+	 *  screenshot was taken. The paths should be full paths with
+	 *  extensions.
+	 *  File paths should be absolute including extensions.
+	 *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+	 *  was a new shot taking by the app to be saved and not
+	 *  initiated by a user (achievement earned or something) */
+	virtual vr::EVRScreenshotError SubmitScreenshot( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename ) = 0;
+};
+
+static const char * const IVRScreenshots_Version = "IVRScreenshots_001";
+
+} // namespace vr
+
+
+
+// ivrresources.h
+namespace vr
+{
+
+class IVRResources
+{
+public:
+
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen ) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path. 
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath( const char *pchResourceName, const char *pchResourceTypeDirectory, VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferLen ) = 0;
+};
+
+static const char * const IVRResources_Version = "IVRResources_001";
+
+
+}
+// ivrdrivermanager.h
+namespace vr
+{
+
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName( vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	virtual DriverHandle_t GetDriverHandle( const char *pchDriverName ) = 0;
+
+	virtual bool IsEnabled( vr::DriverId_t nDriver ) const = 0;
+};
+
+static const char * const IVRDriverManager_Version = "IVRDriverManager_001";
+
+} // namespace vr
+
+
+
+// ivrinput.h
+namespace vr
+{
+	// Maximum number of characters in an action name, including the trailing null
+	static const uint32_t k_unMaxActionNameLength = 64; 
+
+	// Maximum number of characters in an action set name, including the trailing null
+	static const uint32_t k_unMaxActionSetNameLength = 64;
+
+	// Maximum number of origins for an action
+	static const uint32_t k_unMaxActionOriginCount = 16; 
+
+	// Maximum number of characters in a bone name, including the trailing null
+	static const uint32_t k_unMaxBoneNameLength = 32; 
+
+	enum EVRSkeletalTransformSpace
+	{
+		VRSkeletalTransformSpace_Model = 0, 
+		VRSkeletalTransformSpace_Parent = 1
+	};
+
+	enum EVRSkeletalReferencePose
+	{
+		VRSkeletalReferencePose_BindPose = 0,
+		VRSkeletalReferencePose_OpenHand,
+		VRSkeletalReferencePose_Fist,
+		VRSkeletalReferencePose_GripLimit
+	};
+
+	enum EVRFinger
+	{
+		VRFinger_Thumb = 0,
+		VRFinger_Index,
+		VRFinger_Middle,
+		VRFinger_Ring,
+		VRFinger_Pinky,
+		VRFinger_Count
+	};
+
+	enum EVRFingerSplay
+	{
+		VRFingerSplay_Thumb_Index = 0,
+		VRFingerSplay_Index_Middle,
+		VRFingerSplay_Middle_Ring,
+		VRFingerSplay_Ring_Pinky,
+		VRFingerSplay_Count
+	};
+
+	enum EVRSummaryType
+	{
+		// The skeletal summary data will match the animated bone transforms for the action.
+		VRSummaryType_FromAnimation = 0,	
+		
+		// The skeletal summary data will include unprocessed data directly from the device when available. 
+		// This data is generally less latent than the data that is computed from the animations.
+		VRSummaryType_FromDevice = 1,		
+	};
+
+	enum EVRInputFilterCancelType
+	{
+		VRInputFilterCancel_Timers = 0,
+		VRInputFilterCancel_Momentum = 1,
+	};
+
+	enum EVRInputStringBits
+	{
+		VRInputString_Hand = 0x01,
+		VRInputString_ControllerType = 0x02,
+		VRInputString_InputSource = 0x04,
+
+		VRInputString_All = 0xFFFFFFFF
+	};
+
+	struct InputAnalogActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action; will be delta updates for mouse actions */
+		float x, y, z;
+
+		/** Deltas since the previous call to UpdateActionState() */
+		float deltaX, deltaY, deltaZ;
+	
+		/** Time relative to now when this event happened. Will be negative to indicate a past time. */
+		float fUpdateTime;
+	};
+
+	struct InputDigitalActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action; will be true if currently pressed */
+		bool bState;
+
+		/** This is true if the state has changed since the last frame */
+		bool bChanged;
+
+		/** Time relative to now when this event happened. Will be negative to indicate a past time. */
+		float fUpdateTime;
+	};
+
+	struct InputPoseActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action */
+		TrackedDevicePose_t pose;
+	};
+
+	struct InputSkeletalActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+	};
+
+	struct InputOriginInfo_t
+	{
+		VRInputValueHandle_t devicePath;
+		TrackedDeviceIndex_t trackedDeviceIndex;
+		char rchRenderModelComponentName[128];
+	};
+
+	struct InputBindingInfo_t
+	{
+		char rchDevicePathName[128];
+		char rchInputPathName[128];
+		char rchModeName[128];
+		char rchSlotName[128];
+		char rchInputSourceType[ 32 ];
+	};
+
+	// * Experimental global action set priority *
+	// These constants are part of the experimental support in SteamVR for overlay
+	// apps selectively overriding input in the base scene application. This may be
+	// useful for overlay applications that need to use part or all of a controller
+	// without taking away all input to the game. This system must be enabled by the 
+	// "Experimental overlay input overrides" setting in the developer section of 
+	// SteamVR settings.
+	//
+	// To use this system, set the nPriority field of an action set to any number in
+	// this range. 
+	static const int32_t k_nActionSetOverlayGlobalPriorityMin	= 0x01000000;
+	static const int32_t k_nActionSetOverlayGlobalPriorityMax	= 0x01FFFFFF;
+
+	static const int32_t k_nActionSetPriorityReservedMin		= 0x02000000;
+
+	struct VRActiveActionSet_t
+	{
+		/** This is the handle of the action set to activate for this frame. */
+		VRActionSetHandle_t ulActionSet;
+
+		/** This is the handle of a device path that this action set should be active for. To
+		* activate for all devices, set this to k_ulInvalidInputValueHandle. */
+		VRInputValueHandle_t ulRestrictedToDevice;
+
+		/** The action set to activate for all devices other than ulRestrictedDevice. If 
+		* ulRestrictedToDevice is set to k_ulInvalidInputValueHandle, this parameter is 
+		* ignored. */
+		VRActionSetHandle_t ulSecondaryActionSet;
+
+		// This field is ignored
+		uint32_t unPadding;
+
+		/** The priority of this action set relative to other action sets. Any inputs
+		* bound to a source (e.g. trackpad, joystick, trigger) will disable bindings in
+		* other active action sets with a smaller priority. 
+		*
+		* Overlay applications (i.e. ApplicationType_Overlay) may set their action set priority 
+		* to a value between k_nActionSetOverlayGlobalPriorityMin and k_nActionSetOverlayGlobalPriorityMax
+		* to cause any inputs bound to a source used by that action set to be disabled in scene applications.
+		*
+		* No action set priority may value may be larger than k_nActionSetPriorityReservedMin
+		*/
+		int32_t nPriority;
+	};
+
+	/** Contains summary information about the current skeletal pose */
+	struct VRSkeletalSummaryData_t
+	{
+		/** The amount that each finger is 'curled' inwards towards the palm.  In the case of the thumb,
+		* this represents how much the thumb is wrapped around the fist.  
+		* 0 means straight, 1 means fully curled */
+		float	flFingerCurl[ VRFinger_Count ];
+
+		/** The amount that each pair of adjacent fingers are separated.  
+		* 0 means the digits are touching, 1 means they are fully separated.
+		*/
+		float	flFingerSplay[ VRFingerSplay_Count ];
+	};
+
+
+	class IVRInput
+	{
+	public:
+
+		// ---------------  Handle management   --------------- //
+
+		/** Sets the path to the action manifest JSON file that is used by this application. If this information
+		* was set on the Steam partner site, calls to this function are ignored. If the Steam partner site
+		* setting and the path provided by this call are different, VRInputError_MismatchedActionManifest is returned. 
+		* This call must be made before the first call to UpdateActionState or IVRSystem::PollNextEvent. */
+		virtual EVRInputError SetActionManifestPath( const char *pchActionManifestPath ) = 0;
+
+		/** Returns a handle for an action set. This handle is used for all performance-sensitive calls. */
+		virtual EVRInputError GetActionSetHandle( const char *pchActionSetName, VRActionSetHandle_t *pHandle ) = 0;
+
+		/** Returns a handle for an action. This handle is used for all performance-sensitive calls. */
+		virtual EVRInputError GetActionHandle( const char *pchActionName, VRActionHandle_t *pHandle ) = 0;
+
+		/** Returns a handle for any path in the input system. E.g. /user/hand/right */
+		virtual EVRInputError GetInputSourceHandle( const char *pchInputSourcePath, VRInputValueHandle_t *pHandle ) = 0;
+
+
+
+		// --------------- Reading action state ------------------- //
+
+		/** Reads the current state into all actions. After this call, the results of Get*Action calls 
+		* will be the same until the next call to UpdateActionState. */
+		virtual EVRInputError UpdateActionState( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount ) = 0;
+
+		/** Reads the state of a digital action given its handle. This will return VRInputError_WrongType if the type of
+		* action is something other than digital */
+		virtual EVRInputError GetDigitalActionData( VRActionHandle_t action, InputDigitalActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of an analog action given its handle. This will return VRInputError_WrongType if the type of
+		* action is something other than analog */
+		virtual EVRInputError GetAnalogActionData( VRActionHandle_t action, InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a pose action given its handle for the number of seconds relative to now. This
+		* will generally be called with negative times from the fUpdateTime fields in other actions. */
+		virtual EVRInputError GetPoseActionDataRelativeToNow( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a pose action given its handle. The returned values will match the values returned
+		* by the last call to IVRCompositor::WaitGetPoses(). */
+		virtual EVRInputError GetPoseActionDataForNextFrame( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a skeletal action given its handle. */
+		virtual EVRInputError GetSkeletalActionData( VRActionHandle_t action, InputSkeletalActionData_t *pActionData, uint32_t unActionDataSize ) = 0;
+
+		/** Returns the current dominant hand for the user for this application. This function will only return success for applications
+		* which include "supports_dominant_hand_setting": true in their action manifests. The dominant hand will only change after
+		* a call to UpdateActionState, and the action data returned after that point will use the new dominant hand. */
+		virtual EVRInputError GetDominantHand( ETrackedControllerRole *peDominantHand ) = 0;
+
+		/** Sets the dominant hand for the user for this application. */
+		virtual EVRInputError SetDominantHand( ETrackedControllerRole eDominantHand ) = 0;
+
+		// ---------------  Static Skeletal Data ------------------- //
+
+		/** Reads the number of bones in skeleton associated with the given action */
+		virtual EVRInputError GetBoneCount( VRActionHandle_t action, uint32_t* pBoneCount ) = 0;
+
+		/** Fills the given array with the index of each bone's parent in the skeleton associated with the given action */
+		virtual EVRInputError GetBoneHierarchy( VRActionHandle_t action, VR_ARRAY_COUNT( unIndexArayCount ) BoneIndex_t* pParentIndices, uint32_t unIndexArayCount ) = 0;
+
+		/** Fills the given buffer with the name of the bone at the given index in the skeleton associated with the given action */
+		virtual EVRInputError GetBoneName( VRActionHandle_t action, BoneIndex_t nBoneIndex, VR_OUT_STRING() char* pchBoneName, uint32_t unNameBufferSize ) = 0;
+
+		/** Fills the given buffer with the transforms for a specific static skeletal reference pose */
+		virtual EVRInputError GetSkeletalReferenceTransforms( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		/** Reads the level of accuracy to which the controller is able to track the user to recreate a skeletal pose */
+		virtual EVRInputError GetSkeletalTrackingLevel( VRActionHandle_t action, EVRSkeletalTrackingLevel* pSkeletalTrackingLevel ) = 0;
+
+		// ---------------  Dynamic Skeletal Data ------------------- //
+
+		/** Reads the state of the skeletal bone data associated with this action and copies it into the given buffer. */
+		virtual EVRInputError GetSkeletalBoneData( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		/** Reads summary information about the current pose of the skeleton associated with the given action.   */
+		virtual EVRInputError GetSkeletalSummaryData( VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData ) = 0;
+
+		/** Reads the state of the skeletal bone data in a compressed form that is suitable for
+		* sending over the network. The required buffer size will never exceed ( sizeof(VR_BoneTransform_t)*boneCount + 2).
+		* Usually the size will be much smaller. */
+		virtual EVRInputError GetSkeletalBoneDataCompressed( VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, VR_OUT_BUFFER_COUNT( unCompressedSize ) void *pvCompressedData, uint32_t unCompressedSize, uint32_t *punRequiredCompressedSize ) = 0;
+
+		/** Turns a compressed buffer from GetSkeletalBoneDataCompressed and turns it back into a bone transform array. */
+		virtual EVRInputError DecompressSkeletalBoneData( const void *pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		// --------------- Haptics ------------------- //
+
+		/** Triggers a haptic event as described by the specified action */
+		virtual EVRInputError TriggerHapticVibrationAction( VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		// --------------- Action Origins ---------------- //
+
+		/** Retrieve origin handles for an action */
+		virtual EVRInputError GetActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VR_ARRAY_COUNT( originOutCount ) VRInputValueHandle_t *originsOut, uint32_t originOutCount ) = 0;
+
+		/** Retrieves the name of the origin in the current language. unStringSectionsToInclude is a bitfield of values in EVRInputStringBits that allows the 
+			application to specify which parts of the origin's information it wants a string for. */
+		virtual EVRInputError GetOriginLocalizedName( VRInputValueHandle_t origin, VR_OUT_STRING() char *pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude ) = 0;
+
+		/** Retrieves useful information for the origin of this action */
+		virtual EVRInputError GetOriginTrackedDeviceInfo( VRInputValueHandle_t origin, InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize ) = 0;
+
+		/** Retrieves useful information about the bindings for an action */
+		virtual EVRInputError GetActionBindingInfo( VRActionHandle_t action, InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t *punReturnedBindingInfoCount ) = 0;
+
+		/** Shows the current binding for the action in-headset */
+		virtual EVRInputError ShowActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle ) = 0;
+
+		/** Shows the current binding all the actions in the specified action sets */
+		virtual EVRInputError ShowBindingsForActionSet( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight ) = 0;
+
+		/** Use this to query what action on the component returned by GetOriginTrackedDeviceInfo would trigger this binding. */
+		virtual EVRInputError GetComponentStateForBinding( const char *pchRenderModelName, const char *pchComponentName,
+			const InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount,
+			vr::RenderModel_ComponentState_t *pComponentState ) = 0;
+
+
+		// --------------- Legacy Input ------------------- //
+		virtual bool IsUsingLegacyInput() = 0;
+
+
+		// --------------- Utilities ------------------- //
+
+		/** Opens the binding user interface. If no app key is provided it will use the key from the calling process.
+		* If no set is provided it will open to the root of the app binding page. */
+		virtual EVRInputError OpenBindingUI( const char* pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop ) = 0;
+
+		/** Returns the variant set in the current bindings. If the binding doesn't include a variant setting, this function 
+		* will return an empty string */
+		virtual EVRInputError GetBindingVariant( vr::VRInputValueHandle_t ulDevicePath,
+			VR_OUT_STRING() char *pchVariantArray, uint32_t unVariantArraySize ) = 0;
+
+	};
+
+	static const char * const IVRInput_Version = "IVRInput_010";
+
+} // namespace vr
+
+// ivriobuffer.h
+namespace vr
+{
+
+typedef uint64_t IOBufferHandle_t;
+static const uint64_t k_ulInvalidIOBufferHandle = 0;
+	
+	enum EIOBufferError
+	{
+		IOBuffer_Success                  = 0,
+		IOBuffer_OperationFailed          = 100,
+		IOBuffer_InvalidHandle            = 101,
+		IOBuffer_InvalidArgument          = 102,
+		IOBuffer_PathExists               = 103,
+		IOBuffer_PathDoesNotExist         = 104,
+		IOBuffer_Permission               = 105,
+	};
+
+	enum EIOBufferMode
+	{
+		IOBufferMode_Read                 = 0x0001,
+		IOBufferMode_Write                = 0x0002,
+		IOBufferMode_Create               = 0x0200,
+	};
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose:
+	// ----------------------------------------------------------------------------------------------
+	class IVRIOBuffer
+	{
+	public:
+		/** opens an existing or creates a new IOBuffer of unSize bytes */
+		virtual vr::EIOBufferError Open( const char *pchPath, vr::EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, vr::IOBufferHandle_t *pulBuffer ) = 0;
+		
+		/** closes a previously opened or created buffer */
+		virtual vr::EIOBufferError Close( vr::IOBufferHandle_t ulBuffer ) = 0;
+		
+		/** reads up to unBytes from buffer into *pDst, returning number of bytes read in *punRead */
+		virtual vr::EIOBufferError Read( vr::IOBufferHandle_t ulBuffer, void *pDst, uint32_t unBytes, uint32_t *punRead ) = 0;
+		
+		/** writes unBytes of data from *pSrc into a buffer. */
+		virtual vr::EIOBufferError Write( vr::IOBufferHandle_t ulBuffer, void *pSrc, uint32_t unBytes ) = 0;
+		
+		/** retrieves the property container of an buffer. */
+		virtual vr::PropertyContainerHandle_t PropertyContainer( vr::IOBufferHandle_t ulBuffer ) = 0;
+
+		/** inexpensively checks for readers to allow writers to fast-fail potentially expensive copies and writes. */
+		virtual bool HasReaders( vr::IOBufferHandle_t ulBuffer ) = 0;
+	};
+
+	static const char *IVRIOBuffer_Version = "IVRIOBuffer_002";
+}
+
+// ivrspatialanchors.h
+namespace vr
+{
+	static const SpatialAnchorHandle_t k_ulInvalidSpatialAnchorHandle = 0;
+
+	struct SpatialAnchorPose_t
+	{
+		HmdMatrix34_t mAnchorToAbsoluteTracking;
+	};
+
+	class IVRSpatialAnchors
+	{
+	public:
+
+		/** Returns a handle for an spatial anchor described by "descriptor".  On success, pHandle
+		* will contain a handle valid for this session.  Caller can wait for an event or occasionally
+		* poll GetSpatialAnchorPose() to find the virtual coordinate associated with this anchor. */
+		virtual EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor( const char *pchDescriptor, SpatialAnchorHandle_t *pHandleOut ) = 0;
+
+		/** Returns a handle for an new spatial anchor at pPose.  On success, pHandle
+		* will contain a handle valid for this session.  Caller can wait for an event or occasionally
+		* poll GetSpatialAnchorDescriptor() to find the permanent descriptor for this pose.
+		* The result of GetSpatialAnchorPose() may evolve from this initial position if the driver chooses
+		* to update it.
+		* The anchor will be associated with the driver that provides unDeviceIndex, and the driver may use that specific
+		* device as a hint for how to best create the anchor.
+		* The eOrigin must match whatever tracking origin you are working in (seated/standing/raw).
+		* This should be called when the user is close to (and ideally looking at/interacting with) the target physical
+		* location.  At that moment, the driver will have the most information about how to recover that physical point
+		* in the future, and the quality of the anchor (when the descriptor is re-used) will be highest.
+		* The caller may decide to apply offsets from this initial pose, but is advised to stay relatively close to the 
+		* original pose location for highest fidelity. */
+		virtual EVRSpatialAnchorError CreateSpatialAnchorFromPose( TrackedDeviceIndex_t unDeviceIndex, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPose, SpatialAnchorHandle_t *pHandleOut ) = 0;
+
+		/** Get the pose for a given handle.  This is intended to be cheap enough to call every frame (or fairly often)
+		* so that the driver can refine this position when it has more information available. */
+		virtual EVRSpatialAnchorError GetSpatialAnchorPose( SpatialAnchorHandle_t unHandle, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPoseOut ) = 0;
+
+		/** Get the descriptor for a given handle.  This will be empty for handles where the driver has not
+		* yet built a descriptor.  It will be the application-supplied descriptor for previously saved anchors
+		* that the application is requesting poses for.  If the driver has called UpdateSpatialAnchorDescriptor()
+		* already in this session, it will be the descriptor provided by the driver.
+		* Returns true if the descriptor fits into the buffer, else false.  Buffer size should be at least
+		* k_unMaxSpatialAnchorDescriptorSize. */
+		virtual EVRSpatialAnchorError GetSpatialAnchorDescriptor( SpatialAnchorHandle_t unHandle, VR_OUT_STRING() char *pchDescriptorOut, uint32_t *punDescriptorBufferLenInOut ) = 0;
+
+	};
+
+	static const char * const IVRSpatialAnchors_Version = "IVRSpatialAnchors_001";
+
+} // namespace vr
+
+// ivrdebug.h
+namespace vr
+{
+	enum EVRDebugError
+	{
+		VRDebugError_Success = 0,
+		VRDebugError_BadParameter
+	};
+
+	/** Handle for vr profiler events */
+	typedef uint64_t VrProfilerEventHandle_t;
+
+	class IVRDebug
+	{
+	public:
+
+		/** Create a vr profiler discrete event (point)
+		* The event will be associated with the message provided in pchMessage, and the current
+		* time will be used as the event timestamp. */
+		virtual EVRDebugError EmitVrProfilerEvent( const char *pchMessage ) = 0;
+
+		/** Create an vr profiler duration event (line)
+		* The current time will be used as the timestamp for the start of the line.
+		* On success, pHandleOut will contain a handle valid for terminating this event. */
+		virtual EVRDebugError BeginVrProfilerEvent( VrProfilerEventHandle_t *pHandleOut ) = 0;
+
+		/** Terminate a vr profiler event
+		* The event associated with hHandle will be considered completed when this method is called.
+		* The current time will be used assocaited to the termination time of the event, and
+		* pchMessage will be used as the event title. */
+		virtual EVRDebugError FinishVrProfilerEvent( VrProfilerEventHandle_t hHandle, const char *pchMessage ) = 0;
+
+		/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+		* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
+		* The size of the response including its terminating null is returned. */
+		virtual uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, VR_OUT_STRING() char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0;
+
+	};
+
+	static const char * const IVRDebug_Version = "IVRDebug_001";
+
+} // namespace vr
+// End
+
+#endif // _OPENVR_API
+
+
+
+namespace vr
+{
+#if !defined( OPENVR_INTERFACE_INTERNAL )
+
+	/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+	* or relative to the current working directory. These are the local install versions of the equivalent
+	* functions in steamvr.h and will work without a local Steam install.
+	*
+	* This path is to the "root" of the VR API install. That's the directory with
+	* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+	*
+	* pStartupInfo is reserved for future use.
+	*/
+	inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr );
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	inline void VR_Shutdown();
+
+	/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+	* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+	* to know if initializing VR is a possibility but isn't ready to take that step yet.
+	*/
+	VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+	/** Returns true if the OpenVR runtime is installed. */
+	VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+	/** Returns where the OpenVR runtime is installed. */
+	VR_INTERFACE bool VR_GetRuntimePath( VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferSize, uint32_t *punRequiredBufferSize );
+	
+	/** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+	VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol( EVRInitError error );
+
+	/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+	* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+	VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+
+	/** Returns the interface of the specified version. This method must be called after VR_Init. The
+	* pointer returned is valid until VR_Shutdown is called.
+	*/
+	VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+
+	/** Returns whether the interface of the specified version exists.
+	*/
+	VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid( const char *pchInterfaceVersion );
+
+	/** Returns a token that represents whether the VR interface handles need to be reloaded */
+	VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+	// These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+	// They will go away in the future.
+	typedef EVRInitError HmdError;
+	typedef EVREye Hmd_Eye;
+	typedef EColorSpace ColorSpace;
+	typedef ETrackingResult HmdTrackingResult;
+	typedef ETrackedDeviceClass TrackedDeviceClass;
+	typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+	typedef ETrackedDeviceProperty TrackedDeviceProperty;
+	typedef ETrackedPropertyError TrackedPropertyError;
+	typedef EVRSubmitFlags VRSubmitFlags_t;
+	typedef EVRState VRState_t;
+	typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+	typedef EVROverlayError VROverlayError;
+	typedef EVRFirmwareError VRFirmwareError;
+	typedef EVRCompositorError VRCompositorError;
+	typedef EVRScreenshotError VRScreenshotsError;
+
+	inline uint32_t &VRToken()
+	{
+		static uint32_t token;
+		return token;
+	}
+
+	class COpenVRContext
+	{
+	public:
+		COpenVRContext() { Clear(); }
+		void Clear();
+
+		inline void CheckClear()
+		{
+			if ( VRToken() != VR_GetInitToken() )
+			{
+				Clear();
+				VRToken() = VR_GetInitToken();
+			}
+		}
+
+		IVRSystem *VRSystem()
+		{
+			CheckClear();
+			if ( m_pVRSystem == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSystem = ( IVRSystem * )VR_GetGenericInterface( IVRSystem_Version, &eError );
+			}
+			return m_pVRSystem;
+		}
+		IVRChaperone *VRChaperone()
+		{
+			CheckClear();
+			if ( m_pVRChaperone == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRChaperone = ( IVRChaperone * )VR_GetGenericInterface( IVRChaperone_Version, &eError );
+			}
+			return m_pVRChaperone;
+		}
+
+		IVRChaperoneSetup *VRChaperoneSetup()
+		{
+			CheckClear();
+			if ( m_pVRChaperoneSetup == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRChaperoneSetup = ( IVRChaperoneSetup * )VR_GetGenericInterface( IVRChaperoneSetup_Version, &eError );
+			}
+			return m_pVRChaperoneSetup;
+		}
+
+		IVRCompositor *VRCompositor()
+		{
+			CheckClear();
+			if ( m_pVRCompositor == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRCompositor = ( IVRCompositor * )VR_GetGenericInterface( IVRCompositor_Version, &eError );
+			}
+			return m_pVRCompositor;
+		}
+
+		IVROverlay *VROverlay()
+		{
+			CheckClear();
+			if ( m_pVROverlay == nullptr )
+			{
+				EVRInitError eError;
+				m_pVROverlay = ( IVROverlay * )VR_GetGenericInterface( IVROverlay_Version, &eError );
+			}
+			return m_pVROverlay;
+		}
+
+		IVROverlayView *VROverlayView()
+		{
+			CheckClear();
+			if ( m_pVROverlayView == nullptr )
+			{
+				EVRInitError eError;
+				m_pVROverlayView = ( IVROverlayView * ) VR_GetGenericInterface( IVROverlayView_Version, &eError );
+			}
+			return m_pVROverlayView;
+		}
+
+		IVRHeadsetView *VRHeadsetView()
+		{
+			CheckClear();
+			if ( m_pVRHeadsetView == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRHeadsetView = ( IVRHeadsetView * ) VR_GetGenericInterface( IVRHeadsetView_Version, &eError );
+			}
+			return m_pVRHeadsetView;
+		}
+
+		IVRResources *VRResources()
+		{
+			CheckClear();
+			if ( m_pVRResources == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRResources = (IVRResources *)VR_GetGenericInterface( IVRResources_Version, &eError );
+			}
+			return m_pVRResources;
+		}
+
+		IVRScreenshots *VRScreenshots()
+		{
+			CheckClear();
+			if ( m_pVRScreenshots == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRScreenshots = ( IVRScreenshots * )VR_GetGenericInterface( IVRScreenshots_Version, &eError );
+			}
+			return m_pVRScreenshots;
+		}
+
+		IVRRenderModels *VRRenderModels()
+		{
+			CheckClear();
+			if ( m_pVRRenderModels == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRRenderModels = ( IVRRenderModels * )VR_GetGenericInterface( IVRRenderModels_Version, &eError );
+			}
+			return m_pVRRenderModels;
+		}
+
+		IVRExtendedDisplay *VRExtendedDisplay()
+		{
+			CheckClear();
+			if ( m_pVRExtendedDisplay == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRExtendedDisplay = ( IVRExtendedDisplay * )VR_GetGenericInterface( IVRExtendedDisplay_Version, &eError );
+			}
+			return m_pVRExtendedDisplay;
+		}
+
+		IVRSettings *VRSettings()
+		{
+			CheckClear();
+			if ( m_pVRSettings == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSettings = ( IVRSettings * )VR_GetGenericInterface( IVRSettings_Version, &eError );
+			}
+			return m_pVRSettings;
+		}
+
+		IVRApplications *VRApplications()
+		{
+			CheckClear();
+			if ( m_pVRApplications == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRApplications = ( IVRApplications * )VR_GetGenericInterface( IVRApplications_Version, &eError );
+			}
+			return m_pVRApplications;
+		}
+
+		IVRTrackedCamera *VRTrackedCamera()
+		{
+			CheckClear();
+			if ( m_pVRTrackedCamera == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRTrackedCamera = ( IVRTrackedCamera * )VR_GetGenericInterface( IVRTrackedCamera_Version, &eError );
+			}
+			return m_pVRTrackedCamera;
+		}
+
+		IVRDriverManager *VRDriverManager()
+		{
+			CheckClear();
+			if ( !m_pVRDriverManager )
+			{
+				EVRInitError eError;
+				m_pVRDriverManager = ( IVRDriverManager * )VR_GetGenericInterface( IVRDriverManager_Version, &eError );
+			}
+			return m_pVRDriverManager;
+		}
+
+		IVRInput *VRInput()
+		{
+			CheckClear();
+			if ( !m_pVRInput )
+			{
+				EVRInitError eError;
+				m_pVRInput = (IVRInput *)VR_GetGenericInterface( IVRInput_Version, &eError );
+			}
+			return m_pVRInput;
+		}
+
+		IVRIOBuffer *VRIOBuffer()
+		{
+			if ( !m_pVRIOBuffer )
+			{
+				EVRInitError eError;
+				m_pVRIOBuffer = ( IVRIOBuffer * )VR_GetGenericInterface( IVRIOBuffer_Version, &eError );
+			}
+			return m_pVRIOBuffer;
+		}
+
+		IVRSpatialAnchors *VRSpatialAnchors()
+		{
+			CheckClear();
+			if ( !m_pVRSpatialAnchors )
+			{
+				EVRInitError eError;
+				m_pVRSpatialAnchors = (IVRSpatialAnchors *)VR_GetGenericInterface( IVRSpatialAnchors_Version, &eError );
+			}
+			return m_pVRSpatialAnchors;
+		}
+
+		IVRDebug *VRDebug()
+		{
+			CheckClear();
+			if ( !m_pVRDebug )
+			{
+				EVRInitError eError;
+				m_pVRDebug = (IVRDebug *)VR_GetGenericInterface( IVRDebug_Version, &eError );
+			}
+			return m_pVRDebug;
+		}
+
+		IVRNotifications *VRNotifications()
+		{
+			CheckClear();
+			if ( !m_pVRNotifications )
+			{
+				EVRInitError eError;
+				m_pVRNotifications = ( IVRNotifications * )VR_GetGenericInterface( IVRNotifications_Version, &eError );
+			}
+			return m_pVRNotifications;
+		}
+		
+	private:
+		IVRSystem			*m_pVRSystem;
+		IVRChaperone		*m_pVRChaperone;
+		IVRChaperoneSetup	*m_pVRChaperoneSetup;
+		IVRCompositor		*m_pVRCompositor;
+		IVRHeadsetView		*m_pVRHeadsetView;
+		IVROverlay			*m_pVROverlay;
+		IVROverlayView		*m_pVROverlayView;
+		IVRResources		*m_pVRResources;
+		IVRRenderModels		*m_pVRRenderModels;
+		IVRExtendedDisplay	*m_pVRExtendedDisplay;
+		IVRSettings			*m_pVRSettings;
+		IVRApplications		*m_pVRApplications;
+		IVRTrackedCamera	*m_pVRTrackedCamera;
+		IVRScreenshots		*m_pVRScreenshots;
+		IVRDriverManager	*m_pVRDriverManager;
+		IVRInput			*m_pVRInput;
+		IVRIOBuffer			*m_pVRIOBuffer;
+		IVRSpatialAnchors   *m_pVRSpatialAnchors;
+		IVRDebug			*m_pVRDebug;
+		IVRNotifications	*m_pVRNotifications;
+	};
+
+	inline COpenVRContext &OpenVRInternal_ModuleContext()
+	{
+		static void *ctx[ sizeof( COpenVRContext ) / sizeof( void * ) ];
+		return *( COpenVRContext * )ctx; // bypass zero-init constructor
+	}
+
+	inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+	inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+	inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+	inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+	inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+	inline IVROverlayView *VR_CALLTYPE VROverlayView() { return OpenVRInternal_ModuleContext().VROverlayView(); }
+	inline IVRHeadsetView *VR_CALLTYPE VRHeadsetView() { return OpenVRInternal_ModuleContext().VRHeadsetView(); }
+	inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+	inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+	inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+	inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+	inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+	inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+	inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+	inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+	inline IVRInput *VR_CALLTYPE VRInput() { return OpenVRInternal_ModuleContext().VRInput(); }
+	inline IVRIOBuffer *VR_CALLTYPE VRIOBuffer() { return OpenVRInternal_ModuleContext().VRIOBuffer(); }
+	inline IVRSpatialAnchors *VR_CALLTYPE VRSpatialAnchors() { return OpenVRInternal_ModuleContext().VRSpatialAnchors(); }
+	inline IVRNotifications *VR_CALLTYPE VRNotifications() { return OpenVRInternal_ModuleContext().VRNotifications(); }
+	inline IVRDebug *VR_CALLTYPE VRDebug() { return OpenVRInternal_ModuleContext().VRDebug(); }
+
+	inline void COpenVRContext::Clear()
+	{
+		m_pVRSystem = nullptr;
+		m_pVRChaperone = nullptr;
+		m_pVRChaperoneSetup = nullptr;
+		m_pVRCompositor = nullptr;
+		m_pVROverlay = nullptr;
+		m_pVROverlayView = nullptr;
+		m_pVRHeadsetView = nullptr;
+		m_pVRRenderModels = nullptr;
+		m_pVRExtendedDisplay = nullptr;
+		m_pVRSettings = nullptr;
+		m_pVRApplications = nullptr;
+		m_pVRTrackedCamera = nullptr;
+		m_pVRResources = nullptr;
+		m_pVRScreenshots = nullptr;
+		m_pVRDriverManager = nullptr;
+		m_pVRInput = nullptr;
+		m_pVRIOBuffer = nullptr;
+		m_pVRSpatialAnchors = nullptr;
+		m_pVRNotifications = nullptr;
+		m_pVRDebug = nullptr;
+	}
+	
+	VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo );
+	VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+	/** Finds the active installation of vrclient.dll and initializes it */
+	inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo )
+	{
+		IVRSystem *pVRSystem = nullptr;
+
+		EVRInitError eError;
+		VRToken() = VR_InitInternal2( &eError, eApplicationType, pStartupInfo );
+		COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+		ctx.Clear();
+
+		if ( eError == VRInitError_None )
+		{
+			if ( VR_IsInterfaceVersionValid( IVRSystem_Version ) )
+			{
+				pVRSystem = VRSystem();
+			}
+			else
+			{
+				VR_ShutdownInternal();
+				eError = VRInitError_Init_InterfaceNotFound;
+			}
+		}
+
+		if ( peError )
+			*peError = eError;
+		return pVRSystem;
+	}
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	inline void VR_Shutdown()
+	{
+		VR_ShutdownInternal();
+	}
+
+#endif // OPENVR_INTERFACE_INTERNAL
+}
diff --git a/gfx/vr/service/openvr/moz.build b/gfx/vr/service/openvr/moz.build
new file mode 100644
index 0000000000..5ad6d0b9b4
--- /dev/null
+++ b/gfx/vr/service/openvr/moz.build
@@ -0,0 +1,62 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# 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/.
+
+FINAL_LIBRARY = 'xul'
+
+DEFINES['VR_API_PUBLIC'] = True
+
+# Windows.h wrappers conflict with internal methods in openvr
+DEFINES['MOZ_DISABLE_WINDOWS_WRAPPER'] = True
+
+if CONFIG['OS_ARCH'] == 'WINNT':
+    if CONFIG['HAVE_64BIT_BUILD']:
+        DEFINES['WIN64'] = True
+    else:
+        DEFINES['WIN32'] = True
+
+if CONFIG['OS_ARCH'] == 'Darwin':
+    DEFINES['POSIX'] = True
+    DEFINES['OSX'] = True
+    if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
+        CXXFLAGS += ['-xobjective-c++']
+
+if CONFIG['OS_ARCH'] == 'Linux':
+    DEFINES['POSIX'] = True
+    DEFINES['LINUX'] = True
+    if CONFIG['HAVE_64BIT_BUILD']:
+        DEFINES['LINUX64'] = True
+    else:
+        DEFINES['LINUX32'] = True
+
+LOCAL_INCLUDES += [
+    '/toolkit/components/jsoncpp/include',
+]
+
+USE_LIBS += [
+    'jsoncpp',
+]
+
+EXPORTS += [
+    'headers/openvr.h',
+]
+
+SOURCES += [
+    'src/dirtools_public.cpp',
+    'src/envvartools_public.cpp',
+    'src/hmderrors_public.cpp',
+    'src/openvr_api_public.cpp',
+    'src/pathtools_public.cpp',
+    'src/sharedlibtools_public.cpp',
+    'src/strtools_public.cpp',
+    'src/vrpathregistry_public.cpp',
+]
+
+if CONFIG['CC_TYPE'] in ('clang', 'gcc'):
+    # Harmless warnings in 3rd party code
+    CXXFLAGS += [
+        '-Wno-error=parentheses',
+        '-Wno-error=unused-variable',
+    ]
diff --git a/gfx/vr/service/openvr/moz.yaml b/gfx/vr/service/openvr/moz.yaml
new file mode 100644
index 0000000000..715daba311
--- /dev/null
+++ b/gfx/vr/service/openvr/moz.yaml
@@ -0,0 +1,50 @@
+schema: 1
+
+bugzilla:
+  product: Core
+  component: WebVR
+
+origin:
+  name: openvr
+  description: OpenVR API interface
+
+  url: https://github.com/ValveSoftware/openvr
+
+  release: v1.11.11 (2020-04-23T17:06:49-08:00).
+  revision: v1.11.11
+
+  license: BSD-3-Clause
+
+vendoring:
+  url: https://github.com/ValveSoftware/openvr
+  source-hosting: github
+  tracking: tag
+
+  exclude:
+    - "**"
+
+  include:
+    - LICENSE
+    - README.md
+    - headers/openvr.h
+    - src/README
+    - src/*.h
+    - src/*.cpp
+    - src/vrcommon
+
+  update-actions:
+    - action: move-dir
+      from: '{vendor_dir}/src/vrcommon'
+      to: '{vendor_dir}/src'
+
+    # The "src/jsoncpp.cpp" file and the "src/json" directory can be skipped. OpenVR
+    # uses the jsoncpp library, which we have already imported elsewhere. If
+    # warnings about using deprecated jsoncpp classes show up during compilation
+    # you might need to reapply the patch in bug 1598288. It replaces uses of the
+    # `Json::Reader` and `Json::StyledWriter` classes with the more modern
+    # `Json::CharReaderBuilder` and `Json::StreamWriterBuilder`.
+    - action: delete-path
+      path: '{vendor_dir}/src/jsoncpp.cpp'
+
+  patches:
+    - "mozilla.patch"
diff --git a/gfx/vr/service/openvr/mozilla.patch b/gfx/vr/service/openvr/mozilla.patch
new file mode 100644
index 0000000000..212b5ebdd1
--- /dev/null
+++ b/gfx/vr/service/openvr/mozilla.patch
@@ -0,0 +1,621 @@
+Legacy steps to update the library:
+
+- Update the "strtools_public.h" and "strtools_public.cpp" files, commenting out
+  the "Uint64ToString", "wcsncpy_s", and "strncpy_s" functions.
+  The "Uint64ToString" function name conflicts with another used in Gecko and
+  the "errno_t" return type returned by the other functions is not defined in
+  Mozilla's macOS continuous integration build environments.  Fortunately, the
+  OpenVR SDK does not use these functions.
+
+- Replace the #define VR_INTERFACE in openvr.h to avoid extern'ing the functions.
+  Unlike the usual OpenVR API builds, we are not building a separate dll.
+
+- Add explicit in CVRSettingHelper constructor.
+
+- In strtools_public.cpp/.h, ensure that UTF16to8 and UTF8to16 are only
+  compiled under
+      #if defined( _WIN32 )
+  and redefine those functions to use ::WideCharToMultiByte and
+  MultiByteToWideChar, respectively. These are modified because the original
+  implementations contain unsupported try-catch.
+
+- In strtools_public.cpp, remove the definition of convert_type.
+
+- In strtools_public.cpp, remove the include of <codecvt>, as this causes
+  problems in compiling on Linux.
+
+- In pathtools_public.cpp/.h, comment out Path_UrlToFilePath and
+  Path_FilePathToUrl to avoid a compile error because 'alloca' isn't defined.
+
+- In vrpathregistry_public.cpp, CVRPathRegistry_Public::BLoadFromFile contains
+  a try-catch, which is not permitted. This code is simply commented out, but
+      Bug 1640068 - OpenVR code can fail JSON parsing and raise exceptions
+  is filed to address a safe fallback in the error condition.
+
+diff --git a/headers/openvr.h b/headers/openvr.h
+index ec26ef41564b9..b95fb1db7e0fe 100644
+--- a/headers/openvr.h
++++ b/headers/openvr.h
+@@ -1932,30 +1932,33 @@ struct ImuSample_t
+ 
+ #pragma pack( pop )
+ 
++#define VR_INTERFACE
++
++// Mozilla: see mozilla.patch for more details
+ // figure out how to import from the VR API dll
+-#if defined(_WIN32)
+-
+-  #if !defined(OPENVR_BUILD_STATIC)
+-    #ifdef VR_API_EXPORT
+-      #define VR_INTERFACE extern "C" __declspec( dllexport )
+-    #else
+-      #define VR_INTERFACE extern "C" __declspec( dllimport )
+-    #endif
+-  #else
+-    #define VR_INTERFACE extern "C"
+-  #endif
+-
+-#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+-
+-#ifdef VR_API_EXPORT
+-  #define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+-#else
+-  #define VR_INTERFACE extern "C" 
+-#endif
++// #if defined(_WIN32)
+ 
+-#else
+-  #error "Unsupported Platform."
+-#endif
++//   #if !defined(OPENVR_BUILD_STATIC)
++//     #ifdef VR_API_EXPORT
++//       #define VR_INTERFACE extern "C" __declspec( dllexport )
++//     #else
++//       #define VR_INTERFACE extern "C" __declspec( dllimport )
++//     #endif
++//   #else
++//     #define VR_INTERFACE extern "C"
++//   #endif
++
++// #elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
++
++// #ifdef VR_API_EXPORT
++//   #define VR_INTERFACE extern "C" __attribute__((visibility("default")))
++// #else
++//   #define VR_INTERFACE extern "C" 
++// #endif
++
++// #else
++//   #error "Unsupported Platform."
++// #endif
+ 
+ 
+ #if defined( _WIN32 )
+@@ -2557,7 +2560,8 @@ namespace vr
+ 	{
+ 		IVRSettings *m_pSettings;
+ 	public:
+-		CVRSettingHelper( IVRSettings *pSettings ) 
++	  // Mozilla: see mozilla.patch for more details
++		explicit CVRSettingHelper( IVRSettings *pSettings ) 
+ 		{ 
+ 			m_pSettings = pSettings; 
+ 		}
+diff --git a/src/pathtools_public.cpp b/src/pathtools_public.cpp
+index eb1373a57b1a5..e7f6d6ca1bf45 100644
+--- a/src/pathtools_public.cpp
++++ b/src/pathtools_public.cpp
+@@ -798,52 +798,54 @@ bool Path_WriteStringToTextFileAtomic( const std::string &strFilename, const cha
+ #define FILE_URL_PREFIX "file://"
+ #endif
+ 
++// Mozilla: see mozilla.patch for more details
+ // ----------------------------------------------------------------------------------------------------------------------------
+ // Purpose: Turns a path to a file on disk into a URL (or just returns the value if it's already a URL)
+ // ----------------------------------------------------------------------------------------------------------------------------
+-std::string Path_FilePathToUrl( const std::string & sRelativePath, const std::string & sBasePath )
+-{
+-	if ( StringHasPrefix( sRelativePath, "http://" )
+-		|| StringHasPrefix( sRelativePath, "https://" )
+-		|| StringHasPrefix( sRelativePath, "vr-input-workshop://" )
+-		|| StringHasPrefix( sRelativePath, "file://" )
+-	   )
+-	{
+-		return sRelativePath;
+-	}
+-	else
+-	{
+-		std::string sAbsolute = Path_MakeAbsolute( sRelativePath, sBasePath );
+-		if ( sAbsolute.empty() )
+-			return sAbsolute;
+-		sAbsolute = Path_FixSlashes( sAbsolute, '/' );
+-
+-		size_t unBufferSize = sAbsolute.length() * 3;
+-		char *pchBuffer = (char *)alloca( unBufferSize );
+-		V_URLEncodeFullPath( pchBuffer, (int)unBufferSize, sAbsolute.c_str(), (int)sAbsolute.length() );
+-
+-		return std::string( FILE_URL_PREFIX ) + pchBuffer;
+-	}
+-}
+-
++// std::string Path_FilePathToUrl( const std::string & sRelativePath, const std::string & sBasePath )
++// {
++// 	if ( StringHasPrefix( sRelativePath, "http://" )
++// 		|| StringHasPrefix( sRelativePath, "https://" )
++// 		|| StringHasPrefix( sRelativePath, "vr-input-workshop://" )
++// 		|| StringHasPrefix( sRelativePath, "file://" )
++// 	   )
++// 	{
++// 		return sRelativePath;
++// 	}
++// 	else
++// 	{
++// 		std::string sAbsolute = Path_MakeAbsolute( sRelativePath, sBasePath );
++// 		if ( sAbsolute.empty() )
++// 			return sAbsolute;
++// 		sAbsolute = Path_FixSlashes( sAbsolute, '/' );
++
++// 		size_t unBufferSize = sAbsolute.length() * 3;
++// 		char *pchBuffer = (char *)alloca( unBufferSize );
++// 		V_URLEncodeFullPath( pchBuffer, (int)unBufferSize, sAbsolute.c_str(), (int)sAbsolute.length() );
++
++// 		return std::string( FILE_URL_PREFIX ) + pchBuffer;
++// 	}
++// }
++
++// Mozilla: see mozilla.patch for more details
+ // -----------------------------------------------------------------------------------------------------
+ // Purpose: Strips off file:// off a URL and returns the path. For other kinds of URLs an empty string is returned
+ // -----------------------------------------------------------------------------------------------------
+-std::string Path_UrlToFilePath( const std::string & sFileUrl )
+-{
+-	if ( !strnicmp( sFileUrl.c_str(), FILE_URL_PREFIX, strlen( FILE_URL_PREFIX ) ) )
+-	{
+-		char *pchBuffer = (char *)alloca( sFileUrl.length() );
+-		V_URLDecodeNoPlusForSpace( pchBuffer, (int)sFileUrl.length(), 
+-			sFileUrl.c_str() + strlen( FILE_URL_PREFIX ), (int)( sFileUrl.length() - strlen( FILE_URL_PREFIX ) ) );
+-
+-		return Path_FixSlashes( pchBuffer );
+-	}
+-	else
+-	{
+-		return "";
+-	}
+-}
++// std::string Path_UrlToFilePath( const std::string & sFileUrl )
++// {
++// 	if ( !strnicmp( sFileUrl.c_str(), FILE_URL_PREFIX, strlen( FILE_URL_PREFIX ) ) )
++// 	{
++// 		char *pchBuffer = (char *)alloca( sFileUrl.length() );
++// 		V_URLDecodeNoPlusForSpace( pchBuffer, (int)sFileUrl.length(), 
++// 			sFileUrl.c_str() + strlen( FILE_URL_PREFIX ), (int)( sFileUrl.length() - strlen( FILE_URL_PREFIX ) ) );
++
++// 		return Path_FixSlashes( pchBuffer );
++// 	}
++// 	else
++// 	{
++// 		return "";
++// 	}
++// }
+ 
+ 
+ // -----------------------------------------------------------------------------------------------------
+diff --git a/src/pathtools_public.h b/src/pathtools_public.h
+index 9a120f43d6a57..33688fba2f4ad 100644
+--- a/src/pathtools_public.h
++++ b/src/pathtools_public.h
+@@ -98,8 +98,9 @@ std::string Path_ReadTextFile( const std::string &strFilename );
+ bool Path_WriteStringToTextFile( const std::string &strFilename, const char *pchData );
+ bool Path_WriteStringToTextFileAtomic( const std::string &strFilename, const char *pchData );
+ 
++// Mozilla: see mozilla.patch for more details
+ /** Returns a file:// url for paths, or an http or https url if that's what was provided */
+-std::string Path_FilePathToUrl( const std::string & sRelativePath, const std::string & sBasePath );
++// std::string Path_FilePathToUrl( const std::string & sRelativePath, const std::string & sBasePath );
+ 
+ /** Strips off file:// off a URL and returns the path. For other kinds of URLs an empty string is returned */
+ std::string Path_UrlToFilePath( const std::string & sFileUrl );
+diff --git a/src/strtools_public.cpp b/src/strtools_public.cpp
+index f9ce0fd5ea799..f52f8e9004982 100644
+--- a/src/strtools_public.cpp
++++ b/src/strtools_public.cpp
+@@ -4,11 +4,12 @@
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <sstream>
+-#include <codecvt>
++// Mozilla: see mozilla.patch for more details
++// #include <codecvt>
+ #include <iostream>
+ #include <functional>
+ #include <locale>
+-#include <codecvt>
++// #include <codecvt>
+ 
+ #if defined( _WIN32 )
+ #include <windows.h>
+@@ -57,40 +58,74 @@ bool StringHasSuffixCaseSensitive( const std::string &sString, const std::string
+ //-----------------------------------------------------------------------------
+ // Purpose:
+ //-----------------------------------------------------------------------------
+-typedef std::codecvt_utf8< wchar_t > convert_type;
++// Mozilla: see mozilla.patch for more details
++//typedef std::codecvt_utf8< wchar_t > convert_type;
+ 
++// Mozilla: see mozilla.patch for more details
++#if defined( _WIN32 )
+ std::string UTF16to8(const wchar_t * in)
+ {
+-	static std::wstring_convert< convert_type, wchar_t > s_converter;  // construction of this can be expensive (or even serialized) depending on locale
+-
+-	try
+-	{
+-		return s_converter.to_bytes( in );
+-	}
+-	catch ( ... )
++	int retLength = ::WideCharToMultiByte(CP_UTF8, 0, in, -1, nullptr, 0, nullptr, nullptr);
++	if (retLength == 0)
+ 	{
+ 		return std::string();
+ 	}
++
++	char* retString = new char[retLength];
++	::WideCharToMultiByte(CP_UTF8, 0, in, -1, retString, retLength, nullptr, nullptr);
++
++	std::string retStringValue(retString);
++
++	delete[] retString;
++
++	return retStringValue;
++
++	// static std::wstring_convert< convert_type, wchar_t > s_converter;  // construction of this can be expensive (or even serialized) depending on locale
++
++	// try
++	// {
++	// 	return s_converter.to_bytes( in );
++	// }
++	// catch ( ... )
++	// {
++	// 	return std::string();
++	// }
+ }
+ 
+ std::string UTF16to8( const std::wstring & in ) { return UTF16to8( in.c_str() ); }
+ 
+-
++// Mozilla: see mozilla.patch for more details
+ std::wstring UTF8to16(const char * in)
+ {
+-	static std::wstring_convert< convert_type, wchar_t > s_converter;  // construction of this can be expensive (or even serialized) depending on locale
+-
+-	try
+-	{
+-		return s_converter.from_bytes( in );
+-	}
+-	catch ( ... )
++	int retLength = ::MultiByteToWideChar(CP_UTF8, 0, in, -1, nullptr, 0);
++	if (retLength == 0)
+ 	{
+ 		return std::wstring();
+ 	}
++
++	wchar_t* retString = new wchar_t[retLength];
++	::MultiByteToWideChar(CP_UTF8, 0, in, -1, retString, retLength);
++
++	std::wstring retStringValue(retString);
++
++	delete[] retString;
++
++	return retStringValue;
++
++	//static std::wstring_convert< convert_type, wchar_t > s_converter;  // construction of this can be expensive (or even serialized) depending on locale
++
++	//try
++	//{
++	//	return s_converter.from_bytes( in );
++	//}
++	//catch ( ... )
++	//{
++	//	return std::wstring();
++	//}
+ }
+ 
+ std::wstring UTF8to16( const std::string & in ) { return UTF8to16( in.c_str() ); }
++#endif
+ 
+ 
+ #if defined( _WIN32 )
+@@ -173,16 +208,17 @@ uint32_t ReturnStdString( const std::string & sValue, char *pchBuffer, uint32_t
+ 
+ 
+ /** Returns a std::string from a uint64_t */
+-std::string Uint64ToString( uint64_t ulValue )
+-{
+-	char buf[ 22 ];
+-#if defined( _WIN32 )
+-	sprintf_s( buf, "%llu", ulValue );
+-#else
+-    snprintf( buf, sizeof( buf ), "%llu", (long long unsigned int ) ulValue );
+-#endif
+-	return buf;
+-}
++// Mozilla: see mozilla.patch for more details
++// std::string Uint64ToString( uint64_t ulValue )
++// {
++// 	char buf[ 22 ];
++// #if defined( _WIN32 )
++// 	sprintf_s( buf, "%llu", ulValue );
++// #else
++//     snprintf( buf, sizeof( buf ), "%llu", (long long unsigned int ) ulValue );
++// #endif
++// 	return buf;
++// }
+ 
+ 
+ /** returns a uint64_t from a string */
+@@ -451,84 +487,85 @@ std::vector<std::string> TokenizeString( const std::string & sString, char cToke
+ 	return vecStrings;
+ }
+ 
++// Mozilla: see mozilla.patch for more details
+ //-----------------------------------------------------------------------------
+ // Purpose: Repairs a should-be-UTF-8 string to a for-sure-is-UTF-8 string, plus return boolean if we subbed in '?' somewhere
+ //-----------------------------------------------------------------------------
+-bool RepairUTF8( const char *pbegin, const char *pend, std::string & sOutputUtf8 )
+-{
+-	typedef std::codecvt_utf8<char32_t> facet_type;
+-	facet_type myfacet;
+-
+-	std::mbstate_t mystate = std::mbstate_t();
+-
+-	sOutputUtf8.clear();
+-	sOutputUtf8.reserve( pend - pbegin );
+-	bool bSqueakyClean = true;
+-
+-	const char *pmid = pbegin;
+-	while ( pmid != pend )
+-	{
+-		bool bHasError = false;
+-		bool bHasValidData = false;
+-
+-		char32_t out = 0xdeadbeef, *pout;
+-		pbegin = pmid;
+-		switch ( myfacet.in( mystate, pbegin, pend, pmid, &out, &out + 1, pout ) )
+-		{
+-		case facet_type::ok:
+-			bHasValidData = true;
+-			break;
+-
+-		case facet_type::noconv:
+-			// unexpected! always converting type
+-			bSqueakyClean = false;
+-			break;
+-
+-		case facet_type::partial:
+-			bHasError = pbegin == pmid;
+-			if ( bHasError )
+-			{
+-				bSqueakyClean = false;
+-			}
+-			else
+-			{
+-				bHasValidData = true;
+-			}
+-			break;
+-
+-		case facet_type::error:
+-			bHasError = true;
+-			bSqueakyClean = false;
+-			break;
+-		}
+-
+-		if ( bHasValidData )
+-		{
+-			// could convert back, but no need
+-			for ( const char *p = pbegin; p != pmid; ++p )
+-			{
+-				sOutputUtf8 += *p;
+-			}
+-		}
+-
+-		if ( bHasError )
+-		{
+-			sOutputUtf8 += '?';
+-		}
+-
+-		if ( pmid == pbegin )
+-		{
+-			pmid++;
+-		}
+-	}
+-
+-	return bSqueakyClean;
+-}
+-
+-//-----------------------------------------------------------------------------
+-// Purpose: Repairs a should-be-UTF-8 string to a for-sure-is-UTF-8 string, plus return boolean if we subbed in '?' somewhere
+-//-----------------------------------------------------------------------------
+-bool RepairUTF8( const std::string & sInputUtf8, std::string & sOutputUtf8 )
+-{
+-	return RepairUTF8( sInputUtf8.data(), sInputUtf8.data() + sInputUtf8.size(), sOutputUtf8 );
+-}
++// bool RepairUTF8( const char *pbegin, const char *pend, std::string & sOutputUtf8 )
++// {
++// 	typedef std::codecvt_utf8<char32_t> facet_type;
++// 	facet_type myfacet;
++
++// 	std::mbstate_t mystate = std::mbstate_t();
++
++// 	sOutputUtf8.clear();
++// 	sOutputUtf8.reserve( pend - pbegin );
++// 	bool bSqueakyClean = true;
++
++// 	const char *pmid = pbegin;
++// 	while ( pmid != pend )
++// 	{
++// 		bool bHasError = false;
++// 		bool bHasValidData = false;
++
++// 		char32_t out = 0xdeadbeef, *pout;
++// 		pbegin = pmid;
++// 		switch ( myfacet.in( mystate, pbegin, pend, pmid, &out, &out + 1, pout ) )
++// 		{
++// 		case facet_type::ok:
++// 			bHasValidData = true;
++// 			break;
++
++// 		case facet_type::noconv:
++// 			// unexpected! always converting type
++// 			bSqueakyClean = false;
++// 			break;
++
++// 		case facet_type::partial:
++// 			bHasError = pbegin == pmid;
++// 			if ( bHasError )
++// 			{
++// 				bSqueakyClean = false;
++// 			}
++// 			else
++// 			{
++// 				bHasValidData = true;
++// 			}
++// 			break;
++
++// 		case facet_type::error:
++// 			bHasError = true;
++// 			bSqueakyClean = false;
++// 			break;
++// 		}
++
++// 		if ( bHasValidData )
++// 		{
++// 			// could convert back, but no need
++// 			for ( const char *p = pbegin; p != pmid; ++p )
++// 			{
++// 				sOutputUtf8 += *p;
++// 			}
++// 		}
++
++// 		if ( bHasError )
++// 		{
++// 			sOutputUtf8 += '?';
++// 		}
++
++// 		if ( pmid == pbegin )
++// 		{
++// 			pmid++;
++// 		}
++// 	}
++
++// 	return bSqueakyClean;
++// }
++
++// //-----------------------------------------------------------------------------
++// // Purpose: Repairs a should-be-UTF-8 string to a for-sure-is-UTF-8 string, plus return boolean if we subbed in '?' somewhere
++// //-----------------------------------------------------------------------------
++// bool RepairUTF8( const std::string & sInputUtf8, std::string & sOutputUtf8 )
++// {
++// 	return RepairUTF8( sInputUtf8.data(), sInputUtf8.data() + sInputUtf8.size(), sOutputUtf8 );
++// }
+diff --git a/src/strtools_public.h b/src/strtools_public.h
+index 349b5b38fd387..067bbe1b1b074 100644
+--- a/src/strtools_public.h
++++ b/src/strtools_public.h
+@@ -14,6 +14,8 @@ bool StringHasPrefixCaseSensitive( const std::string & sString, const std::strin
+ bool StringHasSuffix( const std::string &sString, const std::string &sSuffix );
+ bool StringHasSuffixCaseSensitive( const std::string &sString, const std::string &sSuffix );
+ 
++// Mozilla: see mozilla.patch for more details
++#if defined( _WIN32 )
+ /** converts a UTF-16 string to a UTF-8 string */
+ std::string UTF16to8( const wchar_t * in );
+ std::string UTF16to8( const std::wstring & in );
+@@ -22,6 +24,7 @@ std::string UTF16to8( const std::wstring & in );
+ std::wstring UTF8to16(const char * in);
+ std::wstring UTF8to16( const std::string & in );
+ #define Utf16FromUtf8 UTF8to16
++#endif
+ 
+ #if defined( _WIN32 )
+ std::string DefaultACPtoUTF8( const char *pszStr );
+@@ -69,15 +72,15 @@ inline int strnicmp( const char *pStr1, const char *pStr2, size_t unBufferLen )
+ #if defined( OSX )
+ // behaviors ensure NULL-termination at least as well as _TRUNCATE does, but
+ // wcsncpy_s/strncpy_s can non-NULL-terminate, wcslcpy/strlcpy can not.
+-inline errno_t wcsncpy_s(wchar_t *strDest, size_t numberOfElements, const wchar_t *strSource, size_t count)
+-{
+-	return wcslcpy(strDest, strSource, numberOfElements);
+-}
++// inline errno_t wcsncpy_s(wchar_t *strDest, size_t numberOfElements, const wchar_t *strSource, size_t count)
++// {
++// 	return wcslcpy(strDest, strSource, numberOfElements);
++// }
+ 
+-inline errno_t strncpy_s(char *strDest, size_t numberOfElements, const char *strSource, size_t count)
+-{
+-	return strlcpy(strDest, strSource, numberOfElements);
+-}
++// inline errno_t strncpy_s(char *strDest, size_t numberOfElements, const char *strSource, size_t count)
++// {
++// 	return strlcpy(strDest, strSource, numberOfElements);
++// }
+ 
+ #endif
+ 
+@@ -108,7 +111,8 @@ inline uint64_t strtoull(const char *str, char **endptr, int base) { return _str
+ uint32_t ReturnStdString( const std::string & sValue, char *pchBuffer, uint32_t unBufferLen );
+ 
+ /** Returns a std::string from a uint64_t */
+-std::string Uint64ToString( uint64_t ulValue );
++// Mozilla: see mozilla.patch for more details
++//std::string Uint64ToString( uint64_t ulValue );
+ 
+ /** returns a uint64_t from a string */
+ uint64_t StringToUint64( const std::string & sValue );
+diff --git a/src/vrpathregistry_public.cpp b/src/vrpathregistry_public.cpp
+index 6a7f457bbacf3..f40fc1cda1acd 100644
+--- a/src/vrpathregistry_public.cpp
++++ b/src/vrpathregistry_public.cpp
+@@ -208,7 +208,7 @@ bool CVRPathRegistry_Public::ToJsonString( std::string &sJsonString )
+ 	return true;
+ }
+ 
+-
++// Mozilla: see mozilla.patch for more details
+ // ---------------------------------------------------------------------------
+ // Purpose: Loads the config file from its well known location
+ // ---------------------------------------------------------------------------
+@@ -239,7 +239,8 @@ bool CVRPathRegistry_Public::BLoadFromFile( std::string *psLoadError )
+ 	std::istringstream istream( sRegistryContents );
+ 	std::string sErrors;
+ 
+-	try {
++// try
++	{
+ 		if ( !parseFromStream( builder, istream, &root, &sErrors ) )
+ 		{
+ 			if ( psLoadError )
+@@ -257,14 +258,14 @@ bool CVRPathRegistry_Public::BLoadFromFile( std::string *psLoadError )
+ 			ParseStringListFromJson( &m_vecExternalDrivers, root, "external_drivers" );
+ 		}
+ 	}
+-	catch ( ... )
+-	{
+-		if ( psLoadError )
+-		{
+-			*psLoadError = "Unable to parse " + sRegPath + ": exception thrown in JSON library";
+-		}
+-		return false;
+-	}
++// catch ( ... )
++// {
++// 	if ( psLoadError )
++// 	{
++// 		*psLoadError = "Unable to parse " + sRegPath + ": exception thrown in JSON library";
++// 	}
++// 	return false;
++// }
+ 
+ 	return true;
+ }
diff --git a/gfx/vr/service/openvr/src/README b/gfx/vr/service/openvr/src/README
new file mode 100644
index 0000000000..826c58da79
--- /dev/null
+++ b/gfx/vr/service/openvr/src/README
@@ -0,0 +1,39 @@
+This is the source code for the OpenVR API client binding library which connects
+OpenVR applications to the SteamVR runtime, taking into account the version
+of the OpenVR interface they were compiled against.
+
+The client binding library - openvr_api.dll on Windows, openvr_api.so on
+Linux, and openvr_api.dylib or OpenVR.framework on macOS - knows how to find
+and read the SteamVR runtime installation information which allows it to
+find and dynamically connect to the installed runtime. In combination with the
+interface version identifiers from /include/openvr.h which are baked
+into applications at the time they are built, the OpenVR API client
+binding library captures and conveys to the SteamVR runtime the version
+of the OpenVR API interface behavior that the application expects.
+
+Applications carry with them a private/local copy of the client binding
+library when they ship, and they should install it locally to their
+application.  Applications should not install the client binding library
+globally or attempt to link to a globally installed client binding library.
+Doing so negates at least part of the ability for the client binding library
+to accurately reflect the version of the OpenVR API that the application
+was built against, and so hinders compatibility support in the face of
+API changes.
+
+Most applications should simply link to and redistribute with their application
+the pre-built client binding library found in the /bin directory of this
+repository. Some small number of applications which have specific requirements
+around redistributing only binaries they build themselves should build
+the client library from this source and either statically link it into
+their application or redistribute the binary they build.
+
+This is a cmake project, to build it use the version of cmake appropriate
+for your platform. For example, to build on a POSIX system simply perform
+
+  cd src; mkdir _build; cd _build; cmake ..; make
+
+and you will end up with the static library /src/bin/<arch>/libopenvr_api.a
+
+To build a shared library, pass -DBUILD_SHARED=1 to cmake.
+To build as a framework on apple platforms, pass -DBUILD_FRAMEWORK=1 to cmake.
+To see a complete list of configurable build options, use `cmake -LAH`
diff --git a/gfx/vr/service/openvr/src/dirtools_public.cpp b/gfx/vr/service/openvr/src/dirtools_public.cpp
new file mode 100644
index 0000000000..e5cfc02e0c
--- /dev/null
+++ b/gfx/vr/service/openvr/src/dirtools_public.cpp
@@ -0,0 +1,101 @@
+//========= Copyright Valve Corporation ============//
+#include "dirtools_public.h"
+#include "strtools_public.h"
+#include "pathtools_public.h"
+
+#include <errno.h>
+#include <string.h>
+
+#ifdef _WIN32
+#include "windows.h"
+#else
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
+#if defined( OSX )
+#include <sys/syslimits.h>
+#endif
+
+
+//-----------------------------------------------------------------------------
+// Purpose: utility function to create dirs & subdirs
+//-----------------------------------------------------------------------------
+bool BCreateDirectoryRecursive( const char *pchPath )
+{
+	// Does it already exist?
+	if ( Path_IsDirectory( pchPath ) )
+		return true;
+
+	// copy the path into something we can munge
+	int len = (int)strlen( pchPath );
+	char *path = (char *)malloc( len + 1 );
+	strcpy( path, pchPath );
+
+	// Walk backwards to first non-existing dir that we find
+	char *s = path + len - 1;
+
+	const char slash = Path_GetSlash();
+	while ( s > path )
+	{
+		if ( *s == slash )
+		{
+			*s = '\0';
+			bool bExists = Path_IsDirectory( path );
+			*s = slash;
+
+			if ( bExists )
+			{
+				++s;
+				break;
+			}
+		}
+		--s;
+	}
+
+	// and then move forwards from there
+
+	while ( *s )
+	{
+		if ( *s == slash )
+		{
+			*s = '\0';
+			BCreateDirectory( path );
+			*s = slash;
+		}
+		s++;
+	}
+
+	bool bRetVal = BCreateDirectory( path );
+	free( path );
+	return bRetVal;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Creates the directory, returning true if it is created, or if it already existed
+//-----------------------------------------------------------------------------
+bool BCreateDirectory( const char *pchPath )
+{
+#ifdef WIN32
+	std::wstring wPath = UTF8to16( pchPath );
+	if ( ::CreateDirectoryW( wPath.c_str(), NULL ) )
+		return true;
+
+	if ( ::GetLastError() == ERROR_ALREADY_EXISTS )
+		return true;
+
+	return false;
+#else
+	int i = mkdir( pchPath, S_IRWXU | S_IRWXG | S_IRWXO );
+	if ( i == 0 )
+		return true;
+	if ( errno == EEXIST )
+		return true;
+
+	return false;
+#endif
+}
+
diff --git a/gfx/vr/service/openvr/src/dirtools_public.h b/gfx/vr/service/openvr/src/dirtools_public.h
new file mode 100644
index 0000000000..b048b41b78
--- /dev/null
+++ b/gfx/vr/service/openvr/src/dirtools_public.h
@@ -0,0 +1,17 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+#include <stdint.h>
+#include <string>
+
+
+#if !defined(_WIN32)
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+
+
+extern bool BCreateDirectoryRecursive( const char *pchPath );
+extern bool BCreateDirectory( const char *pchPath );
+
+
diff --git a/gfx/vr/service/openvr/src/envvartools_public.cpp b/gfx/vr/service/openvr/src/envvartools_public.cpp
new file mode 100644
index 0000000000..4fb4817927
--- /dev/null
+++ b/gfx/vr/service/openvr/src/envvartools_public.cpp
@@ -0,0 +1,88 @@
+//========= Copyright Valve Corporation ============//
+#include "envvartools_public.h"
+#include "strtools_public.h"
+#include <stdlib.h>
+#include <string>
+#include <cctype>
+
+#if defined(_WIN32)
+#include <windows.h>
+
+#undef GetEnvironmentVariable
+#undef SetEnvironmentVariable
+#endif
+
+
+std::string GetEnvironmentVariable( const char *pchVarName )
+{
+#if defined(_WIN32)
+	char rchValue[32767]; // max size for an env var on Windows
+	DWORD cChars = GetEnvironmentVariableA( pchVarName, rchValue, sizeof( rchValue ) );
+	if( cChars == 0 )
+		return "";
+	else
+		return rchValue;
+#elif defined(POSIX)
+	char *pchValue = getenv( pchVarName );
+	if( pchValue )
+		return pchValue;
+	else
+		return "";
+#else
+#error "Unsupported Platform"
+#endif
+}
+
+bool GetEnvironmentVariableAsBool( const char *pchVarName, bool bDefault )
+{
+	std::string sValue = GetEnvironmentVariable( pchVarName );
+
+	if ( sValue.empty() )
+	{
+		return bDefault;
+	}
+
+	sValue = StringToLower( sValue );
+	std::string sYesValues[] = { "y", "yes", "true" };
+	std::string sNoValues[] = { "n", "no", "false" };
+
+	for ( std::string &sMatch : sYesValues )
+	{
+		if ( sMatch == sValue )
+		{
+			return true;
+		}
+	}
+
+	for ( std::string &sMatch : sNoValues )
+	{
+		if ( sMatch == sValue )
+		{
+			return false;
+		}
+	}
+
+	if ( std::isdigit( sValue.at(0) ) )
+	{
+		return atoi( sValue.c_str() ) != 0;
+	}
+
+	fprintf( stderr,
+			 "GetEnvironmentVariableAsBool(%s): Unable to parse value '%s', using default %d\n",
+			 pchVarName, sValue.c_str(), bDefault );
+	return bDefault;
+}
+
+bool SetEnvironmentVariable( const char *pchVarName, const char *pchVarValue )
+{
+#if defined(_WIN32)
+	return 0 != SetEnvironmentVariableA( pchVarName, pchVarValue );
+#elif defined(POSIX)
+	if( pchVarValue == NULL )
+		return 0 == unsetenv( pchVarName );
+	else
+		return 0 == setenv( pchVarName, pchVarValue, 1 );
+#else
+#error "Unsupported Platform"
+#endif
+}
diff --git a/gfx/vr/service/openvr/src/envvartools_public.h b/gfx/vr/service/openvr/src/envvartools_public.h
new file mode 100644
index 0000000000..7cd4c208e6
--- /dev/null
+++ b/gfx/vr/service/openvr/src/envvartools_public.h
@@ -0,0 +1,8 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+#include <string>
+
+std::string GetEnvironmentVariable( const char *pchVarName );
+bool GetEnvironmentVariableAsBool( const char *pchVarName, bool bDefault );
+bool SetEnvironmentVariable( const char *pchVarName, const char *pchVarValue );
diff --git a/gfx/vr/service/openvr/src/hmderrors_public.cpp b/gfx/vr/service/openvr/src/hmderrors_public.cpp
new file mode 100644
index 0000000000..e02c370cb1
--- /dev/null
+++ b/gfx/vr/service/openvr/src/hmderrors_public.cpp
@@ -0,0 +1,326 @@
+//========= Copyright Valve Corporation ============//
+#include "openvr.h"
+#include "hmderrors_public.h"
+#include <stdio.h>
+#include <algorithm>
+
+using namespace vr;
+
+#define RETURN_ENUM_AS_STRING(enumValue) case enumValue: return #enumValue;
+
+
+const char *GetEnglishStringForHmdError( vr::EVRInitError eError )
+{
+	switch( eError )
+	{
+	case VRInitError_None:								return "No Error (0)";
+
+	case VRInitError_Init_InstallationNotFound:			return "Installation Not Found (100)";
+	case VRInitError_Init_InstallationCorrupt:			return "Installation Corrupt (101)";
+	case VRInitError_Init_VRClientDLLNotFound:			return "vrclient Shared Lib Not Found (102)";
+	case VRInitError_Init_FileNotFound:					return "File Not Found (103)";
+	case VRInitError_Init_FactoryNotFound:				return "Factory Function Not Found (104)";
+	case VRInitError_Init_InterfaceNotFound:			return "Interface Not Found (105)";
+	case VRInitError_Init_InvalidInterface:				return "Invalid Interface (106)";
+	case VRInitError_Init_UserConfigDirectoryInvalid:	return "User Config Directory Invalid (107)";
+	case VRInitError_Init_HmdNotFound:					return "Hmd Not Found (108)";
+	case VRInitError_Init_NotInitialized:				return "Not Initialized (109)";
+	case VRInitError_Init_PathRegistryNotFound:			return "Installation path could not be located (110)";
+	case VRInitError_Init_NoConfigPath:					return "Config path could not be located (111)";
+	case VRInitError_Init_NoLogPath:					return "Log path could not be located (112)";
+	case VRInitError_Init_PathRegistryNotWritable:		return "Unable to write path registry (113)";
+	case VRInitError_Init_AppInfoInitFailed:			return "App info manager init failed (114)";
+	case VRInitError_Init_Retry:						return "Internal Retry (115)";
+	case VRInitError_Init_InitCanceledByUser:			return "User Canceled Init (116)";
+	case VRInitError_Init_AnotherAppLaunching:			return "Another app was already launching (117)";
+	case VRInitError_Init_SettingsInitFailed:			return "Settings manager init failed (118)";
+	case VRInitError_Init_ShuttingDown:					return "VR system shutting down (119)";
+	case VRInitError_Init_TooManyObjects:				return "Too many tracked objects (120)";
+	case VRInitError_Init_NoServerForBackgroundApp:		return "Not starting vrserver for background app (121)";
+	case VRInitError_Init_NotSupportedWithCompositor:	return "The requested interface is incompatible with the compositor and the compositor is running (122)";
+	case VRInitError_Init_NotAvailableToUtilityApps:	return "This interface is not available to utility applications (123)";
+	case VRInitError_Init_Internal:						return "vrserver internal error (124)";
+	case VRInitError_Init_HmdDriverIdIsNone:			return "Hmd DriverId is invalid (125)";
+	case VRInitError_Init_HmdNotFoundPresenceFailed:	return "Hmd Not Found Presence Failed (126)";
+	case VRInitError_Init_VRMonitorNotFound:			return "VR Monitor Not Found (127)";
+	case VRInitError_Init_VRMonitorStartupFailed:		return "VR Monitor startup failed (128)";
+	case VRInitError_Init_LowPowerWatchdogNotSupported: return "Low Power Watchdog Not Supported (129)";
+	case VRInitError_Init_InvalidApplicationType:		return "Invalid Application Type (130)";
+	case VRInitError_Init_NotAvailableToWatchdogApps:	return "Not available to watchdog apps (131)";
+	case VRInitError_Init_WatchdogDisabledInSettings:	return "Watchdog disabled in settings (132)";
+	case VRInitError_Init_VRDashboardNotFound:			return "VR Dashboard Not Found (133)";
+	case VRInitError_Init_VRDashboardStartupFailed:		return "VR Dashboard startup failed (134)";
+	case VRInitError_Init_VRHomeNotFound:				return "VR Home Not Found (135)";
+	case VRInitError_Init_VRHomeStartupFailed:			return "VR home startup failed (136)";
+	case VRInitError_Init_RebootingBusy:				return "Rebooting In Progress (137)";
+	case VRInitError_Init_FirmwareUpdateBusy:			return "Firmware Update In Progress (138)";
+	case VRInitError_Init_FirmwareRecoveryBusy:			return "Firmware Recovery In Progress (139)";
+	case VRInitError_Init_USBServiceBusy:				return "USB Service Busy (140)";
+
+	case VRInitError_Driver_Failed:							return "Driver Failed (200)";
+	case VRInitError_Driver_Unknown:						return "Driver Not Known (201)";
+	case VRInitError_Driver_HmdUnknown:						return "HMD Not Known (202)";
+	case VRInitError_Driver_NotLoaded:						return "Driver Not Loaded (203)";
+	case VRInitError_Driver_RuntimeOutOfDate:				return "Driver runtime is out of date (204)";
+	case VRInitError_Driver_HmdInUse:						return "HMD already in use by another application (205)";
+	case VRInitError_Driver_NotCalibrated:					return "Device is not calibrated (206)";
+	case VRInitError_Driver_CalibrationInvalid:				return "Device Calibration is invalid (207)";
+	case VRInitError_Driver_HmdDisplayNotFound:				return "HMD detected over USB, but Monitor not found (208)";
+	case VRInitError_Driver_TrackedDeviceInterfaceUnknown:	return "Driver Tracked Device Interface unknown (209)";
+	// case VRInitError_Driver_HmdDisplayNotFoundAfterFix:	return "HMD detected over USB, but Monitor not found after attempt to fix (210)"; // taken out upon Ben's request: He thinks that there is no need to separate that error from 208
+	case VRInitError_Driver_HmdDriverIdOutOfBounds:			return "Hmd DriverId is our of bounds (211)";
+	case VRInitError_Driver_HmdDisplayMirrored:				return "HMD detected over USB, but Monitor may be mirrored instead of extended (212)";
+	case VRInitError_Driver_HmdDisplayNotFoundLaptop:		return "On laptop, HMD detected over USB, but Monitor not found (213)";
+
+	case VRInitError_IPC_ServerInitFailed:						return "VR Server Init Failed (300)";
+	case VRInitError_IPC_ConnectFailed:							return "Connect to VR Server Failed (301)";
+	case VRInitError_IPC_SharedStateInitFailed:					return "Shared IPC State Init Failed (302)";
+	case VRInitError_IPC_CompositorInitFailed:					return "Shared IPC Compositor Init Failed (303)";
+	case VRInitError_IPC_MutexInitFailed:						return "Shared IPC Mutex Init Failed (304)";
+	case VRInitError_IPC_Failed:								return "Shared IPC Failed (305)";
+	case VRInitError_IPC_CompositorConnectFailed:				return "Shared IPC Compositor Connect Failed (306)";
+	case VRInitError_IPC_CompositorInvalidConnectResponse:		return "Shared IPC Compositor Invalid Connect Response (307)";
+	case VRInitError_IPC_ConnectFailedAfterMultipleAttempts:	return "Shared IPC Connect Failed After Multiple Attempts (308)";
+	case VRInitError_IPC_ConnectFailedAfterTargetExited:		return "Shared IPC Connect Failed After Target Exited (309)";
+	case VRInitError_IPC_NamespaceUnavailable:					return "Shared IPC Namespace Unavailable (310)";
+
+	case VRInitError_Compositor_Failed:					return "Compositor failed to initialize (400)";
+	case VRInitError_Compositor_D3D11HardwareRequired:	return "Compositor failed to find DX11 hardware (401)";
+	case VRInitError_Compositor_FirmwareRequiresUpdate:	return "Compositor requires mandatory firmware update (402)";
+	case VRInitError_Compositor_OverlayInitFailed:		return "Compositor initialization succeeded, but overlay init failed (403)";
+	case VRInitError_Compositor_ScreenshotsInitFailed:	return "Compositor initialization succeeded, but screenshot init failed (404)";
+	case VRInitError_Compositor_UnableToCreateDevice:	return "Compositor unable to create graphics device (405)";
+
+	// Oculus
+	case VRInitError_VendorSpecific_UnableToConnectToOculusRuntime:	return "Unable to connect to Oculus Runtime (1000)";
+	case VRInitError_VendorSpecific_OculusRuntimeBadInstall:		return "Unable to connect to Oculus Runtime, possible bad install (1114)";
+
+	// Lighthouse
+	case VRInitError_VendorSpecific_HmdFound_CantOpenDevice:				return "HMD found, but can not open device (1101)";
+	case VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart:	return "HMD found, but unable to request config (1102)";
+	case VRInitError_VendorSpecific_HmdFound_NoStoredConfig:				return "HMD found, but no stored config (1103)";
+	case VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck:       return "HMD found, but failed configuration check (1113)";
+	case VRInitError_VendorSpecific_HmdFound_ConfigTooBig:					return "HMD found, but config too big (1104)";
+	case VRInitError_VendorSpecific_HmdFound_ConfigTooSmall:				return "HMD found, but config too small (1105)";
+	case VRInitError_VendorSpecific_HmdFound_UnableToInitZLib:				return "HMD found, but unable to init ZLib (1106)";
+	case VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion:		return "HMD found, but problems with the data (1107)";
+	case VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart:		return "HMD found, but problems with the data (1108)";
+	case VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart:		return "HMD found, but problems with the data (1109)";
+	case VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext:		return "HMD found, but problems with the data (1110)";
+	case VRInitError_VendorSpecific_HmdFound_UserDataAddressRange:			return "HMD found, but problems with the data (1111)";
+	case VRInitError_VendorSpecific_HmdFound_UserDataError:					return "HMD found, but problems with the data (1112)";
+
+	case VRInitError_Steam_SteamInstallationNotFound: return "Unable to find Steam installation (2000)";
+
+	default:
+		return GetIDForVRInitError( eError );
+	}
+
+}
+
+
+const char *GetIDForVRInitError( vr::EVRInitError eError )
+{
+	switch( eError )
+	{
+		RETURN_ENUM_AS_STRING( VRInitError_None );
+		RETURN_ENUM_AS_STRING( VRInitError_Unknown );
+
+		RETURN_ENUM_AS_STRING( VRInitError_Init_InstallationNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_InstallationCorrupt );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_VRClientDLLNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_FileNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_FactoryNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_InterfaceNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_InvalidInterface );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_UserConfigDirectoryInvalid );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_HmdNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_NotInitialized );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_PathRegistryNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_NoConfigPath );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_NoLogPath );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_PathRegistryNotWritable );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_AppInfoInitFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_Retry );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_InitCanceledByUser );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_AnotherAppLaunching );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_SettingsInitFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_ShuttingDown );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_TooManyObjects );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_NoServerForBackgroundApp );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_NotSupportedWithCompositor );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_NotAvailableToUtilityApps );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_Internal );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_HmdDriverIdIsNone );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_HmdNotFoundPresenceFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_VRMonitorNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_VRMonitorStartupFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_LowPowerWatchdogNotSupported );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_InvalidApplicationType );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_NotAvailableToWatchdogApps );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_WatchdogDisabledInSettings );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_VRDashboardNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_VRDashboardStartupFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_VRHomeNotFound );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_VRHomeStartupFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_RebootingBusy );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_FirmwareUpdateBusy );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_FirmwareRecoveryBusy );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_USBServiceBusy );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_VRWebHelperStartupFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_TrackerManagerInitFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_AlreadyRunning );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_FailedForVrMonitor);
+		RETURN_ENUM_AS_STRING( VRInitError_Init_PropertyManagerInitFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Init_WebServerFailed );
+		
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_Failed );
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_Unknown );
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdUnknown);
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_NotLoaded);
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_RuntimeOutOfDate);
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdInUse);
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_NotCalibrated);
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_CalibrationInvalid);
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDisplayNotFound);
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_TrackedDeviceInterfaceUnknown );
+		// RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDisplayNotFoundAfterFix );
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDriverIdOutOfBounds );
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDisplayMirrored );
+		RETURN_ENUM_AS_STRING( VRInitError_Driver_HmdDisplayNotFoundLaptop );
+
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_ServerInitFailed);
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_ConnectFailed);
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_SharedStateInitFailed);
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_CompositorInitFailed);
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_MutexInitFailed);
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_Failed);
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_CompositorConnectFailed);
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_CompositorInvalidConnectResponse);
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_ConnectFailedAfterMultipleAttempts );
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_ConnectFailedAfterTargetExited );
+		RETURN_ENUM_AS_STRING( VRInitError_IPC_NamespaceUnavailable );
+
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_Failed );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_D3D11HardwareRequired );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FirmwareRequiresUpdate );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_OverlayInitFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_ScreenshotsInitFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_UnableToCreateDevice );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_SharedStateIsNull );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_NotificationManagerIsNull );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_ResourceManagerClientIsNull );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_MessageOverlaySharedStateInitFailure );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_PropertiesInterfaceIsNull );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateFullscreenWindowFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_SettingsInterfaceIsNull );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToShowWindow );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_DistortInterfaceIsNull );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_DisplayFrequencyFailure );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_RendererInitializationFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_DXGIFactoryInterfaceIsNull );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_DXGIFactoryCreateFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_DXGIFactoryQueryFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_InvalidAdapterDesktop );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_InvalidHmdAttachment );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_InvalidOutputDesktop );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_InvalidDeviceProvided );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_D3D11RendererInitializationFailed );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToFindDisplayMode );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToCreateSwapChain );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToGetBackBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToCreateRenderTarget );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToCreateDXGI2SwapChain );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedtoGetDXGI2BackBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToCreateDXGI2RenderTarget );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToGetDXGIDeviceInterface );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_SelectDisplayMode );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToCreateNvAPIRenderTargets );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_NvAPISetDisplayMode );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToCreateDirectModeDisplay );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_InvalidHmdPropertyContainer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_UpdateDisplayFrequency );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateRasterizerState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateWireframeRasterizerState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateSamplerState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateClampToBorderSamplerState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateAnisoSamplerState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateOverlaySamplerState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreatePanoramaSamplerState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateFontSamplerState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateNoBlendState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateBlendState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateAlphaBlendState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateBlendStateMaskR );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateBlendStateMaskG );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateBlendStateMaskB );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateDepthStencilState );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateDepthStencilStateNoWrite );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateDepthStencilStateNoDepth );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateFlushTexture );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateDistortionSurfaces );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateHmdPoseConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateOverlayConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateGeomConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreatePanelMaskConstantBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreatePixelSimUBO );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateMSAARenderTextures );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateResolveRenderTextures );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateComputeResolveRenderTextures );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateDriverDirectModeResolveTextures );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_OpenDriverDirectModeResolveTextures );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateFallbackSyncTexture );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_ShareFallbackSyncTexture );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateOverlayIndexBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateOverlayVertexBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateTextVertexBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateTextIndexBuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateMirrorTextures );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateLastFrameRenderTexture );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateMirrorOverlay );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_DisplayModeNotSupported );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateOverlayInvalidCall );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_CreateOverlayAlreadyInitialized );
+		RETURN_ENUM_AS_STRING( VRInitError_Compositor_FailedToCreateMailbox );
+
+		// Vendor-specific errors
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_UnableToConnectToOculusRuntime);
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_WindowsNotInDevMode );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_OculusRuntimeBadInstall );
+
+		// Lighthouse
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_CantOpenDevice);
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart);
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_NoStoredConfig);
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_ConfigTooBig );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_ConfigTooSmall );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToInitZLib );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UserDataAddressRange );
+		RETURN_ENUM_AS_STRING( VRInitError_VendorSpecific_HmdFound_UserDataError );
+
+		RETURN_ENUM_AS_STRING( VRInitError_Steam_SteamInstallationNotFound );
+
+	default:
+		{
+			static char buf[128];
+			sprintf( buf, "Unknown error (%d)", eError );
+			return buf;
+		}
+	}
+}
+
diff --git a/gfx/vr/service/openvr/src/hmderrors_public.h b/gfx/vr/service/openvr/src/hmderrors_public.h
new file mode 100644
index 0000000000..ccd6c8a96c
--- /dev/null
+++ b/gfx/vr/service/openvr/src/hmderrors_public.h
@@ -0,0 +1,6 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+const char *GetEnglishStringForHmdError( vr::EVRInitError eError );
+const char *GetIDForVRInitError( vr::EVRInitError eError );
+
diff --git a/gfx/vr/service/openvr/src/ivrclientcore.h b/gfx/vr/service/openvr/src/ivrclientcore.h
new file mode 100644
index 0000000000..6884e7fbc8
--- /dev/null
+++ b/gfx/vr/service/openvr/src/ivrclientcore.h
@@ -0,0 +1,35 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+namespace vr
+{
+
+class IVRClientCore
+{
+public:
+	/** Initializes the system */
+	virtual EVRInitError Init( vr::EVRApplicationType eApplicationType, const char *pStartupInfo ) = 0;
+
+	/** cleans up everything in vrclient.dll and prepares the DLL to be unloaded */
+	virtual void Cleanup() = 0;
+
+	/** checks to see if the specified interface/version is supported in this vrclient.dll */
+	virtual EVRInitError IsInterfaceVersionValid( const char *pchInterfaceVersion ) = 0;
+
+	/** Retrieves any interface from vrclient.dll */
+	virtual void *GetGenericInterface( const char *pchNameAndVersion, EVRInitError *peError ) = 0;
+
+	/** Returns true if any driver has an HMD attached. Can be called outside of Init/Cleanup */
+	virtual bool BIsHmdPresent() = 0;
+
+	/** Returns an English error string from inside vrclient.dll which might be newer than the API DLL */
+	virtual const char *GetEnglishStringForHmdError( vr::EVRInitError eError ) = 0;
+
+	/** Returns an error symbol from inside vrclient.dll which might be newer than the API DLL */
+	virtual const char *GetIDForVRInitError( vr::EVRInitError eError ) = 0;
+};
+
+static const char * const IVRClientCore_Version = "IVRClientCore_003";
+
+
+}
diff --git a/gfx/vr/service/openvr/src/openvr_api_public.cpp b/gfx/vr/service/openvr/src/openvr_api_public.cpp
new file mode 100644
index 0000000000..54aa555955
--- /dev/null
+++ b/gfx/vr/service/openvr/src/openvr_api_public.cpp
@@ -0,0 +1,352 @@
+//========= Copyright Valve Corporation ============//
+#define VR_API_EXPORT 1
+#include "openvr.h"
+#include "ivrclientcore.h"
+#include "pathtools_public.h"
+#include "sharedlibtools_public.h"
+#include "envvartools_public.h"
+#include "hmderrors_public.h"
+#include "strtools_public.h"
+#include "vrpathregistry_public.h"
+#include <mutex>
+
+using vr::EVRInitError;
+using vr::IVRSystem;
+using vr::IVRClientCore;
+using vr::VRInitError_None;
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#if !defined(OPENVR_BUILD_STATIC)
+#define VR_EXPORT_INTERFACE extern "C" __declspec( dllexport )
+#else
+#define VR_EXPORT_INTERFACE extern "C"
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#define VR_EXPORT_INTERFACE extern "C" __attribute__((visibility("default")))
+
+#else
+#error "Unsupported Platform."
+#endif
+
+namespace vr
+{
+
+static void *g_pVRModule = NULL;
+static IVRClientCore *g_pHmdSystem = NULL;
+static std::recursive_mutex g_mutexSystem;
+
+
+typedef void* (*VRClientCoreFactoryFn)(const char *pInterfaceName, int *pReturnCode);
+
+static uint32_t g_nVRToken = 0;
+
+uint32_t VR_GetInitToken()
+{
+	return g_nVRToken;
+}
+
+EVRInitError VR_LoadHmdSystemInternal();
+void CleanupInternalInterfaces();
+
+
+uint32_t VR_InitInternal2( EVRInitError *peError, vr::EVRApplicationType eApplicationType, const char *pStartupInfo )
+{
+	std::lock_guard<std::recursive_mutex> lock( g_mutexSystem );
+
+	EVRInitError err = VR_LoadHmdSystemInternal();
+	if ( err == vr::VRInitError_None )
+	{
+		err = g_pHmdSystem->Init( eApplicationType, pStartupInfo );
+	}
+
+	if ( peError )
+		*peError = err;
+
+	if ( err != VRInitError_None )
+	{
+		SharedLib_Unload( g_pVRModule );
+		g_pHmdSystem = NULL;
+		g_pVRModule = NULL;
+
+		return 0;
+	}
+
+	return ++g_nVRToken;
+}
+
+VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal( EVRInitError *peError, EVRApplicationType eApplicationType );
+
+uint32_t VR_InitInternal( EVRInitError *peError, vr::EVRApplicationType eApplicationType )
+{
+	return VR_InitInternal2( peError, eApplicationType, nullptr );
+}
+
+void VR_ShutdownInternal()
+{
+	std::lock_guard<std::recursive_mutex> lock( g_mutexSystem );
+	
+	if ( g_pHmdSystem )
+	{
+		g_pHmdSystem->Cleanup();
+		g_pHmdSystem = NULL;
+	}
+	if ( g_pVRModule )
+	{
+		SharedLib_Unload( g_pVRModule );
+		g_pVRModule = NULL;
+	}
+
+#if !defined( VR_API_PUBLIC )
+	CleanupInternalInterfaces();
+#endif
+
+	++g_nVRToken;
+}
+
+EVRInitError VR_LoadHmdSystemInternal()
+{
+	std::string sRuntimePath, sConfigPath, sLogPath;
+
+	bool bReadPathRegistry = CVRPathRegistry_Public::GetPaths( &sRuntimePath, &sConfigPath, &sLogPath, NULL, NULL );
+	if( !bReadPathRegistry )
+	{
+		return vr::VRInitError_Init_PathRegistryNotFound;
+	}
+
+	// figure out where we're going to look for vrclient.dll
+	// see if the specified path actually exists.
+	if( !Path_IsDirectory( sRuntimePath ) )
+	{
+		return vr::VRInitError_Init_InstallationNotFound;
+	}
+
+	// Because we don't have a way to select debug vs. release yet we'll just
+	// use debug if it's there
+#if defined( LINUX64 ) || defined( LINUXARM64 )
+	std::string sTestPath = Path_Join( sRuntimePath, "bin", PLATSUBDIR );
+#else
+	std::string sTestPath = Path_Join( sRuntimePath, "bin" );
+#endif
+	if( !Path_IsDirectory( sTestPath ) )
+	{
+		return vr::VRInitError_Init_InstallationCorrupt;
+	}
+
+#if defined( WIN64 )
+	std::string sDLLPath = Path_Join( sTestPath, "vrclient_x64" DYNAMIC_LIB_EXT );
+#else
+	std::string sDLLPath = Path_Join( sTestPath, "vrclient" DYNAMIC_LIB_EXT );
+#endif
+
+	// only look in the override
+	void *pMod = SharedLib_Load( sDLLPath.c_str() );
+	// nothing more to do if we can't load the DLL
+	if( !pMod )
+	{
+		return vr::VRInitError_Init_VRClientDLLNotFound;
+	}
+
+	VRClientCoreFactoryFn fnFactory = ( VRClientCoreFactoryFn )( SharedLib_GetFunction( pMod, "VRClientCoreFactory" ) );
+	if( !fnFactory )
+	{
+		SharedLib_Unload( pMod );
+		return vr::VRInitError_Init_FactoryNotFound;
+	}
+
+	int nReturnCode = 0;
+	g_pHmdSystem = static_cast< IVRClientCore * > ( fnFactory( vr::IVRClientCore_Version, &nReturnCode ) );
+	if( !g_pHmdSystem )
+	{
+		SharedLib_Unload( pMod );
+		return vr::VRInitError_Init_InterfaceNotFound;
+	}
+
+	g_pVRModule = pMod;
+	return VRInitError_None;
+}
+
+
+void *VR_GetGenericInterface(const char *pchInterfaceVersion, EVRInitError *peError)
+{
+	std::lock_guard<std::recursive_mutex> lock( g_mutexSystem );
+
+	if (!g_pHmdSystem)
+	{
+		if (peError)
+			*peError = vr::VRInitError_Init_NotInitialized;
+		return NULL;
+	}
+
+	return g_pHmdSystem->GetGenericInterface(pchInterfaceVersion, peError);
+}
+
+bool VR_IsInterfaceVersionValid(const char *pchInterfaceVersion)
+{
+	std::lock_guard<std::recursive_mutex> lock( g_mutexSystem );
+
+	if (!g_pHmdSystem)
+	{
+		return false;
+	}
+
+	return g_pHmdSystem->IsInterfaceVersionValid(pchInterfaceVersion) == VRInitError_None;
+}
+
+bool VR_IsHmdPresent()
+{
+	std::lock_guard<std::recursive_mutex> lock( g_mutexSystem );
+
+	if( g_pHmdSystem )
+	{
+		// if we're already initialized, just call through
+		return g_pHmdSystem->BIsHmdPresent();
+	}
+	else
+	{
+		// otherwise we need to do a bit more work
+		EVRInitError err = VR_LoadHmdSystemInternal();
+		if( err != VRInitError_None )
+			return false;
+
+		bool bHasHmd = g_pHmdSystem->BIsHmdPresent();
+
+		g_pHmdSystem = NULL;
+		SharedLib_Unload( g_pVRModule );
+		g_pVRModule = NULL;
+
+		return bHasHmd;
+	}
+}
+
+/** Returns true if the OpenVR runtime is installed. */
+bool VR_IsRuntimeInstalled()
+{
+	std::lock_guard<std::recursive_mutex> lock( g_mutexSystem );
+
+	if( g_pHmdSystem )
+	{
+		// if we're already initialized, OpenVR is obviously installed
+		return true;
+	}
+	else
+	{
+		// otherwise we need to do a bit more work
+		std::string sRuntimePath, sConfigPath, sLogPath;
+
+		bool bReadPathRegistry = CVRPathRegistry_Public::GetPaths( &sRuntimePath, &sConfigPath, &sLogPath, NULL, NULL );
+		if( !bReadPathRegistry )
+		{
+			return false;
+		}
+
+		// figure out where we're going to look for vrclient.dll
+		// see if the specified path actually exists.
+		if( !Path_IsDirectory( sRuntimePath ) )
+		{
+			return false;
+		}
+
+		// the installation may be corrupt in some way, but it certainly looks installed
+		return true;
+	}
+}
+
+
+// -------------------------------------------------------------------------------
+// Purpose: This is the old Runtime Path interface that is no longer exported in the
+//			latest header. We still want to export it from the DLL, though, so updating
+//			to a new DLL doesn't break old compiled code. This version was not thread 
+//			safe and could change the buffer pointer to by a previous result on a 
+//			subsequent call
+// -------------------------------------------------------------------------------
+VR_EXPORT_INTERFACE const char *VR_CALLTYPE VR_RuntimePath();
+
+/** Returns where OpenVR runtime is installed. */
+const char *VR_RuntimePath()
+{
+	static char rchBuffer[1024];
+	uint32_t unRequiredSize;
+	if ( VR_GetRuntimePath( rchBuffer, sizeof( rchBuffer ), &unRequiredSize ) && unRequiredSize < sizeof( rchBuffer ) )
+	{
+		return rchBuffer;
+	}
+	else
+	{
+		return nullptr;
+	}
+}
+
+
+/** Returns where OpenVR runtime is installed. */
+bool VR_GetRuntimePath( char *pchPathBuffer, uint32_t unBufferSize, uint32_t *punRequiredBufferSize )
+{
+	// otherwise we need to do a bit more work
+	std::string sRuntimePath;
+
+	*punRequiredBufferSize = 0;
+
+	bool bReadPathRegistry = CVRPathRegistry_Public::GetPaths( &sRuntimePath, nullptr, nullptr, nullptr, nullptr );
+	if ( !bReadPathRegistry )
+	{
+		return false;
+	}
+
+	// figure out where we're going to look for vrclient.dll
+	// see if the specified path actually exists.
+	if ( !Path_IsDirectory( sRuntimePath ) )
+	{
+		return false;
+	}
+
+	*punRequiredBufferSize = (uint32_t)sRuntimePath.size() + 1;
+	if ( sRuntimePath.size() >= unBufferSize )
+	{
+		*pchPathBuffer = '\0';
+	}
+	else
+	{
+		strcpy_safe( pchPathBuffer, unBufferSize, sRuntimePath.c_str() );
+	}
+
+	return true;
+}
+
+
+/** Returns the symbol version of an HMD error. */
+const char *VR_GetVRInitErrorAsSymbol( EVRInitError error )
+{
+	std::lock_guard<std::recursive_mutex> lock( g_mutexSystem );
+
+	if( g_pHmdSystem )
+		return g_pHmdSystem->GetIDForVRInitError( error );
+	else
+		return GetIDForVRInitError( error );
+}
+
+
+/** Returns the english string version of an HMD error. */
+const char *VR_GetVRInitErrorAsEnglishDescription( EVRInitError error )
+{
+	std::lock_guard<std::recursive_mutex> lock( g_mutexSystem );
+
+	if ( g_pHmdSystem )
+		return g_pHmdSystem->GetEnglishStringForHmdError( error );
+	else
+		return GetEnglishStringForHmdError( error );
+}
+
+
+VR_INTERFACE const char *VR_CALLTYPE VR_GetStringForHmdError( vr::EVRInitError error );
+
+/** Returns the english string version of an HMD error. */
+const char *VR_GetStringForHmdError( EVRInitError error )
+{
+	return VR_GetVRInitErrorAsEnglishDescription( error );
+}
+
+}
+
diff --git a/gfx/vr/service/openvr/src/pathtools_public.cpp b/gfx/vr/service/openvr/src/pathtools_public.cpp
new file mode 100644
index 0000000000..2f401fa501
--- /dev/null
+++ b/gfx/vr/service/openvr/src/pathtools_public.cpp
@@ -0,0 +1,901 @@
+//========= Copyright Valve Corporation ============//
+#include "strtools_public.h"
+#include "pathtools_public.h"
+
+#if defined( _WIN32)
+#include <windows.h>
+#include <direct.h>
+#include <shobjidl.h>
+#include <knownfolders.h>
+#include <shlobj.h>
+#include <share.h>
+
+#undef GetEnvironmentVariable
+#else
+#include <dlfcn.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <alloca.h>
+#endif
+
+#if defined OSX
+#include <Foundation/Foundation.h>
+#include <AppKit/AppKit.h>
+#include <mach-o/dyld.h>
+#define _S_IFDIR S_IFDIR     // really from tier0/platform.h which we dont have yet
+#endif
+
+#include <sys/stat.h>
+
+#include <algorithm>
+
+/** Returns the path (including filename) to the current executable */
+std::string Path_GetExecutablePath()
+{
+#if defined( _WIN32 )
+	wchar_t *pwchPath = new wchar_t[MAX_UNICODE_PATH];
+	char *pchPath = new char[MAX_UNICODE_PATH_IN_UTF8];
+	::GetModuleFileNameW( NULL, pwchPath, MAX_UNICODE_PATH );
+	WideCharToMultiByte( CP_UTF8, 0, pwchPath, -1, pchPath, MAX_UNICODE_PATH_IN_UTF8, NULL, NULL );
+	delete[] pwchPath;
+
+	std::string sPath = pchPath;
+	delete[] pchPath;
+	return sPath;
+#elif defined( OSX )
+	char rchPath[1024];
+	uint32_t nBuff = sizeof( rchPath );
+	bool bSuccess = _NSGetExecutablePath(rchPath, &nBuff) == 0;
+	rchPath[nBuff-1] = '\0';
+	if( bSuccess )
+		return rchPath;
+	else
+		return "";
+#elif defined LINUX
+	char rchPath[1024];
+	size_t nBuff = sizeof( rchPath );
+	ssize_t nRead = readlink("/proc/self/exe", rchPath, nBuff-1 );
+	if ( nRead != -1 )
+	{
+		rchPath[ nRead ] = 0;
+		return rchPath;
+	}
+	else
+	{
+		return "";
+	}
+#else
+	AssertMsg( false, "Implement Plat_GetExecutablePath" );
+	return "";
+#endif
+
+}
+
+/** Returns the path of the current working directory */
+std::string Path_GetWorkingDirectory()
+{
+	std::string sPath;
+#if defined( _WIN32 )
+	wchar_t buf[MAX_UNICODE_PATH];
+	sPath = UTF16to8( _wgetcwd( buf, MAX_UNICODE_PATH ) );
+#else
+	char buf[ 1024 ];
+	sPath = getcwd( buf, sizeof( buf ) );
+#endif
+	return sPath;
+}
+
+/** Sets the path of the current working directory. Returns true if this was successful. */
+bool Path_SetWorkingDirectory( const std::string & sPath )
+{
+	bool bSuccess;
+#if defined( _WIN32 )
+	std::wstring wsPath = UTF8to16( sPath.c_str() );
+	bSuccess = 0 == _wchdir( wsPath.c_str() );
+#else
+	bSuccess = 0 == chdir( sPath.c_str() );
+#endif
+	return bSuccess;
+}
+
+/** Gets the path to a temporary directory. */
+std::string Path_GetTemporaryDirectory()
+{
+#if defined( _WIN32 )
+	wchar_t buf[MAX_UNICODE_PATH];
+	if ( GetTempPathW( MAX_UNICODE_PATH, buf ) == 0 )
+		return Path_GetWorkingDirectory();
+	return UTF16to8( buf );
+#else
+	const char *pchTmpDir = getenv( "TMPDIR" );
+	if ( pchTmpDir == NULL )
+	{
+		return "";
+	}
+	return pchTmpDir;
+#endif
+}
+
+/** Returns the specified path without its filename */
+std::string Path_StripFilename( const std::string & sPath, char slash )
+{
+	if( slash == 0 )
+		slash = Path_GetSlash();
+
+	std::string::size_type n = sPath.find_last_of( slash );
+	if( n == std::string::npos )
+		return sPath;
+	else
+		return std::string( sPath.begin(), sPath.begin() + n );
+}
+
+/** returns just the filename from the provided full or relative path. */
+std::string Path_StripDirectory( const std::string & sPath, char slash )
+{
+	if( slash == 0 )
+		slash = Path_GetSlash();
+
+	std::string::size_type n = sPath.find_last_of( slash );
+	if( n == std::string::npos )
+		return sPath;
+	else
+		return std::string( sPath.begin() + n + 1, sPath.end() );
+}
+
+/** returns just the filename with no extension of the provided filename. 
+* If there is a path the path is left intact. */
+std::string Path_StripExtension( const std::string & sPath )
+{
+	for( std::string::const_reverse_iterator i = sPath.rbegin(); i != sPath.rend(); i++ )
+	{
+		if( *i == '.' )
+		{
+			return std::string( sPath.begin(), i.base() - 1 );
+		}
+
+		// if we find a slash there is no extension
+		if( *i == '\\' || *i == '/' )
+			break;
+	}
+
+	// we didn't find an extension
+	return sPath;
+}
+
+/** returns just extension of the provided filename (if any). */
+std::string Path_GetExtension( const std::string & sPath )
+{
+	for ( std::string::const_reverse_iterator i = sPath.rbegin(); i != sPath.rend(); i++ )
+	{
+		if ( *i == '.' )
+		{
+			return std::string( i.base(), sPath.end() );
+		}
+
+		// if we find a slash there is no extension
+		if ( *i == '\\' || *i == '/' )
+			break;
+	}
+
+	// we didn't find an extension
+	return "";
+}
+
+bool Path_IsAbsolute( const std::string & sPath )
+{
+	if( sPath.empty() )
+		return false;
+
+#if defined( WIN32 )
+	if ( sPath.size() < 3 ) // must be c:\x or \\x at least
+		return false;
+
+	if ( sPath[1] == ':' ) // drive letter plus slash, but must test both slash cases
+	{
+		if ( sPath[2] == '\\' || sPath[2] == '/' )
+			return true;
+	}
+	else if ( sPath[0] == '\\' && sPath[1] == '\\' ) // UNC path
+		return true;
+#else
+	if( sPath[0] == '\\' || sPath[0] == '/' ) // any leading slash
+		return true;
+#endif
+
+	return false;
+}
+
+
+/** Makes an absolute path from a relative path and a base path */
+std::string Path_MakeAbsolute( const std::string & sRelativePath, const std::string & sBasePath )
+{
+	if( Path_IsAbsolute( sRelativePath ) )
+		return Path_Compact( sRelativePath );
+	else
+	{
+		if( !Path_IsAbsolute( sBasePath ) )
+			return "";
+
+		std::string sCompacted = Path_Compact( Path_Join( sBasePath, sRelativePath ) );
+		if( Path_IsAbsolute( sCompacted ) )
+			return sCompacted;
+		else
+			return "";
+	}
+}
+
+
+/** Fixes the directory separators for the current platform */
+std::string Path_FixSlashes( const std::string & sPath, char slash )
+{
+	if( slash == 0 )
+		slash = Path_GetSlash();
+
+	std::string sFixed = sPath;
+	for( std::string::iterator i = sFixed.begin(); i != sFixed.end(); i++ )
+	{
+		if( *i == '/' || *i == '\\' )
+			*i = slash;
+	}
+
+	return sFixed;
+}
+
+
+char Path_GetSlash()
+{
+#if defined(_WIN32)
+	return '\\';
+#else
+	return '/';
+#endif
+}
+
+/** Jams two paths together with the right kind of slash */
+std::string Path_Join( const std::string & first, const std::string & second, char slash )
+{
+	if( slash == 0 )
+		slash = Path_GetSlash();
+
+	// only insert a slash if we don't already have one
+	std::string::size_type nLen = first.length();
+	if( !nLen )
+		return second;
+#if defined(_WIN32)
+	if( first.back() == '\\' || first.back() == '/' )
+	    nLen--;
+#else
+	char last_char = first[first.length()-1];
+	if (last_char == '\\' || last_char == '/')
+	    nLen--;
+#endif
+
+	return first.substr( 0, nLen ) + std::string( 1, slash ) + second;
+}
+
+
+std::string Path_Join( const std::string & first, const std::string & second, const std::string & third, char slash )
+{
+	return Path_Join( Path_Join( first, second, slash ), third, slash );
+}
+
+std::string Path_Join( const std::string & first, const std::string & second, const std::string & third, const std::string &fourth, char slash )
+{
+	return Path_Join( Path_Join( Path_Join( first, second, slash ), third, slash ), fourth, slash );
+}
+
+std::string Path_Join( 
+	const std::string & first, 
+	const std::string & second, 
+	const std::string & third, 
+	const std::string & fourth, 
+	const std::string & fifth, 
+	char slash )
+{
+	return Path_Join( Path_Join( Path_Join( Path_Join( first, second, slash ), third, slash ), fourth, slash ), fifth, slash );
+}
+
+
+std::string Path_RemoveTrailingSlash( const std::string & sRawPath, char slash )
+{
+	if ( slash == 0 )
+		slash = Path_GetSlash();
+
+	std::string sPath = sRawPath;
+	std::string::size_type nCurrent = sRawPath.length();
+	if ( nCurrent == 0 )
+		return sPath;
+
+	int nLastFound = -1;
+	nCurrent--;
+	while( nCurrent != 0 )
+	{
+		if ( sRawPath[ nCurrent ] == slash )
+		{
+			nLastFound = (int)nCurrent;
+			nCurrent--;
+		}
+		else
+		{
+			break;
+		}
+	}
+		
+	if ( nLastFound >= 0 )
+	{
+		sPath.erase( nLastFound, std::string::npos );
+	}
+	
+	return sPath;
+}
+
+
+/** Removes redundant <dir>/.. elements in the path. Returns an empty path if the 
+* specified path has a broken number of directories for its number of ..s */
+std::string Path_Compact( const std::string & sRawPath, char slash )
+{
+	if( slash == 0 )
+		slash = Path_GetSlash();
+
+	std::string sPath = Path_FixSlashes( sRawPath, slash );
+	std::string sSlashString( 1, slash );
+
+	// strip out all /./
+	for( std::string::size_type i = 0; (i + 3) < sPath.length();  )
+	{
+		if( sPath[ i ] == slash && sPath[ i+1 ] == '.' && sPath[ i+2 ] == slash )
+		{
+			sPath.replace( i, 3, sSlashString );
+		}
+		else
+		{
+			++i;
+		}
+	}
+
+
+	// get rid of trailing /. but leave the path separator
+	if( sPath.length() > 2 )
+	{
+		std::string::size_type len = sPath.length();
+		if( sPath[ len-1 ] == '.'  && sPath[ len-2 ] == slash )
+		{
+			sPath.pop_back();
+			//Not sure why the following line of code was used for a while.  It causes problems with strlen.
+			//sPath[len-1] = 0;  // for now, at least 
+		}
+	}
+
+	// get rid of leading ./ 
+	if( sPath.length() > 2 )
+	{
+		if( sPath[ 0 ] == '.'  && sPath[ 1 ] == slash )
+		{
+			sPath.replace( 0, 2, "" );
+		}
+	}
+
+	// each time we encounter .. back up until we've found the previous directory name
+	// then get rid of both
+	std::string::size_type i = 0;
+	while( i < sPath.length() )
+	{
+		if( i > 0 && sPath.length() - i >= 2 
+			&& sPath[i] == '.'
+			&& sPath[i+1] == '.'
+			&& ( i + 2 == sPath.length() || sPath[ i+2 ] == slash )
+			&& sPath[ i-1 ] == slash )
+		{
+			// check if we've hit the start of the string and have a bogus path
+			if( i == 1 )
+				return "";
+			
+			// find the separator before i-1
+			std::string::size_type iDirStart = i-2;
+			while( iDirStart > 0 && sPath[ iDirStart - 1 ] != slash )
+				--iDirStart;
+
+			// remove everything from iDirStart to i+2
+			sPath.replace( iDirStart, (i - iDirStart) + 3, "" );
+
+			// start over
+			i = 0;
+		}
+		else
+		{
+			++i;
+		}
+	}
+
+	return sPath;
+}
+
+
+/** Returns true if these two paths are the same without respect for internal . or ..
+* sequences, slash type, or case (on case-insensitive platforms). */
+bool Path_IsSamePath( const std::string & sPath1, const std::string & sPath2 )
+{
+	std::string sCompact1 = Path_Compact( sPath1 );
+	std::string sCompact2 = Path_Compact( sPath2 );
+#if defined(WIN32)
+	return !stricmp( sCompact1.c_str(), sCompact2.c_str() );
+#else
+	return !strcmp( sCompact1.c_str(), sCompact2.c_str() );
+#endif
+}
+
+
+/** Returns the path to the current DLL or exe */
+std::string Path_GetThisModulePath()
+{
+	// gets the path of vrclient.dll itself
+#ifdef WIN32
+	HMODULE hmodule = NULL;
+
+	::GetModuleHandleEx( GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS | GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT, reinterpret_cast<LPCTSTR>(Path_GetThisModulePath), &hmodule );
+
+	wchar_t *pwchPath = new wchar_t[MAX_UNICODE_PATH];
+	char *pchPath = new char[ MAX_UNICODE_PATH_IN_UTF8 ];
+	::GetModuleFileNameW( hmodule, pwchPath, MAX_UNICODE_PATH );
+	WideCharToMultiByte( CP_UTF8, 0, pwchPath, -1, pchPath, MAX_UNICODE_PATH_IN_UTF8, NULL, NULL );
+	delete[] pwchPath;
+
+	std::string sPath = pchPath;
+	delete [] pchPath;
+	return sPath;
+
+#elif defined( OSX ) || defined( LINUX )
+	// get the addr of a function in vrclient.so and then ask the dlopen system about it
+	Dl_info info;
+	dladdr( (void *)Path_GetThisModulePath, &info );
+	return info.dli_fname;
+#endif
+
+}
+
+
+/** returns true if the specified path exists and is a directory */
+bool Path_IsDirectory( const std::string & sPath )
+{
+	std::string sFixedPath = Path_FixSlashes( sPath );
+	if( sFixedPath.empty() )
+		return false;
+	char cLast = sFixedPath[ sFixedPath.length() - 1 ];
+	if( cLast == '/' || cLast == '\\' )
+		sFixedPath.erase( sFixedPath.end() - 1, sFixedPath.end() );
+
+	// see if the specified path actually exists.
+
+#if defined(POSIX)
+	struct	stat	buf;
+	if ( stat( sFixedPath.c_str(), &buf ) == -1 )
+	{
+		return false;
+	}
+
+#if defined( LINUX ) || defined( OSX )
+	return S_ISDIR( buf.st_mode );
+#else
+	return (buf.st_mode & _S_IFDIR) != 0;
+#endif
+
+#else
+	struct	_stat	buf;
+	std::wstring wsFixedPath = UTF8to16( sFixedPath.c_str() );
+	if ( _wstat( wsFixedPath.c_str(), &buf ) == -1 )
+	{
+		return false;
+	}
+
+	return (buf.st_mode & _S_IFDIR) != 0;
+#endif
+}
+
+/** returns true if the specified path represents an app bundle */
+bool Path_IsAppBundle( const std::string & sPath )
+{
+#if defined(OSX)
+	@autoreleasepool {
+		NSBundle *bundle = [ NSBundle bundleWithPath: [ NSString stringWithUTF8String:sPath.c_str() ] ];
+		bool bisAppBundle = ( nullptr != bundle );
+		return bisAppBundle;
+	}
+#else
+	return false;
+#endif
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: returns true if the the path exists
+//-----------------------------------------------------------------------------
+bool Path_Exists( const std::string & sPath )
+{
+	std::string sFixedPath = Path_FixSlashes( sPath );
+	if( sFixedPath.empty() )
+		return false;
+
+#if defined( WIN32 )
+	struct	_stat	buf;
+	std::wstring wsFixedPath = UTF8to16( sFixedPath.c_str() );
+	if ( _wstat( wsFixedPath.c_str(), &buf ) == -1 )
+	{
+		return false;
+	}
+#else
+	struct stat buf;
+	if ( stat ( sFixedPath.c_str(), &buf ) == -1)
+	{
+		return false;
+	}
+#endif
+
+	return true;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: helper to find a directory upstream from a given path
+//-----------------------------------------------------------------------------
+std::string Path_FindParentDirectoryRecursively( const std::string &strStartDirectory, const std::string &strDirectoryName )
+{
+	std::string strFoundPath = "";
+	std::string strCurrentPath = Path_FixSlashes( strStartDirectory );
+	if ( strCurrentPath.length() == 0 )
+		return "";
+
+	bool bExists = Path_Exists( strCurrentPath );
+	std::string strCurrentDirectoryName = Path_StripDirectory( strCurrentPath );
+	if ( bExists && stricmp( strCurrentDirectoryName.c_str(), strDirectoryName.c_str() ) == 0 )
+		return strCurrentPath;
+
+	while( bExists && strCurrentPath.length() != 0 )
+	{
+		strCurrentPath = Path_StripFilename( strCurrentPath );
+		strCurrentDirectoryName = Path_StripDirectory( strCurrentPath );
+		bExists = Path_Exists( strCurrentPath );
+		if ( bExists && stricmp( strCurrentDirectoryName.c_str(), strDirectoryName.c_str() ) == 0 )
+			return strCurrentPath;
+	}
+
+	return "";
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: helper to find a subdirectory upstream from a given path
+//-----------------------------------------------------------------------------
+std::string Path_FindParentSubDirectoryRecursively( const std::string &strStartDirectory, const std::string &strDirectoryName )
+{
+	std::string strFoundPath = "";
+	std::string strCurrentPath = Path_FixSlashes( strStartDirectory );
+	if ( strCurrentPath.length() == 0 )
+		return "";
+
+	bool bExists = Path_Exists( strCurrentPath );
+	while( bExists && strCurrentPath.length() != 0 )
+	{
+		strCurrentPath = Path_StripFilename( strCurrentPath );
+		bExists = Path_Exists( strCurrentPath );
+
+		if( Path_Exists( Path_Join( strCurrentPath, strDirectoryName ) ) )
+		{
+			strFoundPath = Path_Join( strCurrentPath, strDirectoryName );
+			break;
+		}
+	}
+	return strFoundPath;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: reading and writing files in the vortex directory
+//-----------------------------------------------------------------------------
+unsigned char * Path_ReadBinaryFile( const std::string &strFilename, int *pSize )
+{
+	FILE *f;
+#if defined( POSIX )
+	f = fopen( strFilename.c_str(), "rb" );
+#else
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	// the open operation needs to be sharable, therefore use of _wfsopen instead of _wfopen_s
+	f = _wfsopen( wstrFilename.c_str(), L"rb", _SH_DENYNO );
+#endif
+	
+	unsigned char* buf = NULL;
+
+	if ( f != NULL )
+	{
+		fseek(f, 0, SEEK_END);
+		int size = ftell(f);
+		fseek(f, 0, SEEK_SET);
+
+		buf = new unsigned char[size];
+		if (buf && fread(buf, size, 1, f) == 1)
+		{
+			if (pSize)
+				*pSize = size;
+		}
+		else
+		{
+			delete[] buf;
+			buf = 0;
+		}
+
+		fclose(f);
+	}
+
+	return buf;
+}
+
+uint32_t  Path_ReadBinaryFile( const std::string &strFilename, unsigned char *pBuffer, uint32_t unSize )
+{
+	FILE *f;
+#if defined( POSIX )
+	f = fopen( strFilename.c_str(), "rb" );
+#else
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	errno_t err = _wfopen_s( &f, wstrFilename.c_str(), L"rb" );
+	if ( err != 0 )
+	{
+		f = NULL;
+	}
+#endif
+
+	uint32_t unSizeToReturn = 0;
+
+	if ( f != NULL )
+	{
+		fseek( f, 0, SEEK_END );
+		uint32_t size = (uint32_t)ftell( f );
+		fseek( f, 0, SEEK_SET );
+
+		if ( size > unSize || !pBuffer )
+		{
+			unSizeToReturn = (uint32_t)size;
+		}
+		else
+		{
+			if ( fread( pBuffer, size, 1, f ) == 1 )
+			{
+				unSizeToReturn = (uint32_t)size;
+			}
+		}
+
+		fclose( f );
+	}
+
+	return unSizeToReturn;
+}
+
+bool Path_WriteBinaryFile(const std::string &strFilename, unsigned char *pData, unsigned nSize)
+{
+	FILE *f;
+#if defined( POSIX )
+	f = fopen(strFilename.c_str(), "wb");
+#else
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	errno_t err = _wfopen_s( &f, wstrFilename.c_str(), L"wb" );
+	if (err != 0)
+	{
+		f = NULL;
+	}
+#endif
+
+	size_t written = 0;
+	if (f != NULL) {
+		written = fwrite(pData, sizeof(unsigned char), nSize, f);
+		fclose(f);
+	}
+
+	return written == nSize ? true : false;
+}
+
+std::string Path_ReadTextFile( const std::string &strFilename )
+{
+	// doing it this way seems backwards, but I don't
+	// see an easy way to do this with C/C++ style IO
+	// that isn't worse...
+	int size;
+	unsigned char* buf = Path_ReadBinaryFile( strFilename, &size );
+	if (!buf)
+		return "";
+
+	// convert CRLF -> LF
+	size_t outsize = 1;
+	for (int i=1; i < size; i++)
+	{
+		if (buf[i] == '\n' && buf[i-1] == '\r') // CRLF
+			buf[outsize-1] = '\n'; // ->LF
+		else
+			buf[outsize++] = buf[i]; // just copy
+	}
+
+	std::string ret((char *)buf, outsize);
+	delete[] buf;
+	return ret;
+}
+
+
+bool Path_MakeWritable( const std::string &strFilename )
+{
+#if defined ( _WIN32 )
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+
+	DWORD dwAttrs = GetFileAttributesW( wstrFilename.c_str() );
+	if ( dwAttrs != INVALID_FILE_ATTRIBUTES && ( dwAttrs & FILE_ATTRIBUTE_READONLY ) )
+	{
+		return SetFileAttributesW( wstrFilename.c_str(), dwAttrs & ~FILE_ATTRIBUTE_READONLY );
+	}
+#else
+	struct stat sb;
+
+	if ( stat( strFilename.c_str(), &sb ) == 0 && !( sb.st_mode & S_IWUSR ) )
+	{
+		return ( chmod( strFilename.c_str(), sb.st_mode | S_IWUSR ) == 0 );
+	}
+#endif
+
+	return true;
+}
+
+bool Path_WriteStringToTextFile( const std::string &strFilename, const char *pchData )
+{
+	FILE *f;
+#if defined( POSIX )
+	f = fopen( strFilename.c_str(), "w" );
+#else
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	errno_t err = _wfopen_s( &f, wstrFilename.c_str(), L"w" );
+	if ( err != 0 )
+	{
+		f = NULL;
+	}
+#endif
+	
+	bool ok = false;
+
+	if ( f != NULL )
+	{
+		ok = fputs( pchData, f) >= 0;
+		fclose(f);
+	}
+
+	return ok;
+}
+
+bool Path_WriteStringToTextFileAtomic( const std::string &strFilename, const char *pchData )
+{
+	std::string strTmpFilename = strFilename + ".tmp";
+
+	if ( !Path_WriteStringToTextFile( strTmpFilename, pchData ) )
+		return false;
+
+	// Platform specific atomic file replacement
+#if defined( _WIN32 )
+	std::wstring wsFilename = UTF8to16( strFilename.c_str() );
+	std::wstring wsTmpFilename = UTF8to16( strTmpFilename.c_str() );
+	if ( !::ReplaceFileW( wsFilename.c_str(), wsTmpFilename.c_str(), nullptr, 0, 0, 0 ) )
+	{
+		// if we couldn't ReplaceFile, try a non-atomic write as a fallback
+		if ( !Path_WriteStringToTextFile( strFilename, pchData ) )
+			return false;
+	}
+#elif defined( POSIX )
+	if ( rename( strTmpFilename.c_str(), strFilename.c_str() ) == -1 )
+		return false;
+#else
+#error Do not know how to write atomic file
+#endif
+
+	return true;
+}
+
+
+#if defined(WIN32)
+#define FILE_URL_PREFIX "file:///"
+#else
+#define FILE_URL_PREFIX "file://"
+#endif
+
+// Mozilla: see mozilla.patch for more details
+// ----------------------------------------------------------------------------------------------------------------------------
+// Purpose: Turns a path to a file on disk into a URL (or just returns the value if it's already a URL)
+// ----------------------------------------------------------------------------------------------------------------------------
+// std::string Path_FilePathToUrl( const std::string & sRelativePath, const std::string & sBasePath )
+// {
+// 	if ( StringHasPrefix( sRelativePath, "http://" )
+// 		|| StringHasPrefix( sRelativePath, "https://" )
+// 		|| StringHasPrefix( sRelativePath, "vr-input-workshop://" )
+// 		|| StringHasPrefix( sRelativePath, "file://" )
+// 	   )
+// 	{
+// 		return sRelativePath;
+// 	}
+// 	else
+// 	{
+// 		std::string sAbsolute = Path_MakeAbsolute( sRelativePath, sBasePath );
+// 		if ( sAbsolute.empty() )
+// 			return sAbsolute;
+// 		sAbsolute = Path_FixSlashes( sAbsolute, '/' );
+
+// 		size_t unBufferSize = sAbsolute.length() * 3;
+// 		char *pchBuffer = (char *)alloca( unBufferSize );
+// 		V_URLEncodeFullPath( pchBuffer, (int)unBufferSize, sAbsolute.c_str(), (int)sAbsolute.length() );
+
+// 		return std::string( FILE_URL_PREFIX ) + pchBuffer;
+// 	}
+// }
+
+// Mozilla: see mozilla.patch for more details
+// -----------------------------------------------------------------------------------------------------
+// Purpose: Strips off file:// off a URL and returns the path. For other kinds of URLs an empty string is returned
+// -----------------------------------------------------------------------------------------------------
+// std::string Path_UrlToFilePath( const std::string & sFileUrl )
+// {
+// 	if ( !strnicmp( sFileUrl.c_str(), FILE_URL_PREFIX, strlen( FILE_URL_PREFIX ) ) )
+// 	{
+// 		char *pchBuffer = (char *)alloca( sFileUrl.length() );
+// 		V_URLDecodeNoPlusForSpace( pchBuffer, (int)sFileUrl.length(), 
+// 			sFileUrl.c_str() + strlen( FILE_URL_PREFIX ), (int)( sFileUrl.length() - strlen( FILE_URL_PREFIX ) ) );
+
+// 		return Path_FixSlashes( pchBuffer );
+// 	}
+// 	else
+// 	{
+// 		return "";
+// 	}
+// }
+
+
+// -----------------------------------------------------------------------------------------------------
+// Purpose: Returns the root of the directory the system wants us to store user documents in
+// -----------------------------------------------------------------------------------------------------
+std::string GetUserDocumentsPath()
+{
+#if defined( WIN32 )
+	WCHAR rwchPath[MAX_PATH];
+
+	if ( !SUCCEEDED( SHGetFolderPathW( NULL, CSIDL_MYDOCUMENTS | CSIDL_FLAG_CREATE, NULL, 0, rwchPath ) ) )
+	{
+		return "";
+	}
+
+	// Convert the path to UTF-8 and store in the output
+	std::string sUserPath = UTF16to8( rwchPath );
+
+	return sUserPath;
+#elif defined( OSX )
+	@autoreleasepool {
+		NSArray *paths = NSSearchPathForDirectoriesInDomains( NSDocumentDirectory, NSUserDomainMask, YES );
+		if ( [paths count] == 0 )
+		{
+			return "";
+		}
+		
+		return [[paths objectAtIndex:0] UTF8String];
+	}
+#elif defined( LINUX )
+	// @todo: not solved/changed as part of OSX - still not real - just removed old class based steam cut and paste
+	const char *pchHome = getenv( "HOME" );
+	if ( pchHome == NULL )
+	{
+		return "";
+	}
+	return pchHome;
+#endif
+}
+
+
+// -----------------------------------------------------------------------------------------------------
+// Purpose: deletes / unlinks a single file
+// -----------------------------------------------------------------------------------------------------
+bool Path_UnlinkFile( const std::string &strFilename )
+{
+#if defined( WIN32 )
+	std::wstring wsFilename = UTF8to16( strFilename.c_str() );
+	return ( 0 != DeleteFileW( wsFilename.c_str() ) );
+#else
+	return ( 0 == unlink( strFilename.c_str() ) );
+#endif
+}
diff --git a/gfx/vr/service/openvr/src/pathtools_public.h b/gfx/vr/service/openvr/src/pathtools_public.h
new file mode 100644
index 0000000000..d7fe7ca649
--- /dev/null
+++ b/gfx/vr/service/openvr/src/pathtools_public.h
@@ -0,0 +1,150 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+#include <string>
+#include <stdint.h>
+
+/** Returns the path (including filename) to the current executable */
+std::string Path_GetExecutablePath();
+
+/** Returns the path of the current working directory */
+std::string Path_GetWorkingDirectory();
+
+/** Sets the path of the current working directory. Returns true if this was successful. */
+bool Path_SetWorkingDirectory( const std::string & sPath );
+
+/** Gets the path to a temporary directory. */
+std::string Path_GetTemporaryDirectory();
+
+/** returns the path (including filename) of the current shared lib or DLL */
+std::string Path_GetThisModulePath();
+
+/** Returns the specified path without its filename.
+* If slash is unspecified the native path separator of the current platform
+* will be used. */
+std::string Path_StripFilename( const std::string & sPath, char slash = 0 );
+
+/** returns just the filename from the provided full or relative path. */
+std::string Path_StripDirectory( const std::string & sPath, char slash = 0 );
+
+/** returns just the filename with no extension of the provided filename. 
+* If there is a path the path is left intact. */
+std::string Path_StripExtension( const std::string & sPath );
+
+/** returns just extension of the provided filename (if any). */
+std::string Path_GetExtension( const std::string & sPath );
+
+/** Returns true if the path is absolute */
+bool Path_IsAbsolute( const std::string & sPath );
+
+/** Makes an absolute path from a relative path and a base path */
+std::string Path_MakeAbsolute( const std::string & sRelativePath, const std::string & sBasePath );
+
+/** Fixes the directory separators for the current platform.
+* If slash is unspecified the native path separator of the current platform
+* will be used. */
+std::string Path_FixSlashes( const std::string & sPath, char slash = 0 );
+
+/** Returns the path separator for the current platform */
+char Path_GetSlash();
+
+/** Jams two paths together with the right kind of slash */
+std::string Path_Join( const std::string & first, const std::string & second, char slash = 0 );
+std::string Path_Join( const std::string & first, const std::string & second, const std::string & third, char slash = 0 );
+std::string Path_Join( const std::string & first, const std::string & second, const std::string & third, const std::string &fourth, char slash = 0 );
+std::string Path_Join( 
+	const std::string & first, 
+	const std::string & second, 
+	const std::string & third, 
+	const std::string & fourth, 
+	const std::string & fifth, 
+	char slash = 0 );
+
+
+/** Removes redundant <dir>/.. elements in the path. Returns an empty path if the 
+* specified path has a broken number of directories for its number of ..s.
+* If slash is unspecified the native path separator of the current platform
+* will be used. */
+std::string Path_Compact( const std::string & sRawPath, char slash = 0 );
+
+/** Returns true if these two paths are the same without respect for internal . or ..
+* sequences, slash type, or case (on case-insensitive platforms). */
+bool Path_IsSamePath( const std::string & sPath1, const std::string & sPath2 );
+
+//** Removed trailing slashes */
+std::string Path_RemoveTrailingSlash( const std::string & sRawPath, char slash = 0 );
+
+/** returns true if the specified path exists and is a directory */
+bool Path_IsDirectory( const std::string & sPath );
+
+/** returns true if the specified path represents an app bundle */
+bool Path_IsAppBundle( const std::string & sPath );
+
+/** returns true if the the path exists */
+bool Path_Exists( const std::string & sPath );
+
+/** Helper functions to find parent directories or subdirectories of parent directories */
+std::string Path_FindParentDirectoryRecursively( const std::string &strStartDirectory, const std::string &strDirectoryName );
+std::string Path_FindParentSubDirectoryRecursively( const std::string &strStartDirectory, const std::string &strDirectoryName );
+
+/** Make a text file writable. */
+bool Path_MakeWritable( const std::string &strFilename );
+
+/** Path operations to read or write text/binary files */
+unsigned char * Path_ReadBinaryFile( const std::string &strFilename, int *pSize );
+uint32_t  Path_ReadBinaryFile( const std::string &strFilename, unsigned char *pBuffer, uint32_t unSize );
+bool Path_WriteBinaryFile( const std::string &strFilename, unsigned char *pData, unsigned nSize );
+std::string Path_ReadTextFile( const std::string &strFilename );
+bool Path_WriteStringToTextFile( const std::string &strFilename, const char *pchData );
+bool Path_WriteStringToTextFileAtomic( const std::string &strFilename, const char *pchData );
+
+// Mozilla: see mozilla.patch for more details
+/** Returns a file:// url for paths, or an http or https url if that's what was provided */
+// std::string Path_FilePathToUrl( const std::string & sRelativePath, const std::string & sBasePath );
+
+/** Strips off file:// off a URL and returns the path. For other kinds of URLs an empty string is returned */
+std::string Path_UrlToFilePath( const std::string & sFileUrl );
+
+/** Returns the root of the directory the system wants us to store user documents in */
+std::string GetUserDocumentsPath();
+
+/** deletes / unlinks a single file */
+bool Path_UnlinkFile( const std::string &strFilename );
+
+#ifndef MAX_UNICODE_PATH
+	#define MAX_UNICODE_PATH 32767
+#endif
+
+#ifndef MAX_UNICODE_PATH_IN_UTF8
+	#define MAX_UNICODE_PATH_IN_UTF8 (MAX_UNICODE_PATH * 4)
+#endif
+
+//-----------------------------------------------------------------------------
+#if defined(WIN32)
+#define DYNAMIC_LIB_EXT	".dll"
+#define PROGRAM_EXT ".exe"
+#ifdef _WIN64
+#define PLATSUBDIR	"win64"
+#else
+#define PLATSUBDIR	"win32"
+#endif
+#elif defined(OSX)
+#define DYNAMIC_LIB_EXT	".dylib"
+#define PLATSUBDIR	"osx32"
+#define PROGRAM_EXT ""
+#elif defined(LINUX)
+#define DYNAMIC_LIB_EXT	".so"
+#define PROGRAM_EXT ""
+#if defined( LINUX32 )
+#define PLATSUBDIR	"linux32"
+#elif defined( ANDROIDARM64 )
+#define PLATSUBDIR	"androidarm64" 
+#elif defined( LINUXARM64 )
+#define PLATSUBDIR	"linuxarm64" 
+#else
+#define PLATSUBDIR	"linux64"
+#endif
+#else
+#warning "Unknown platform for PLATSUBDIR"
+#define PLATSUBDIR	"unknown_platform"
+#endif
diff --git a/gfx/vr/service/openvr/src/sharedlibtools_public.cpp b/gfx/vr/service/openvr/src/sharedlibtools_public.cpp
new file mode 100644
index 0000000000..048512a1de
--- /dev/null
+++ b/gfx/vr/service/openvr/src/sharedlibtools_public.cpp
@@ -0,0 +1,43 @@
+//========= Copyright Valve Corporation ============//
+#include "sharedlibtools_public.h"
+#include <string.h>
+
+#if defined(_WIN32)
+#include <windows.h>
+#endif
+
+#if defined(POSIX)
+#include <dlfcn.h>
+#endif
+
+SharedLibHandle SharedLib_Load( const char *pchPath )
+{
+#if defined( _WIN32)
+	return (SharedLibHandle)LoadLibraryEx( pchPath, NULL, LOAD_WITH_ALTERED_SEARCH_PATH );
+#elif defined(POSIX)
+	return (SharedLibHandle)dlopen(pchPath, RTLD_LOCAL|RTLD_NOW);
+#endif
+}
+
+void *SharedLib_GetFunction( SharedLibHandle lib, const char *pchFunctionName)
+{
+#if defined( _WIN32)
+	return (void*)GetProcAddress( (HMODULE)lib, pchFunctionName );
+#elif defined(POSIX)
+	return dlsym( lib, pchFunctionName );
+#endif
+}
+
+
+void SharedLib_Unload( SharedLibHandle lib )
+{
+	if ( !lib )
+		return;
+#if defined( _WIN32)
+	FreeLibrary( (HMODULE)lib );
+#elif defined(POSIX)
+	dlclose( lib );
+#endif
+}
+
+
diff --git a/gfx/vr/service/openvr/src/sharedlibtools_public.h b/gfx/vr/service/openvr/src/sharedlibtools_public.h
new file mode 100644
index 0000000000..10163dbfab
--- /dev/null
+++ b/gfx/vr/service/openvr/src/sharedlibtools_public.h
@@ -0,0 +1,10 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+typedef void *SharedLibHandle;
+
+SharedLibHandle SharedLib_Load( const char *pchPath );
+void *SharedLib_GetFunction( SharedLibHandle lib, const char *pchFunctionName);
+void SharedLib_Unload( SharedLibHandle lib );
+
+
diff --git a/gfx/vr/service/openvr/src/strtools_public.cpp b/gfx/vr/service/openvr/src/strtools_public.cpp
new file mode 100644
index 0000000000..d9a3881995
--- /dev/null
+++ b/gfx/vr/service/openvr/src/strtools_public.cpp
@@ -0,0 +1,571 @@
+//========= Copyright Valve Corporation ============//
+#include "strtools_public.h"
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sstream>
+// Mozilla: see mozilla.patch for more details
+// #include <codecvt>
+#include <iostream>
+#include <functional>
+#include <locale>
+// #include <codecvt>
+
+#if defined( _WIN32 )
+#include <windows.h>
+#endif
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool StringHasPrefix( const std::string & sString, const std::string & sPrefix )
+{
+	return 0 == strnicmp( sString.c_str(), sPrefix.c_str(), sPrefix.length() );
+}
+
+bool StringHasPrefixCaseSensitive( const std::string & sString, const std::string & sPrefix )
+{
+	return 0 == strncmp( sString.c_str(), sPrefix.c_str(), sPrefix.length() );
+}
+
+
+bool StringHasSuffix( const std::string &sString, const std::string &sSuffix )
+{
+	size_t cStrLen = sString.length();
+	size_t cSuffixLen = sSuffix.length();
+
+	if ( cSuffixLen > cStrLen )
+		return false;
+
+	std::string sStringSuffix = sString.substr( cStrLen - cSuffixLen, cSuffixLen );
+
+	return 0 == stricmp( sStringSuffix.c_str(), sSuffix.c_str() );
+}
+
+bool StringHasSuffixCaseSensitive( const std::string &sString, const std::string &sSuffix )
+{
+	size_t cStrLen = sString.length();
+	size_t cSuffixLen = sSuffix.length();
+
+	if ( cSuffixLen > cStrLen )
+		return false;
+
+	std::string sStringSuffix = sString.substr( cStrLen - cSuffixLen, cSuffixLen );
+
+	return 0 == strncmp( sStringSuffix.c_str(), sSuffix.c_str(),cSuffixLen );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+// Mozilla: see mozilla.patch for more details
+//typedef std::codecvt_utf8< wchar_t > convert_type;
+
+// Mozilla: see mozilla.patch for more details
+#if defined( _WIN32 )
+std::string UTF16to8(const wchar_t * in)
+{
+	int retLength = ::WideCharToMultiByte(CP_UTF8, 0, in, -1, nullptr, 0, nullptr, nullptr);
+	if (retLength == 0)
+	{
+		return std::string();
+	}
+
+	char* retString = new char[retLength];
+	::WideCharToMultiByte(CP_UTF8, 0, in, -1, retString, retLength, nullptr, nullptr);
+
+	std::string retStringValue(retString);
+
+	delete[] retString;
+
+	return retStringValue;
+
+	// static std::wstring_convert< convert_type, wchar_t > s_converter;  // construction of this can be expensive (or even serialized) depending on locale
+
+	// try
+	// {
+	// 	return s_converter.to_bytes( in );
+	// }
+	// catch ( ... )
+	// {
+	// 	return std::string();
+	// }
+}
+
+std::string UTF16to8( const std::wstring & in ) { return UTF16to8( in.c_str() ); }
+
+// Mozilla: see mozilla.patch for more details
+std::wstring UTF8to16(const char * in)
+{
+	int retLength = ::MultiByteToWideChar(CP_UTF8, 0, in, -1, nullptr, 0);
+	if (retLength == 0)
+	{
+		return std::wstring();
+	}
+
+	wchar_t* retString = new wchar_t[retLength];
+	::MultiByteToWideChar(CP_UTF8, 0, in, -1, retString, retLength);
+
+	std::wstring retStringValue(retString);
+
+	delete[] retString;
+
+	return retStringValue;
+
+	//static std::wstring_convert< convert_type, wchar_t > s_converter;  // construction of this can be expensive (or even serialized) depending on locale
+
+	//try
+	//{
+	//	return s_converter.from_bytes( in );
+	//}
+	//catch ( ... )
+	//{
+	//	return std::wstring();
+	//}
+}
+
+std::wstring UTF8to16( const std::string & in ) { return UTF8to16( in.c_str() ); }
+#endif
+
+
+#if defined( _WIN32 )
+//-----------------------------------------------------------------------------
+// Purpose: Convert LPSTR in the default CodePage to UTF8
+//-----------------------------------------------------------------------------
+std::string DefaultACPtoUTF8( const char *pszStr )
+{
+	if ( GetACP() == CP_UTF8 )
+	{
+		return pszStr;
+	}
+	else
+	{
+		std::vector<wchar_t> vecBuf( strlen( pszStr ) + 1 ); // should be guaranteed to be enough
+		MultiByteToWideChar( CP_ACP, MB_PRECOMPOSED, pszStr, -1, vecBuf.data(), (int) vecBuf.size() );
+		return UTF16to8( vecBuf.data() );
+	}
+}
+#endif
+
+// --------------------------------------------------------------------
+// Purpose:
+// --------------------------------------------------------------------
+void strcpy_safe( char *pchBuffer, size_t unBufferSizeBytes, const char *pchSource )
+{
+	strncpy( pchBuffer, pchSource, unBufferSizeBytes - 1 );
+	pchBuffer[unBufferSizeBytes - 1] = '\0';
+}
+
+// --------------------------------------------------------------------
+// Purpose: converts a string to upper case
+// --------------------------------------------------------------------
+std::string StringToUpper( const std::string & sString )
+{
+	std::string sOut;
+	sOut.reserve( sString.size() + 1 );
+	for( std::string::const_iterator i = sString.begin(); i != sString.end(); i++ )
+	{
+		sOut.push_back( (char)toupper( *i ) );
+	}
+
+	return sOut;
+}
+
+
+// --------------------------------------------------------------------
+// Purpose: converts a string to lower case
+// --------------------------------------------------------------------
+std::string StringToLower( const std::string & sString )
+{
+	std::string sOut;
+	sOut.reserve( sString.size() + 1 );
+	for( std::string::const_iterator i = sString.begin(); i != sString.end(); i++ )
+	{
+		sOut.push_back( (char)tolower( *i ) );
+	}
+
+	return sOut;
+}
+
+
+uint32_t ReturnStdString( const std::string & sValue, char *pchBuffer, uint32_t unBufferLen )
+{
+	uint32_t unLen = (uint32_t)sValue.length() + 1;
+	if( !pchBuffer || !unBufferLen )
+		return unLen;
+
+	if( unBufferLen < unLen )
+	{
+		pchBuffer[0] = '\0';
+	}
+	else
+	{
+		memcpy( pchBuffer, sValue.c_str(), unLen );
+	}
+
+	return unLen;
+}
+
+
+/** Returns a std::string from a uint64_t */
+// Mozilla: see mozilla.patch for more details
+// std::string Uint64ToString( uint64_t ulValue )
+// {
+// 	char buf[ 22 ];
+// #if defined( _WIN32 )
+// 	sprintf_s( buf, "%llu", ulValue );
+// #else
+//     snprintf( buf, sizeof( buf ), "%llu", (long long unsigned int ) ulValue );
+// #endif
+// 	return buf;
+// }
+
+
+/** returns a uint64_t from a string */
+uint64_t StringToUint64( const std::string & sValue )
+{
+	return strtoull( sValue.c_str(), NULL, 0 );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Helper for converting a numeric value to a hex digit, value should be 0-15.
+//-----------------------------------------------------------------------------
+char cIntToHexDigit( int nValue )
+{
+	//Assert( nValue >= 0 && nValue <= 15 );
+	return "0123456789ABCDEF"[ nValue & 15 ];
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Helper for converting a hex char value to numeric, return -1 if the char
+//          is not a valid hex digit.
+//-----------------------------------------------------------------------------
+int iHexCharToInt( char cValue )
+{
+	int32_t iValue = cValue;
+	if ( (uint32_t)( iValue - '0' ) < 10 )
+		return iValue - '0';
+
+	iValue |= 0x20;
+	if ( (uint32_t)( iValue - 'a' ) < 6 )
+		return iValue - 'a' + 10;
+
+	return -1;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: These define the set of characters to filter for components (which
+//			need all the escaping we can muster) vs. paths (which don't want
+//			/ and : escaped so we don't break less compliant URL handling code.
+//-----------------------------------------------------------------------------
+static bool CharNeedsEscape_Component( const char c )
+{
+	return (!(c >= 'a' && c <= 'z') && !(c >= 'A' && c <= 'Z') && !(c >= '0' && c <= '9')
+		&& c != '-' && c != '_' && c != '.');
+}
+static bool CharNeedsEscape_FullPath( const char c )
+{
+	return (!(c >= 'a' && c <= 'z') && !(c >= 'A' && c <= 'Z') && !(c >= '0' && c <= '9')
+		&& c != '-' && c != '_' && c != '.' && c != '/' && c != ':' );
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Internal implementation of encode, works in the strict RFC manner, or
+//          with spaces turned to + like HTML form encoding.
+//-----------------------------------------------------------------------------
+void V_URLEncodeInternal( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen, 
+	bool bUsePlusForSpace, std::function< bool(const char)> fnNeedsEscape )
+{
+	//AssertMsg( nDestLen > 3*nSourceLen, "Target buffer for V_URLEncode should be 3x source length, plus one for terminating null\n" );
+	
+	int iDestPos = 0;
+	for ( int i=0; i < nSourceLen; ++i )
+	{
+		// worst case we need 3 additional chars
+		if( (iDestPos+3) > nDestLen  )
+		{
+			pchDest[0] = '\0';
+//			AssertMsg( false, "Target buffer too short\n" );
+			return;
+		}
+
+		// We allow only a-z, A-Z, 0-9, period, underscore, and hyphen to pass through unescaped.
+		// These are the characters allowed by both the original RFC 1738 and the latest RFC 3986.
+		// Current specs also allow '~', but that is forbidden under original RFC 1738.
+		if ( fnNeedsEscape( pchSource[i] ) )
+		{
+			if ( bUsePlusForSpace && pchSource[i] == ' ' )
+			{
+				pchDest[iDestPos++] = '+';
+			}
+			else
+			{
+				pchDest[iDestPos++] = '%';
+				uint8_t iValue = pchSource[i];
+				if ( iValue == 0 )
+				{
+					pchDest[iDestPos++] = '0';
+					pchDest[iDestPos++] = '0';
+				}
+				else
+				{
+					char cHexDigit1 = cIntToHexDigit( iValue % 16 );
+					iValue /= 16;
+					char cHexDigit2 = cIntToHexDigit( iValue );
+					pchDest[iDestPos++] = cHexDigit2;
+					pchDest[iDestPos++] = cHexDigit1;
+				}
+			}
+		}
+		else
+		{
+			pchDest[iDestPos++] = pchSource[i];
+		}
+	}
+
+	if( (iDestPos+1) > nDestLen )
+	{
+		pchDest[0] = '\0';
+		//AssertMsg( false, "Target buffer too short to terminate\n" );
+		return;
+	}
+
+	// Null terminate
+	pchDest[iDestPos++] = 0;
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Internal implementation of decode, works in the strict RFC manner, or
+//          with spaces turned to + like HTML form encoding.
+//
+//			Returns the amount of space used in the output buffer.
+//-----------------------------------------------------------------------------
+size_t V_URLDecodeInternal( char *pchDecodeDest, int nDecodeDestLen, const char *pchEncodedSource, int nEncodedSourceLen, bool bUsePlusForSpace )
+{
+	if ( nDecodeDestLen < nEncodedSourceLen )
+	{
+		//AssertMsg( false, "V_URLDecode needs a dest buffer at least as large as the source" );
+		return 0;
+	}
+
+	int iDestPos = 0;
+	for( int i=0; i < nEncodedSourceLen; ++i )
+	{
+		if ( bUsePlusForSpace && pchEncodedSource[i] == '+' )
+		{
+			pchDecodeDest[ iDestPos++ ] = ' ';
+		}
+		else if ( pchEncodedSource[i] == '%' )
+		{
+			// Percent signifies an encoded value, look ahead for the hex code, convert to numeric, and use that
+
+			// First make sure we have 2 more chars
+			if ( i < nEncodedSourceLen - 2 )
+			{
+				char cHexDigit1 = pchEncodedSource[i+1];
+				char cHexDigit2 = pchEncodedSource[i+2];
+
+				// Turn the chars into a hex value, if they are not valid, then we'll
+				// just place the % and the following two chars direct into the string,
+				// even though this really shouldn't happen, who knows what bad clients
+				// may do with encoding.
+				bool bValid = false;
+				int iValue = iHexCharToInt( cHexDigit1 );
+				if ( iValue != -1 )
+				{
+					iValue *= 16;
+					int iValue2 = iHexCharToInt( cHexDigit2 );
+					if ( iValue2 != -1 )
+					{
+						iValue += iValue2;
+						pchDecodeDest[ iDestPos++ ] = (char)iValue;
+						bValid = true;
+					}
+				}
+
+				if ( !bValid )
+				{
+					pchDecodeDest[ iDestPos++ ] = '%';
+					pchDecodeDest[ iDestPos++ ] = cHexDigit1;
+					pchDecodeDest[ iDestPos++ ] = cHexDigit2;
+				}
+			}
+
+			// Skip ahead
+			i += 2;
+		}
+		else
+		{
+			pchDecodeDest[ iDestPos++ ] = pchEncodedSource[i];
+		}
+	}
+
+	// We may not have extra room to NULL terminate, since this can be used on raw data, but if we do
+	// go ahead and do it as this can avoid bugs.
+	if ( iDestPos < nDecodeDestLen )
+	{
+		pchDecodeDest[iDestPos] = 0;
+	}
+
+	return (size_t)iDestPos;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Encodes a string (or binary data) from URL encoding format, see rfc1738 section 2.2.  
+//          This version of the call isn't a strict RFC implementation, but uses + for space as is
+//          the standard in HTML form encoding, despite it not being part of the RFC.
+//
+//          Dest buffer should be at least as large as source buffer to guarantee room for decode.
+//-----------------------------------------------------------------------------
+void V_URLEncode( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen )
+{
+	return V_URLEncodeInternal( pchDest, nDestLen, pchSource, nSourceLen, true, CharNeedsEscape_Component );
+}
+
+
+void V_URLEncodeNoPlusForSpace( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen )
+{
+	return V_URLEncodeInternal( pchDest, nDestLen, pchSource, nSourceLen, false, CharNeedsEscape_Component );
+}
+
+void V_URLEncodeFullPath( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen )
+{
+	return V_URLEncodeInternal( pchDest, nDestLen, pchSource, nSourceLen, false, CharNeedsEscape_FullPath );
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Decodes a string (or binary data) from URL encoding format, see rfc1738 section 2.2.  
+//          This version of the call isn't a strict RFC implementation, but uses + for space as is
+//          the standard in HTML form encoding, despite it not being part of the RFC.
+//
+//          Dest buffer should be at least as large as source buffer to guarantee room for decode.
+//			Dest buffer being the same as the source buffer (decode in-place) is explicitly allowed.
+//-----------------------------------------------------------------------------
+size_t V_URLDecode( char *pchDecodeDest, int nDecodeDestLen, const char *pchEncodedSource, int nEncodedSourceLen )
+{
+	return V_URLDecodeInternal( pchDecodeDest, nDecodeDestLen, pchEncodedSource, nEncodedSourceLen, true );
+}
+
+size_t V_URLDecodeNoPlusForSpace( char *pchDecodeDest, int nDecodeDestLen, const char *pchEncodedSource, int nEncodedSourceLen )
+{
+	return V_URLDecodeInternal( pchDecodeDest, nDecodeDestLen, pchEncodedSource, nEncodedSourceLen, false );
+}
+
+//-----------------------------------------------------------------------------
+void V_StripExtension( std::string &in )
+{
+	// Find the last dot. If it's followed by a dot or a slash, then it's part of a 
+	// directory specifier like ../../somedir/./blah.
+	std::string::size_type test = in.rfind( '.' );
+	if ( test != std::string::npos )
+	{
+		// This handles things like ".\blah" or "c:\my@email.com\abc\def\geh"
+		// Which would otherwise wind up with "" and "c:\my@email", respectively.
+		if ( in.rfind( '\\' ) < test && in.rfind( '/' ) < test )
+		{
+			in.resize( test );
+		}
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Tokenizes a string into a vector of strings
+//-----------------------------------------------------------------------------
+std::vector<std::string> TokenizeString( const std::string & sString, char cToken )
+{
+	std::vector<std::string> vecStrings;
+	std::istringstream stream( sString );
+	std::string s;
+	while ( std::getline( stream, s, cToken ) )
+	{
+		vecStrings.push_back( s );
+	}
+	return vecStrings;
+}
+
+// Mozilla: see mozilla.patch for more details
+//-----------------------------------------------------------------------------
+// Purpose: Repairs a should-be-UTF-8 string to a for-sure-is-UTF-8 string, plus return boolean if we subbed in '?' somewhere
+//-----------------------------------------------------------------------------
+// bool RepairUTF8( const char *pbegin, const char *pend, std::string & sOutputUtf8 )
+// {
+// 	typedef std::codecvt_utf8<char32_t> facet_type;
+// 	facet_type myfacet;
+
+// 	std::mbstate_t mystate = std::mbstate_t();
+
+// 	sOutputUtf8.clear();
+// 	sOutputUtf8.reserve( pend - pbegin );
+// 	bool bSqueakyClean = true;
+
+// 	const char *pmid = pbegin;
+// 	while ( pmid != pend )
+// 	{
+// 		bool bHasError = false;
+// 		bool bHasValidData = false;
+
+// 		char32_t out = 0xdeadbeef, *pout;
+// 		pbegin = pmid;
+// 		switch ( myfacet.in( mystate, pbegin, pend, pmid, &out, &out + 1, pout ) )
+// 		{
+// 		case facet_type::ok:
+// 			bHasValidData = true;
+// 			break;
+
+// 		case facet_type::noconv:
+// 			// unexpected! always converting type
+// 			bSqueakyClean = false;
+// 			break;
+
+// 		case facet_type::partial:
+// 			bHasError = pbegin == pmid;
+// 			if ( bHasError )
+// 			{
+// 				bSqueakyClean = false;
+// 			}
+// 			else
+// 			{
+// 				bHasValidData = true;
+// 			}
+// 			break;
+
+// 		case facet_type::error:
+// 			bHasError = true;
+// 			bSqueakyClean = false;
+// 			break;
+// 		}
+
+// 		if ( bHasValidData )
+// 		{
+// 			// could convert back, but no need
+// 			for ( const char *p = pbegin; p != pmid; ++p )
+// 			{
+// 				sOutputUtf8 += *p;
+// 			}
+// 		}
+
+// 		if ( bHasError )
+// 		{
+// 			sOutputUtf8 += '?';
+// 		}
+
+// 		if ( pmid == pbegin )
+// 		{
+// 			pmid++;
+// 		}
+// 	}
+
+// 	return bSqueakyClean;
+// }
+
+// //-----------------------------------------------------------------------------
+// // Purpose: Repairs a should-be-UTF-8 string to a for-sure-is-UTF-8 string, plus return boolean if we subbed in '?' somewhere
+// //-----------------------------------------------------------------------------
+// bool RepairUTF8( const std::string & sInputUtf8, std::string & sOutputUtf8 )
+// {
+// 	return RepairUTF8( sInputUtf8.data(), sInputUtf8.data() + sInputUtf8.size(), sOutputUtf8 );
+// }
diff --git a/gfx/vr/service/openvr/src/strtools_public.h b/gfx/vr/service/openvr/src/strtools_public.h
new file mode 100644
index 0000000000..9bb54be7e3
--- /dev/null
+++ b/gfx/vr/service/openvr/src/strtools_public.h
@@ -0,0 +1,156 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+#include <string>
+#include <stdint.h>
+#include <sys/types.h>
+#include <vector>
+
+/** returns true if the string has the prefix */
+bool StringHasPrefix( const std::string & sString, const std::string & sPrefix );
+bool StringHasPrefixCaseSensitive( const std::string & sString, const std::string & sPrefix );
+
+/** returns if the string has the suffix */
+bool StringHasSuffix( const std::string &sString, const std::string &sSuffix );
+bool StringHasSuffixCaseSensitive( const std::string &sString, const std::string &sSuffix );
+
+// Mozilla: see mozilla.patch for more details
+#if defined( _WIN32 )
+/** converts a UTF-16 string to a UTF-8 string */
+std::string UTF16to8( const wchar_t * in );
+std::string UTF16to8( const std::wstring & in );
+
+/** converts a UTF-8 string to a UTF-16 string */
+std::wstring UTF8to16(const char * in);
+std::wstring UTF8to16( const std::string & in );
+#define Utf16FromUtf8 UTF8to16
+#endif
+
+#if defined( _WIN32 )
+std::string DefaultACPtoUTF8( const char *pszStr );
+#endif
+
+/** Repairs a should-be-UTF-8 string to a for-sure-is-UTF-8 string, plus return boolean if we subbed in '?' somewhere */
+bool RepairUTF8( const char *begin, const char *end, std::string & sOutputUtf8 );
+bool RepairUTF8( const std::string & sInputUtf8, std::string & sOutputUtf8 );
+
+/** safely copy a string into a buffer */
+void strcpy_safe( char *pchBuffer, size_t unBufferSizeBytes, const char *pchSource );
+template< size_t bufferSize >
+void strcpy_safe( char (& buffer) [ bufferSize ], const char *pchSource ) 
+{
+	strcpy_safe( buffer, bufferSize, pchSource );
+}
+
+
+/** converts a string to upper case */
+std::string StringToUpper( const std::string & sString );
+
+/** converts a string to lower case */
+std::string StringToLower( const std::string & sString );
+
+// we stricmp (from WIN) but it isn't POSIX - OSX/LINUX have strcasecmp so just inline bridge to it
+#if defined( OSX ) || defined( LINUX )
+#include <strings.h>
+inline int stricmp(const char *pStr1, const char *pStr2) { return strcasecmp(pStr1,pStr2); }
+#ifndef _stricmp
+#define _stricmp stricmp
+#endif
+inline int strnicmp( const char *pStr1, const char *pStr2, size_t unBufferLen ) { return strncasecmp( pStr1,pStr2, unBufferLen ); }
+#ifndef _strnicmp
+#define _strnicmp strnicmp
+#endif
+
+#ifndef _vsnprintf_s
+#define _vsnprintf_s vsnprintf
+#endif
+
+#define _TRUNCATE ((size_t)-1)
+
+#endif
+
+#if defined( OSX )
+// behaviors ensure NULL-termination at least as well as _TRUNCATE does, but
+// wcsncpy_s/strncpy_s can non-NULL-terminate, wcslcpy/strlcpy can not.
+// inline errno_t wcsncpy_s(wchar_t *strDest, size_t numberOfElements, const wchar_t *strSource, size_t count)
+// {
+// 	return wcslcpy(strDest, strSource, numberOfElements);
+// }
+
+// inline errno_t strncpy_s(char *strDest, size_t numberOfElements, const char *strSource, size_t count)
+// {
+// 	return strlcpy(strDest, strSource, numberOfElements);
+// }
+
+#endif
+
+#if defined( LINUX )
+// this implementation does not return whether or not the destination was 
+// truncated, but that is straightforward to fix if anybody actually needs the
+// return code. 
+#include "string.h"
+inline void wcsncpy_s(wchar_t *strDest, size_t numberOfElements, const wchar_t *strSource, size_t count)
+{
+	wcsncpy(strDest, strSource, numberOfElements);
+	strDest[numberOfElements-1] = '\0';
+}
+
+inline void strncpy_s(char *strDest, size_t numberOfElements, const char *strSource, size_t count)
+{
+	strncpy(strDest, strSource, numberOfElements);
+	strDest[numberOfElements-1] = '\0';
+}
+
+#endif
+
+#if defined( _WIN32 ) && _MSC_VER < 1800
+inline uint64_t strtoull(const char *str, char **endptr, int base) { return _strtoui64( str, endptr, base ); }
+#endif
+
+/* Handles copying a std::string into a buffer as would be provided in an API */
+uint32_t ReturnStdString( const std::string & sValue, char *pchBuffer, uint32_t unBufferLen );
+
+/** Returns a std::string from a uint64_t */
+// Mozilla: see mozilla.patch for more details
+//std::string Uint64ToString( uint64_t ulValue );
+
+/** returns a uint64_t from a string */
+uint64_t StringToUint64( const std::string & sValue );
+
+//-----------------------------------------------------------------------------
+// Purpose: Encodes a string (or binary data) from URL encoding format, see rfc1738 section 2.2.  
+//          This version of the call isn't a strict RFC implementation, but uses + for space as is
+//          the standard in HTML form encoding, despite it not being part of the RFC.
+//
+//          Dest buffer should be at least as large as source buffer to guarantee room for decode.
+//-----------------------------------------------------------------------------
+void V_URLEncode( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen );
+
+/** Same as V_URLEncode, but without plus for space. */
+void V_URLEncodeNoPlusForSpace( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen );
+
+/** Same as V_URLEncodeNoPlusForSpace, but without escaping / and : */
+void V_URLEncodeFullPath( char *pchDest, int nDestLen, const char *pchSource, int nSourceLen );
+
+
+//-----------------------------------------------------------------------------
+// Purpose: Decodes a string (or binary data) from URL encoding format, see rfc1738 section 2.2.  
+//          This version of the call isn't a strict RFC implementation, but uses + for space as is
+//          the standard in HTML form encoding, despite it not being part of the RFC.
+//
+//          Dest buffer should be at least as large as source buffer to guarantee room for decode.
+//			Dest buffer being the same as the source buffer (decode in-place) is explicitly allowed.
+//-----------------------------------------------------------------------------
+size_t V_URLDecode( char *pchDecodeDest, int nDecodeDestLen, const char *pchEncodedSource, int nEncodedSourceLen );
+
+/** Same as V_URLDecode, but without plus for space. */
+size_t V_URLDecodeNoPlusForSpace( char *pchDecodeDest, int nDecodeDestLen, const char *pchEncodedSource, int nEncodedSourceLen );
+
+//-----------------------------------------------------------------------------
+// Purpose: strip extension from a path
+//-----------------------------------------------------------------------------
+void V_StripExtension( std::string &in );
+
+
+/** Tokenizes a string into a vector of strings */
+std::vector<std::string> TokenizeString( const std::string & sString, char cToken );
diff --git a/gfx/vr/service/openvr/src/vrpathregistry_public.cpp b/gfx/vr/service/openvr/src/vrpathregistry_public.cpp
new file mode 100644
index 0000000000..0af46e57cb
--- /dev/null
+++ b/gfx/vr/service/openvr/src/vrpathregistry_public.cpp
@@ -0,0 +1,442 @@
+//========= Copyright Valve Corporation ============//
+
+#include "vrpathregistry_public.h"
+#include "json/json.h"
+#include "pathtools_public.h"
+#include "envvartools_public.h"
+#include "strtools_public.h"
+#include "dirtools_public.h"
+
+#if defined( WIN32 )
+#include <windows.h>
+#include <shlobj.h>
+
+#undef GetEnvironmentVariable
+#elif defined OSX
+#include <Foundation/Foundation.h>
+#include <AppKit/AppKit.h>
+#elif defined(LINUX)
+#include <dlfcn.h>
+#include <stdio.h>
+#endif
+
+#include <algorithm>
+
+#ifndef VRLog
+	#if defined( __MINGW32__ )
+		#define VRLog(args...)		fprintf(stderr, args)
+	#elif defined( WIN32 )
+		#define VRLog(fmt, ...)		fprintf(stderr, fmt, __VA_ARGS__)
+	#else
+		#define VRLog(args...)		fprintf(stderr, args)
+	#endif
+#endif
+
+/** Returns the root of the directory the system wants us to store user config data in */
+static std::string GetAppSettingsPath()
+{
+#if defined( WIN32 )
+	WCHAR rwchPath[MAX_PATH];
+
+	if( !SUCCEEDED( SHGetFolderPathW( NULL, CSIDL_LOCAL_APPDATA | CSIDL_FLAG_CREATE, NULL, 0, rwchPath ) ) )
+	{
+		return "";
+	}
+
+	// Convert the path to UTF-8 and store in the output
+	std::string sUserPath = UTF16to8( rwchPath );
+
+	return sUserPath;
+#elif defined( OSX )
+	std::string sSettingsDir;
+	@autoreleasepool {
+		// Search for the path
+		NSArray *paths = NSSearchPathForDirectoriesInDomains( NSApplicationSupportDirectory, NSUserDomainMask, YES );
+		if ( [paths count] == 0 )
+		{
+			return "";
+		}
+		
+		NSString *resolvedPath = [paths objectAtIndex:0];
+		resolvedPath = [resolvedPath stringByAppendingPathComponent: @"OpenVR"];
+		
+		if ( ![[NSFileManager defaultManager] createDirectoryAtPath: resolvedPath withIntermediateDirectories:YES attributes:nil error:nil] )
+		{
+			return "";
+		}
+		
+		sSettingsDir.assign( [resolvedPath UTF8String] );
+	}
+	return sSettingsDir;
+#elif defined( LINUX )
+
+	// As defined by XDG Base Directory Specification 
+	// https://specifications.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+	const char *pchHome = getenv("XDG_CONFIG_HOME");
+	if ( ( pchHome != NULL) && ( pchHome[0] != '\0' ) )
+	{
+		return pchHome;
+	}
+
+	//
+	// XDG_CONFIG_HOME is not defined, use ~/.config instead
+	// 
+	pchHome = getenv( "HOME" );
+	if ( pchHome == NULL )
+	{
+		return "";
+	}
+
+	std::string sUserPath( pchHome );
+	sUserPath = Path_Join( sUserPath, ".config" );
+	return sUserPath;
+#else
+	#warning "Unsupported platform"
+#endif
+}
+
+
+// ---------------------------------------------------------------------------
+// Purpose: Constructor
+// ---------------------------------------------------------------------------
+CVRPathRegistry_Public::CVRPathRegistry_Public()
+{
+
+}
+
+// ---------------------------------------------------------------------------
+// Purpose: Computes the registry filename
+// ---------------------------------------------------------------------------
+std::string CVRPathRegistry_Public::GetOpenVRConfigPath()
+{
+	std::string sConfigPath = GetAppSettingsPath();
+	if( sConfigPath.empty() )
+		return "";
+
+#if defined( _WIN32 ) || defined( LINUX )
+	sConfigPath = Path_Join( sConfigPath, "openvr" );
+#elif defined ( OSX ) 
+	sConfigPath = Path_Join( sConfigPath, ".openvr" );
+#else
+	#warning "Unsupported platform"
+#endif
+	sConfigPath = Path_FixSlashes( sConfigPath );
+	return sConfigPath;
+}
+
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+std::string CVRPathRegistry_Public::GetVRPathRegistryFilename()
+{
+	std::string sOverridePath = GetEnvironmentVariable( "VR_PATHREG_OVERRIDE" );
+	if ( !sOverridePath.empty() )
+		return sOverridePath;
+
+	std::string sPath = GetOpenVRConfigPath();
+	if ( sPath.empty() )
+		return "";
+
+#if defined( _WIN32 )
+	sPath = Path_Join( sPath, "openvrpaths.vrpath" );
+#elif defined ( POSIX ) 
+	sPath = Path_Join( sPath, "openvrpaths.vrpath" );
+#else
+	#error "Unsupported platform"
+#endif
+	sPath = Path_FixSlashes( sPath );
+	return sPath;
+}
+
+
+// ---------------------------------------------------------------------------
+// Purpose: Converts JSON to a history array
+// ---------------------------------------------------------------------------
+static void ParseStringListFromJson( std::vector< std::string > *pvecHistory, const Json::Value & root, const char *pchArrayName )
+{
+	if( !root.isMember( pchArrayName ) )
+		return;
+
+	const Json::Value & arrayNode = root[ pchArrayName ];
+	if( !arrayNode )
+	{
+		VRLog( "VR Path Registry node %s is not an array\n", pchArrayName );
+		return;
+	}
+
+	pvecHistory->clear();
+	pvecHistory->reserve( arrayNode.size() );
+	for( uint32_t unIndex = 0; unIndex < arrayNode.size(); unIndex++ )
+	{
+		std::string sPath( arrayNode[ unIndex ].asString() );
+		pvecHistory->push_back( sPath );
+	}
+}
+
+
+// ---------------------------------------------------------------------------
+// Purpose: Converts a history array to JSON
+// ---------------------------------------------------------------------------
+static void StringListToJson( const std::vector< std::string > & vecHistory, Json::Value & root, const char *pchArrayName )
+{
+	Json::Value & arrayNode = root[ pchArrayName ];
+	for( auto i = vecHistory.begin(); i != vecHistory.end(); i++ )
+	{
+		arrayNode.append( *i );
+	}
+}
+
+
+//-----------------------------------------------------------------------------
+// Purpose:
+//-----------------------------------------------------------------------------
+bool CVRPathRegistry_Public::ToJsonString( std::string &sJsonString )
+{
+	std::string sRegPath = GetVRPathRegistryFilename();
+	if( sRegPath.empty() )
+		return false;
+	
+	std::string sRegistryContents = Path_ReadTextFile( sRegPath );
+	if( sRegistryContents.empty() )
+		return false;
+
+	sJsonString = sRegistryContents;
+
+	return true;
+}
+
+// Mozilla: see mozilla.patch for more details
+// ---------------------------------------------------------------------------
+// Purpose: Loads the config file from its well known location
+// ---------------------------------------------------------------------------
+bool CVRPathRegistry_Public::BLoadFromFile( std::string *psLoadError )
+{
+	std::string sRegPath = GetVRPathRegistryFilename();
+	if( sRegPath.empty() )
+	{
+		if ( psLoadError )
+		{
+			*psLoadError = "Unable to determine VR Path Registry filename";
+		}
+		return false;
+	}
+
+	std::string sRegistryContents = Path_ReadTextFile( sRegPath );
+	if( sRegistryContents.empty() )
+	{
+		if ( psLoadError )
+		{
+			*psLoadError = "Unable to read VR Path Registry from " + sRegPath;
+		}
+		return false;
+	}
+
+	Json::Value root;
+	Json::CharReaderBuilder builder;
+	std::istringstream istream( sRegistryContents );
+	std::string sErrors;
+
+// try
+	{
+		if ( !parseFromStream( builder, istream, &root, &sErrors ) )
+		{
+			if ( psLoadError )
+			{
+				*psLoadError = "Unable to parse " + sRegPath + ": " + sErrors;
+			}
+			return false;
+		}
+
+		ParseStringListFromJson( &m_vecRuntimePath, root, "runtime" );
+		ParseStringListFromJson( &m_vecConfigPath, root, "config" );
+		ParseStringListFromJson( &m_vecLogPath, root, "log" );
+		if ( root.isMember( "external_drivers" ) && root["external_drivers"].isArray() )
+		{
+			ParseStringListFromJson( &m_vecExternalDrivers, root, "external_drivers" );
+		}
+	}
+// catch ( ... )
+// {
+// 	if ( psLoadError )
+// 	{
+// 		*psLoadError = "Unable to parse " + sRegPath + ": exception thrown in JSON library";
+// 	}
+// 	return false;
+// }
+
+	return true;
+}
+
+
+// ---------------------------------------------------------------------------
+// Purpose: Saves the config file to its well known location
+// ---------------------------------------------------------------------------
+bool CVRPathRegistry_Public::BSaveToFile() const
+{
+	std::string sRegPath = GetVRPathRegistryFilename();
+	if( sRegPath.empty() )
+		return false;
+	
+	Json::Value root;
+	
+	root[ "version" ] = 1;
+	root[ "jsonid" ] = "vrpathreg";
+
+	StringListToJson( m_vecRuntimePath, root, "runtime" );
+	StringListToJson( m_vecConfigPath, root, "config" );
+	StringListToJson( m_vecLogPath, root, "log" );
+	StringListToJson( m_vecExternalDrivers, root, "external_drivers" );
+
+	Json::StreamWriterBuilder builder;
+	std::string sRegistryContents = Json::writeString( builder, root );
+
+	// make sure the directory we're writing into actually exists
+	std::string sRegDirectory = Path_StripFilename( sRegPath );
+	if( !BCreateDirectoryRecursive( sRegDirectory.c_str() ) )
+	{
+		VRLog( "Unable to create path registry directory %s\n", sRegDirectory.c_str() );
+		return false;
+	}
+
+	if( !Path_WriteStringToTextFile( sRegPath, sRegistryContents.c_str() ) )
+	{
+		VRLog( "Unable to write VR path registry to %s\n", sRegPath.c_str() );
+		return false;
+	}
+
+	return true;
+}
+
+
+// ---------------------------------------------------------------------------
+// Purpose: Returns the current runtime path or NULL if no path is configured.
+// ---------------------------------------------------------------------------
+std::string CVRPathRegistry_Public::GetRuntimePath() const
+{
+	if( m_vecRuntimePath.empty() )
+		return "";
+	else
+		return m_vecRuntimePath.front().c_str();
+}
+
+
+// ---------------------------------------------------------------------------
+// Purpose: Returns the current config path or NULL if no path is configured.
+// ---------------------------------------------------------------------------
+std::string CVRPathRegistry_Public::GetConfigPath() const
+{
+	if( m_vecConfigPath.empty() )
+		return "";
+	else
+		return m_vecConfigPath.front().c_str();
+}
+
+
+// ---------------------------------------------------------------------------
+// Purpose: Returns the current log path or NULL if no path is configured.
+// ---------------------------------------------------------------------------
+std::string CVRPathRegistry_Public::GetLogPath() const
+{
+	if( m_vecLogPath.empty() )
+		return "";
+	else
+		return m_vecLogPath.front().c_str();
+}
+
+
+
+// ---------------------------------------------------------------------------
+// Purpose: Returns paths using the path registry and the provided override 
+//			values. Pass NULL for any paths you don't care about.
+// ---------------------------------------------------------------------------
+bool CVRPathRegistry_Public::GetPaths( std::string *psRuntimePath, std::string *psConfigPath, std::string *psLogPath, const char *pchConfigPathOverride, const char *pchLogPathOverride, std::vector<std::string> *pvecExternalDrivers )
+{
+	std::string sLoadError;
+	CVRPathRegistry_Public pathReg;
+	bool bLoadedRegistry = pathReg.BLoadFromFile( &sLoadError );
+	int nCountEnvironmentVariables = 0;
+	int nRequestedPaths = 0;
+
+	if( psRuntimePath )
+	{
+		nRequestedPaths++;
+		if ( GetEnvironmentVariable( k_pchRuntimeOverrideVar ).length() != 0 )
+		{
+			*psRuntimePath = GetEnvironmentVariable( k_pchRuntimeOverrideVar );
+			nCountEnvironmentVariables++;
+		}
+		else if( !pathReg.GetRuntimePath().empty() )
+		{
+			*psRuntimePath = pathReg.GetRuntimePath();
+		}
+		else
+		{
+			*psRuntimePath = "";
+		}
+	}
+
+	if( psConfigPath )
+	{
+		nRequestedPaths++;
+		if ( GetEnvironmentVariable( k_pchConfigOverrideVar ).length() != 0 )
+		{
+			*psConfigPath = GetEnvironmentVariable( k_pchConfigOverrideVar );
+			nCountEnvironmentVariables++;
+		}
+		else if( pchConfigPathOverride )
+		{
+			*psConfigPath = pchConfigPathOverride;
+		}
+		else if( !pathReg.GetConfigPath().empty() )
+		{
+			*psConfigPath = pathReg.GetConfigPath();
+		}
+		else
+		{
+			*psConfigPath = "";
+		}
+	}
+
+	if( psLogPath )
+	{
+		nRequestedPaths++;
+		if ( GetEnvironmentVariable( k_pchLogOverrideVar ).length() != 0 )
+		{
+			*psLogPath = GetEnvironmentVariable( k_pchLogOverrideVar );
+			nCountEnvironmentVariables++;
+		}
+		else if( pchLogPathOverride )
+		{
+			*psLogPath = pchLogPathOverride;
+		}
+		else if( !pathReg.GetLogPath().empty() )
+		{
+			*psLogPath = pathReg.GetLogPath();
+		}
+		else
+		{
+			*psLogPath = "";
+		}
+	}
+
+	if ( pvecExternalDrivers )
+	{
+		*pvecExternalDrivers = pathReg.m_vecExternalDrivers;
+	}
+
+	if ( nCountEnvironmentVariables == nRequestedPaths )
+	{
+		// all three environment variables were set, so we don't need the physical file
+		return true;
+	}
+	else if( !bLoadedRegistry )
+	{
+		VRLog( "%s\n", sLoadError.c_str() );
+	}
+
+	return bLoadedRegistry;
+}
+
diff --git a/gfx/vr/service/openvr/src/vrpathregistry_public.h b/gfx/vr/service/openvr/src/vrpathregistry_public.h
new file mode 100644
index 0000000000..776935a011
--- /dev/null
+++ b/gfx/vr/service/openvr/src/vrpathregistry_public.h
@@ -0,0 +1,45 @@
+//========= Copyright Valve Corporation ============//
+#pragma once
+
+#include <string>
+#include <vector>
+#include <stdint.h>
+
+static const char *k_pchRuntimeOverrideVar = "VR_OVERRIDE";
+static const char *k_pchConfigOverrideVar = "VR_CONFIG_PATH";
+static const char *k_pchLogOverrideVar = "VR_LOG_PATH";
+
+class CVRPathRegistry_Public
+{
+public:
+	static std::string GetVRPathRegistryFilename();
+	static std::string GetOpenVRConfigPath();
+
+public:
+	CVRPathRegistry_Public();
+
+	/** Returns paths using the path registry and the provided override values. Pass NULL for any paths you don't care about. 
+	* Returns false if the path registry could not be read. Valid paths might still be returned based on environment variables. */
+	static bool GetPaths( std::string *psRuntimePath, std::string *psConfigPath, std::string *psLogPath, const char *pchConfigPathOverride, const char *pchLogPathOverride, std::vector<std::string> *pvecExternalDrivers = NULL );
+
+	bool BLoadFromFile( std::string *psError = nullptr );
+	bool BSaveToFile() const;
+
+	bool ToJsonString( std::string &sJsonString );
+
+	// methods to get the current values
+	std::string GetRuntimePath() const;
+	std::string GetConfigPath() const;
+	std::string GetLogPath() const;
+
+protected:
+	typedef std::vector< std::string > StringVector_t;
+
+	// index 0 is the current setting
+	StringVector_t m_vecRuntimePath;
+	StringVector_t m_vecLogPath;
+	StringVector_t m_vecConfigPath;
+
+	// full list of external drivers
+	StringVector_t m_vecExternalDrivers;
+};
diff --git a/gfx/vr/service/osvr/ClientKit/ClientKitC.h b/gfx/vr/service/osvr/ClientKit/ClientKitC.h
new file mode 100644
index 0000000000..8309e890d3
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/ClientKitC.h
@@ -0,0 +1,37 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_ClientKitC_h_GUID_8D7DF104_892D_4CB5_2302_7C6BB5BC985C
+#define INCLUDED_ClientKitC_h_GUID_8D7DF104_892D_4CB5_2302_7C6BB5BC985C
+
+#include <osvr/ClientKit/ContextC.h>
+#include <osvr/ClientKit/InterfaceC.h>
+#include <osvr/ClientKit/InterfaceCallbackC.h>
+#include <osvr/ClientKit/SystemCallbackC.h>
+
+#endif
diff --git a/gfx/vr/service/osvr/ClientKit/ContextC.h b/gfx/vr/service/osvr/ClientKit/ContextC.h
new file mode 100644
index 0000000000..e07e1b4a77
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/ContextC.h
@@ -0,0 +1,96 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @todo Apply annotation macros
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_ContextC_h_GUID_3790F330_2425_4486_4C9F_20C300D7DED3
+#define INCLUDED_ContextC_h_GUID_3790F330_2425_4486_4C9F_20C300D7DED3
+
+/* Internal Includes */
+#include <osvr/ClientKit/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/ReturnCodesC.h>
+#include <osvr/Util/AnnotationMacrosC.h>
+#include <osvr/Util/StdInt.h>
+#include <osvr/Util/ClientOpaqueTypesC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup ClientKit
+    @{
+*/
+
+/** @brief Initialize the library.
+
+    @param applicationIdentifier A null terminated string identifying your
+   application. Reverse DNS format strongly suggested.
+    @param flags initialization options (reserved) - pass 0 for now.
+
+    @returns Client context - will be needed for subsequent calls
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ClientContext osvrClientInit(
+    const char applicationIdentifier[], uint32_t flags OSVR_CPP_ONLY(= 0));
+
+/** @brief Updates the state of the context - call regularly in your mainloop.
+
+    @param ctx Client context
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientUpdate(OSVR_ClientContext ctx);
+
+/** @brief Checks to see if the client context is fully started up and connected
+    properly to a server.
+
+    If this reports that the client context is not OK, there may not be a server
+    running, or you may just have to call osvrClientUpdate() a few times to
+    permit startup to finish. The return value of this call will not change from
+    failure to success without calling osvrClientUpdate().
+
+    @param ctx Client context
+
+    @return OSVR_RETURN_FAILURE if not yet fully connected/initialized, or if
+    some other error (null context) occurs.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientCheckStatus(OSVR_ClientContext ctx);
+
+/** @brief Shutdown the library.
+    @param ctx Client context
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientShutdown(OSVR_ClientContext ctx);
+
+/** @} */
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/ClientKit/DisplayC.h b/gfx/vr/service/osvr/ClientKit/DisplayC.h
new file mode 100644
index 0000000000..fb11ca6b53
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/DisplayC.h
@@ -0,0 +1,506 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2015
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2015 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_DisplayC_h_GUID_8658EDC9_32A2_49A2_5F5C_10F67852AE74
+#define INCLUDED_DisplayC_h_GUID_8658EDC9_32A2_49A2_5F5C_10F67852AE74
+
+/* Internal Includes */
+#include <osvr/ClientKit/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/ReturnCodesC.h>
+#include <osvr/Util/ClientOpaqueTypesC.h>
+#include <osvr/Util/RenderingTypesC.h>
+#include <osvr/Util/MatrixConventionsC.h>
+#include <osvr/Util/Pose3C.h>
+#include <osvr/Util/BoolC.h>
+#include <osvr/Util/RadialDistortionParametersC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+/** @addtogroup ClientKit
+    @{
+    @name Display API
+    @{
+*/
+
+/** @brief Opaque type of a display configuration. */
+typedef struct OSVR_DisplayConfigObject* OSVR_DisplayConfig;
+
+/** @brief Allocates a display configuration object populated with data from the
+    OSVR system.
+
+    Before this call will succeed, your application will need to be correctly
+   and fully connected to an OSVR server. You may consider putting this call in
+   a loop alternating with osvrClientUpdate() until this call succeeds.
+
+    Data provided by a display configuration object:
+
+    - The logical display topology (number and relationship of viewers, eyes,
+        and surfaces), which remains constant throughout the life of the
+        configuration object. (A method of notification of change here is TBD).
+    - Pose data for viewers (not required for rendering) and pose/view data for
+        eyes (used for rendering) which is based on tracker data: if used, these
+        should be queried every frame.
+    - Projection matrix data for surfaces, which while in current practice may
+        be relatively unchanging, we are not guaranteeing them to be constant:
+        these should be queried every frame.
+    - Video-input-relative viewport size/location for a surface: would like this
+        to be variable, but probably not feasible. If you have input, please
+        comment on the dev mailing list.
+    - Per-surface distortion strategy priorities/availabilities: constant. Note
+        the following, though...
+    - Per-surface distortion strategy parameters: variable, request each frame.
+        (Could make constant with a notification if needed?)
+
+    Important note: While most of this data is immediately available if you are
+   successful in getting a display config object, the pose-based data (viewer
+   pose, eye pose, eye view matrix) needs tracker state, so at least one (and in
+   practice, typically more) osvrClientUpdate() must be performed before a new
+   tracker report is available to populate that state. See
+   osvrClientCheckDisplayStartup() to query if all startup data is available.
+
+    @todo Decide if relative viewport should be constant in a display config,
+   and update docs accordingly.
+
+    @todo Decide if distortion params should be constant in a display config,
+   and update docs accordingly.
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed or some other
+    error occurred, in which case the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetDisplay(OSVR_ClientContext ctx, OSVR_DisplayConfig* disp);
+
+/** @brief Frees a display configuration object. The corresponding context must
+    still be open.
+
+    If you fail to call this, it will be automatically called as part of
+    clean-up when the corresponding context is closed.
+
+    @return OSVR_RETURN_FAILURE if a null config was passed, or if the given
+    display object was already freed.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientFreeDisplay(OSVR_DisplayConfig disp);
+
+/** @brief Checks to see if a display is fully configured and ready, including
+    having received its first pose update.
+
+    Once this first succeeds, it will continue to succeed for the lifetime of
+    the display config object, so it is not necessary to keep calling once you
+    get a successful result.
+
+    @return OSVR_RETURN_FAILURE if a null config was passed, or if the given
+    display config object was otherwise not ready for full use.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientCheckDisplayStartup(OSVR_DisplayConfig disp);
+
+/** @brief A display config can have one or more display inputs to pass pixels
+    over (HDMI/DVI connections, etc): retrieve the number of display inputs in
+   the current configuration.
+
+    @param disp Display config object.
+    @param[out] numDisplayInputs Number of display inputs in the logical display
+    topology, **constant** throughout the active, valid lifetime of a display
+    config object.
+
+    @sa OSVR_DisplayInputCount
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in
+   which case the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientGetNumDisplayInputs(
+    OSVR_DisplayConfig disp, OSVR_DisplayInputCount* numDisplayInputs);
+
+/** @brief Retrieve the pixel dimensions of a given display input for a display
+   config
+
+    @param disp Display config object.
+    @param displayInputIndex The zero-based index of the display input.
+    @param[out] width Width (in pixels) of the display input.
+    @param[out] height Height (in pixels) of the display input.
+
+    The out parameters are **constant** throughout the active, valid lifetime of
+    a display config object.
+
+    @sa OSVR_DisplayDimension
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in
+   which case the output arguments are unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientGetDisplayDimensions(
+    OSVR_DisplayConfig disp, OSVR_DisplayInputCount displayInputIndex,
+    OSVR_DisplayDimension* width, OSVR_DisplayDimension* height);
+
+/** @brief A display config can have one (or theoretically more) viewers:
+    retrieve the viewer count.
+
+    @param disp Display config object.
+    @param[out] viewers Number of viewers in the logical display topology,
+    **constant** throughout the active, valid lifetime of a display config
+    object.
+
+    @sa OSVR_ViewerCount
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+   the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetNumViewers(OSVR_DisplayConfig disp, OSVR_ViewerCount* viewers);
+
+/** @brief Get the pose of a viewer in a display config.
+
+    Note that there may not necessarily be any surfaces rendered from this pose
+    (it's the unused "center" eye in a stereo configuration, for instance) so
+    only use this if it makes integration into your engine or existing
+    applications (not originally designed for stereo) easier.
+
+    Will only succeed if osvrClientCheckDisplayStartup() succeeds.
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed or no pose was
+    yet available, in which case the pose argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientGetViewerPose(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_Pose3* pose);
+
+/** @brief Each viewer in a display config can have one or more "eyes" which
+    have a substantially similar pose: get the count.
+
+    @param disp Display config object.
+    @param viewer Viewer ID
+    @param[out] eyes Number of eyes for this viewer in the logical display
+   topology, **constant** throughout the active, valid lifetime of a display
+   config object
+
+    @sa OSVR_EyeCount
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+    the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientGetNumEyesForViewer(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount* eyes);
+
+/** @brief Get the "viewpoint" for the given eye of a viewer in a display
+   config.
+
+    Will only succeed if osvrClientCheckDisplayStartup() succeeds.
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param[out] pose Room-space pose (not relative to pose of the viewer)
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed or no pose was
+    yet available, in which case the pose argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetViewerEyePose(OSVR_DisplayConfig disp, OSVR_ViewerCount viewer,
+                           OSVR_EyeCount eye, OSVR_Pose3* pose);
+
+/** @brief Get the view matrix (inverse of pose) for the given eye of a
+    viewer in a display config - matrix of **doubles**.
+
+    Will only succeed if osvrClientCheckDisplayStartup() succeeds.
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param flags Bitwise OR of matrix convention flags (see @ref MatrixFlags)
+    @param[out] mat Pass a double[::OSVR_MATRIX_SIZE] to get the transformation
+    matrix from room space to eye space (not relative to pose of the viewer)
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed or no pose was
+    yet available, in which case the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientGetViewerEyeViewMatrixd(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_MatrixConventions flags, double* mat);
+
+/** @brief Get the view matrix (inverse of pose) for the given eye of a
+    viewer in a display config - matrix of **floats**.
+
+    Will only succeed if osvrClientCheckDisplayStartup() succeeds.
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param flags Bitwise OR of matrix convention flags (see @ref MatrixFlags)
+    @param[out] mat Pass a float[::OSVR_MATRIX_SIZE] to get the transformation
+    matrix from room space to eye space (not relative to pose of the viewer)
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed or no pose was
+    yet available, in which case the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientGetViewerEyeViewMatrixf(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_MatrixConventions flags, float* mat);
+
+/** @brief Each eye of each viewer in a display config has one or more surfaces
+    (aka "screens") on which content should be rendered.
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param[out] surfaces Number of surfaces (numbered [0, surfaces - 1]) for the
+    given viewer and eye. **Constant** throughout the active, valid lifetime of
+    a display config object.
+
+    @sa OSVR_SurfaceCount
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+    the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientGetNumSurfacesForViewerEye(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount* surfaces);
+
+/** @brief Get the dimensions/location of the viewport **within the display
+    input** for a surface seen by an eye of a viewer in a display config. (This
+    does not include other video inputs that may be on a single virtual desktop,
+    etc. or explicitly account for display configurations that use multiple
+    video inputs. It does not necessarily indicate that a viewport in the sense
+    of glViewport must be created with these parameters, though the parameter
+    order matches for convenience.)
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param surface Surface ID
+    @param[out] left Output: Distance in pixels from the left of the video input
+    to the left of the viewport.
+    @param[out] bottom Output: Distance in pixels from the bottom of the video
+    input to the bottom of the viewport.
+    @param[out] width Output: Width of viewport in pixels.
+    @param[out] height Output: Height of viewport in pixels.
+
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+    the output arguments are unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetRelativeViewportForViewerEyeSurface(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, OSVR_ViewportDimension* left,
+    OSVR_ViewportDimension* bottom, OSVR_ViewportDimension* width,
+    OSVR_ViewportDimension* height);
+
+/** @brief Get the index of the display input for a surface seen by an eye of a
+   viewer in a display config.
+
+    This is the OSVR-assigned display input: it may not (and in practice,
+    usually will not) match any platform-specific display indices. This function
+    exists to associate surfaces with video inputs as enumerated by
+    osvrClientGetNumDisplayInputs().
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param surface Surface ID
+    @param[out] displayInput Zero-based index of the display input pixels for
+    this surface are tranmitted over.
+
+    This association is **constant** throughout the active, valid lifetime of a
+    display config object.
+
+    @sa osvrClientGetNumDisplayInputs(),
+    osvrClientGetRelativeViewportForViewerEyeSurface()
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which
+    case the output argument is unmodified.
+ */
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetViewerEyeSurfaceDisplayInputIndex(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, OSVR_DisplayInputCount* displayInput);
+
+/** @brief Get the projection matrix for a surface seen by an eye of a viewer
+    in a display config. (double version)
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param surface Surface ID
+    @param near Distance from viewpoint to near clipping plane - must be
+    positive.
+    @param far Distance from viewpoint to far clipping plane - must be positive
+    and not equal to near, typically greater than near.
+    @param flags Bitwise OR of matrix convention flags (see @ref MatrixFlags)
+    @param[out] matrix Output projection matrix: supply an array of 16
+    (::OSVR_MATRIX_SIZE) doubles.
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+    the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetViewerEyeSurfaceProjectionMatrixd(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, double near, double far,
+    OSVR_MatrixConventions flags, double* matrix);
+
+/** @brief Get the projection matrix for a surface seen by an eye of a viewer
+    in a display config. (float version)
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param surface Surface ID
+    @param near Distance to near clipping plane - must be nonzero, typically
+    positive.
+    @param far Distance to far clipping plane - must be nonzero, typically
+    positive and greater than near.
+    @param flags Bitwise OR of matrix convention flags (see @ref MatrixFlags)
+    @param[out] matrix Output projection matrix: supply an array of 16
+    (::OSVR_MATRIX_SIZE) floats.
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+    the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetViewerEyeSurfaceProjectionMatrixf(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, float near, float far,
+    OSVR_MatrixConventions flags, float* matrix);
+
+/** @brief Get the clipping planes (positions at unit distance) for a surface
+   seen by an eye of a viewer
+    in a display config.
+
+    This is only for use in integrations that cannot accept a fully-formulated
+    projection matrix as returned by
+    osvrClientGetViewerEyeSurfaceProjectionMatrixf() or
+    osvrClientGetViewerEyeSurfaceProjectionMatrixd(), and may not necessarily
+    provide the same optimizations.
+
+    As all the planes are given at unit (1) distance, before passing these
+   planes to a consuming function in your application/engine, you will typically
+   divide them by your near clipping plane distance.
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param surface Surface ID
+    @param[out] left Distance to left clipping plane
+    @param[out] right Distance to right clipping plane
+    @param[out] bottom Distance to bottom clipping plane
+    @param[out] top Distance to top clipping plane
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+    the output arguments are unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetViewerEyeSurfaceProjectionClippingPlanes(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, double* left, double* right, double* bottom,
+    double* top);
+
+/** @brief Determines if a surface seen by an eye of a viewer in a display
+    config requests some distortion to be performed.
+
+    This simply reports true or false, and does not specify which kind of
+    distortion implementations have been parameterized for this display. For
+    each distortion implementation your application supports, you'll want to
+    call the corresponding priority function to find out if it is available.
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param surface Surface ID
+    @param[out] distortionRequested Output parameter: whether distortion is
+    requested. **Constant** throughout the active, valid lifetime of a display
+    config object.
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+    the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientDoesViewerEyeSurfaceWantDistortion(OSVR_DisplayConfig disp,
+                                             OSVR_ViewerCount viewer,
+                                             OSVR_EyeCount eye,
+                                             OSVR_SurfaceCount surface,
+                                             OSVR_CBool* distortionRequested);
+
+/** @brief Returns the priority/availability of radial distortion parameters for
+    a surface seen by an eye of a viewer in a display config.
+
+    If osvrClientDoesViewerEyeSurfaceWantDistortion() reports false, then the
+    display does not request distortion of any sort, and thus neither this nor
+    any other distortion strategy priority function will report an "available"
+    priority.
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param surface Surface ID
+    @param[out] priority Output: the priority level. Negative values
+    (canonically OSVR_DISTORTION_PRIORITY_UNAVAILABLE) indicate this technique
+    not available, higher values indicate higher preference for the given
+    technique based on the device's description. **Constant** throughout the
+    active, valid lifetime of a display config object.
+
+    @return OSVR_RETURN_FAILURE if invalid parameters were passed, in which case
+    the output argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetViewerEyeSurfaceRadialDistortionPriority(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, OSVR_DistortionPriority* priority);
+
+/** @brief Returns the radial distortion parameters, if known/requested, for a
+    surface seen by an eye of a viewer in a display config.
+
+    Will only succeed if osvrClientGetViewerEyeSurfaceRadialDistortionPriority()
+    reports a non-negative priority.
+
+    @param disp Display config object
+    @param viewer Viewer ID
+    @param eye Eye ID
+    @param surface Surface ID
+    @param[out] params Output: the parameters for radial distortion
+
+    @return OSVR_RETURN_FAILURE if this surface does not have these parameters
+    described, or if invalid parameters were passed, in which case the output
+    argument is unmodified.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientGetViewerEyeSurfaceRadialDistortion(
+    OSVR_DisplayConfig disp, OSVR_ViewerCount viewer, OSVR_EyeCount eye,
+    OSVR_SurfaceCount surface, OSVR_RadialDistortionParameters* params);
+
+/** @}
+    @}
+*/
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/ClientKit/Export.h b/gfx/vr/service/osvr/ClientKit/Export.h
new file mode 100644
index 0000000000..eec95c2737
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/Export.h
@@ -0,0 +1,140 @@
+/** @file
+    @brief Automatically-generated export header - do not edit!
+
+    @date 2016
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+// Copyright 2016 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OSVR_CLIENTKIT_EXPORT_H
+#define OSVR_CLIENTKIT_EXPORT_H
+
+#ifdef OSVR_CLIENTKIT_STATIC_DEFINE
+#  define OSVR_CLIENTKIT_EXPORT
+#  define OSVR_CLIENTKIT_NO_EXPORT
+#endif
+
+/* Per-compiler advance preventative definition */
+#if defined(__BORLANDC__) || defined(__CODEGEARC__) || defined(__HP_aCC) || \
+    defined(__PGI) || defined(__WATCOMC__)
+/* Compilers that don't support deprecated, according to CMake. */
+#  ifndef OSVR_CLIENTKIT_DEPRECATED
+#    define OSVR_CLIENTKIT_DEPRECATED
+#  endif
+#endif
+
+/* Check for attribute support */
+#if defined(__INTEL_COMPILER)
+/* Checking before GNUC because Intel implements GNU extensions,
+ * so it chooses to define __GNUC__ as well. */
+#  if __INTEL_COMPILER >= 1200
+/* Intel compiler 12.0 or newer can handle these attributes per CMake */
+#    define OSVR_CLIENTKIT_EXPORT_HEADER_SUPPORTS_ATTRIBUTES
+#  endif
+
+#elif defined(__GNUC__)
+#  if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+/* GCC 4.2+ */
+#    define OSVR_CLIENTKIT_EXPORT_HEADER_SUPPORTS_ATTRIBUTES
+#  endif
+#endif
+
+/* Per-platform defines */
+#if defined(_MSC_VER)
+/* MSVC on Windows */
+
+#  ifndef OSVR_CLIENTKIT_EXPORT
+#    ifdef osvrClientKit_EXPORTS
+/* We are building this library */
+#      define OSVR_CLIENTKIT_EXPORT __declspec(dllexport)
+#    else
+/* We are using this library */
+#      define OSVR_CLIENTKIT_EXPORT __declspec(dllimport)
+#    endif
+#  endif
+
+#  ifndef OSVR_CLIENTKIT_DEPRECATED
+#    define OSVR_CLIENTKIT_DEPRECATED __declspec(deprecated)
+#  endif
+
+#elif defined(_WIN32) && defined(__GNUC__)
+/* GCC-compatible on Windows */
+
+#  ifndef OSVR_CLIENTKIT_EXPORT
+#    ifdef osvrClientKit_EXPORTS
+/* We are building this library */
+#      define OSVR_CLIENTKIT_EXPORT __attribute__((dllexport))
+#    else
+/* We are using this library */
+#      define OSVR_CLIENTKIT_EXPORT __attribute__((dllimport))
+#    endif
+#  endif
+
+#  ifndef OSVR_CLIENTKIT_DEPRECATED
+#    define OSVR_CLIENTKIT_DEPRECATED __attribute__((__deprecated__))
+#  endif
+
+#elif defined(OSVR_CLIENTKIT_EXPORT_HEADER_SUPPORTS_ATTRIBUTES) || \
+    (defined(__APPLE__) && defined(__MACH__))
+/* GCC4.2+ compatible (assuming something *nix-like) and Mac OS X */
+/* (The first macro is defined at the top of the file, if applicable) */
+/* see https://gcc.gnu.org/wiki/Visibility */
+
+#  ifndef OSVR_CLIENTKIT_EXPORT
+/* We are building/using this library */
+#    define OSVR_CLIENTKIT_EXPORT __attribute__((visibility("default")))
+#  endif
+
+#  ifndef OSVR_CLIENTKIT_NO_EXPORT
+#    define OSVR_CLIENTKIT_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+
+#  ifndef OSVR_CLIENTKIT_DEPRECATED
+#    define OSVR_CLIENTKIT_DEPRECATED __attribute__((__deprecated__))
+#  endif
+
+#endif
+/* End of platform ifdefs */
+
+/* fallback def */
+#ifndef OSVR_CLIENTKIT_EXPORT
+#  define OSVR_CLIENTKIT_EXPORT
+#endif
+
+/* fallback def */
+#ifndef OSVR_CLIENTKIT_NO_EXPORT
+#  define OSVR_CLIENTKIT_NO_EXPORT
+#endif
+
+/* fallback def */
+#ifndef OSVR_CLIENTKIT_DEPRECATED_EXPORT
+#  define OSVR_CLIENTKIT_DEPRECATED_EXPORT \
+    OSVR_CLIENTKIT_EXPORT OSVR_CLIENTKIT_DEPRECATED
+#endif
+
+/* fallback def */
+#ifndef OSVR_CLIENTKIT_DEPRECATED_NO_EXPORT
+#  define OSVR_CLIENTKIT_DEPRECATED_NO_EXPORT \
+    OSVR_CLIENTKIT_NO_EXPORT OSVR_CLIENTKIT_DEPRECATED
+#endif
+
+/* Clean up after ourselves */
+#undef OSVR_CLIENTKIT_EXPORT_HEADER_SUPPORTS_ATTRIBUTES
+
+#endif
diff --git a/gfx/vr/service/osvr/ClientKit/InterfaceC.h b/gfx/vr/service/osvr/ClientKit/InterfaceC.h
new file mode 100644
index 0000000000..a8523b1733
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/InterfaceC.h
@@ -0,0 +1,74 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_InterfaceC_h_GUID_D90BBAA6_AD62_499D_C023_2F6ED8987C17
+#define INCLUDED_InterfaceC_h_GUID_D90BBAA6_AD62_499D_C023_2F6ED8987C17
+
+/* Internal Includes */
+#include <osvr/ClientKit/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/ReturnCodesC.h>
+#include <osvr/Util/AnnotationMacrosC.h>
+#include <osvr/Util/ClientOpaqueTypesC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+/** @addtogroup ClientKit
+@{
+*/
+
+/** @brief Get the interface associated with the given path.
+    @param ctx Client context
+    @param path A resource path (null-terminated string)
+    @param[out] iface The interface object. May be freed when no longer needed,
+   otherwise it will be freed when the context is closed.
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrClientGetInterface(
+    OSVR_ClientContext ctx, const char path[], OSVR_ClientInterface* iface);
+
+/** @brief Free an interface object before context closure.
+
+    @param ctx Client context
+    @param iface The interface object
+
+    @returns OSVR_RETURN_SUCCESS unless a null context or interface was passed
+   or the given interface was not found in the context (i.e. had already been
+   freed)
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientFreeInterface(OSVR_ClientContext ctx, OSVR_ClientInterface iface);
+
+/** @} */
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/ClientKit/InterfaceCallbackC.h b/gfx/vr/service/osvr/ClientKit/InterfaceCallbackC.h
new file mode 100644
index 0000000000..18e2c135a7
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/InterfaceCallbackC.h
@@ -0,0 +1,77 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_InterfaceCallbacksC_h_GUID_8F16E6CB_F998_4ABC_5B6B_4FC1E4B71BC9
+#define INCLUDED_InterfaceCallbacksC_h_GUID_8F16E6CB_F998_4ABC_5B6B_4FC1E4B71BC9
+
+/* Internal Includes */
+#include <osvr/ClientKit/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/ReturnCodesC.h>
+#include <osvr/Util/AnnotationMacrosC.h>
+#include <osvr/Util/ClientOpaqueTypesC.h>
+#include <osvr/Util/ClientCallbackTypesC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+#define OSVR_INTERFACE_CALLBACK_METHOD(TYPE)                          \
+  /** @brief Register a callback for TYPE reports on an interface */  \
+  OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrRegister##TYPE##Callback( \
+      OSVR_ClientInterface iface, OSVR_##TYPE##Callback cb, void* userdata);
+
+OSVR_INTERFACE_CALLBACK_METHOD(Pose)
+OSVR_INTERFACE_CALLBACK_METHOD(Position)
+OSVR_INTERFACE_CALLBACK_METHOD(Orientation)
+OSVR_INTERFACE_CALLBACK_METHOD(Velocity)
+OSVR_INTERFACE_CALLBACK_METHOD(LinearVelocity)
+OSVR_INTERFACE_CALLBACK_METHOD(AngularVelocity)
+OSVR_INTERFACE_CALLBACK_METHOD(Acceleration)
+OSVR_INTERFACE_CALLBACK_METHOD(LinearAcceleration)
+OSVR_INTERFACE_CALLBACK_METHOD(AngularAcceleration)
+OSVR_INTERFACE_CALLBACK_METHOD(Button)
+OSVR_INTERFACE_CALLBACK_METHOD(Analog)
+OSVR_INTERFACE_CALLBACK_METHOD(Imaging)
+OSVR_INTERFACE_CALLBACK_METHOD(Location2D)
+OSVR_INTERFACE_CALLBACK_METHOD(Direction)
+OSVR_INTERFACE_CALLBACK_METHOD(EyeTracker2D)
+OSVR_INTERFACE_CALLBACK_METHOD(EyeTracker3D)
+OSVR_INTERFACE_CALLBACK_METHOD(EyeTrackerBlink)
+OSVR_INTERFACE_CALLBACK_METHOD(NaviVelocity)
+OSVR_INTERFACE_CALLBACK_METHOD(NaviPosition)
+
+#undef OSVR_INTERFACE_CALLBACK_METHOD
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/ClientKit/InterfaceStateC.h b/gfx/vr/service/osvr/ClientKit/InterfaceStateC.h
new file mode 100644
index 0000000000..46d0b60393
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/InterfaceStateC.h
@@ -0,0 +1,79 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_InterfaceStateC_h_GUID_8F85D178_74B9_4AA9_4E9E_243089411408
+#define INCLUDED_InterfaceStateC_h_GUID_8F85D178_74B9_4AA9_4E9E_243089411408
+
+/* Internal Includes */
+#include <osvr/ClientKit/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/ReturnCodesC.h>
+#include <osvr/Util/AnnotationMacrosC.h>
+#include <osvr/Util/ClientOpaqueTypesC.h>
+#include <osvr/Util/ClientReportTypesC.h>
+#include <osvr/Util/TimeValueC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+#define OSVR_CALLBACK_METHODS(TYPE)                                      \
+  /** @brief Get TYPE state from an interface, returning failure if none \
+   * exists */                                                           \
+  OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode osvrGet##TYPE##State(            \
+      OSVR_ClientInterface iface, struct OSVR_TimeValue* timestamp,      \
+      OSVR_##TYPE##State* state);
+
+OSVR_CALLBACK_METHODS(Pose)
+OSVR_CALLBACK_METHODS(Position)
+OSVR_CALLBACK_METHODS(Orientation)
+OSVR_CALLBACK_METHODS(Velocity)
+OSVR_CALLBACK_METHODS(LinearVelocity)
+OSVR_CALLBACK_METHODS(AngularVelocity)
+OSVR_CALLBACK_METHODS(Acceleration)
+OSVR_CALLBACK_METHODS(LinearAcceleration)
+OSVR_CALLBACK_METHODS(AngularAcceleration)
+OSVR_CALLBACK_METHODS(Button)
+OSVR_CALLBACK_METHODS(Analog)
+OSVR_CALLBACK_METHODS(Location2D)
+OSVR_CALLBACK_METHODS(Direction)
+OSVR_CALLBACK_METHODS(EyeTracker2D)
+OSVR_CALLBACK_METHODS(EyeTracker3D)
+OSVR_CALLBACK_METHODS(EyeTrackerBlink)
+OSVR_CALLBACK_METHODS(NaviVelocity)
+OSVR_CALLBACK_METHODS(NaviPosition)
+
+#undef OSVR_CALLBACK_METHODS
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/ClientKit/SystemCallbackC.h b/gfx/vr/service/osvr/ClientKit/SystemCallbackC.h
new file mode 100644
index 0000000000..2476d5f21c
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/SystemCallbackC.h
@@ -0,0 +1,47 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_SystemCallbackC_h_GUID_543F3F04_343E_4389_08A0_DEA988EC23F7
+#define INCLUDED_SystemCallbackC_h_GUID_543F3F04_343E_4389_08A0_DEA988EC23F7
+
+/* Internal Includes */
+#include <osvr/ClientKit/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/ReturnCodesC.h>
+#include <osvr/Util/AnnotationMacrosC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/ClientKit/TransformsC.h b/gfx/vr/service/osvr/ClientKit/TransformsC.h
new file mode 100644
index 0000000000..183497dfd8
--- /dev/null
+++ b/gfx/vr/service/osvr/ClientKit/TransformsC.h
@@ -0,0 +1,75 @@
+/** @file
+    @brief Header controlling the OSVR transformation hierarchy
+
+    Must be c-safe!
+
+    @date 2015
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2015 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_TransformsC_h_GUID_5B5B7438_42D4_4095_E48A_90E2CC13498E
+#define INCLUDED_TransformsC_h_GUID_5B5B7438_42D4_4095_E48A_90E2CC13498E
+
+/* Internal Includes */
+#include <osvr/ClientKit/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/ReturnCodesC.h>
+#include <osvr/Util/ClientOpaqueTypesC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup ClientKit
+    @{
+*/
+
+/** @brief Updates the internal "room to world" transformation (applied to all
+    tracker data for this client context instance) based on the user's head
+    orientation, so that the direction the user is facing becomes -Z to your
+    application. Only rotates about the Y axis (yaw).
+
+    Note that this method internally calls osvrClientUpdate() to get a head pose
+    so your callbacks may be called during its execution!
+
+    @param ctx Client context
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientSetRoomRotationUsingHead(OSVR_ClientContext ctx);
+
+/** @brief Clears/resets the internal "room to world" transformation back to an
+   identity transformation - that is, clears the effect of any other
+   manipulation of the room to world transform.
+
+    @param ctx Client context
+*/
+OSVR_CLIENTKIT_EXPORT OSVR_ReturnCode
+osvrClientClearRoomToWorldTransform(OSVR_ClientContext ctx);
+
+/** @} */
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/APIBaseC.h b/gfx/vr/service/osvr/Util/APIBaseC.h
new file mode 100644
index 0000000000..5d133f5c52
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/APIBaseC.h
@@ -0,0 +1,50 @@
+/** @file
+    @brief Header providing basic C macros for defining API headers.
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_APIBaseC_h_GUID_C5A2E769_2ADC_429E_D250_DF0883E6E5DB
+#define INCLUDED_APIBaseC_h_GUID_C5A2E769_2ADC_429E_D250_DF0883E6E5DB
+
+#ifdef __cplusplus
+#  define OSVR_C_ONLY(X)
+#  define OSVR_CPP_ONLY(X) X
+#  define OSVR_EXTERN_C_BEGIN extern "C" {
+#  define OSVR_EXTERN_C_END }
+#  define OSVR_INLINE inline
+#else
+#  define OSVR_C_ONLY(X) X
+#  define OSVR_CPP_ONLY(X)
+#  define OSVR_EXTERN_C_BEGIN
+#  define OSVR_EXTERN_C_END
+#  ifdef _MSC_VER
+#    define OSVR_INLINE static __inline
+#  else
+#    define OSVR_INLINE static inline
+#  endif
+#endif
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/AnnotationMacrosC.h b/gfx/vr/service/osvr/Util/AnnotationMacrosC.h
new file mode 100644
index 0000000000..6ce645840c
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/AnnotationMacrosC.h
@@ -0,0 +1,232 @@
+/** @file
+    @brief Header containing macros for source-level annotation.
+
+    In theory, supporting MSVC SAL, as well as compatible GCC and
+    Clang attributes. In practice, expanded as time allows and requires.
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_AnnotationMacrosC_h_GUID_48538D9B_35E3_4E9A_D2B0_D83D51DD5900
+#define INCLUDED_AnnotationMacrosC_h_GUID_48538D9B_35E3_4E9A_D2B0_D83D51DD5900
+
+#ifndef OSVR_DISABLE_ANALYSIS
+
+#  if defined(_MSC_VER) && (_MSC_VER >= 1700)
+/* Visual C++ (2012 and newer) */
+/* Using SAL attribute format:
+ * http://msdn.microsoft.com/en-us/library/ms182032(v=vs.120).aspx */
+
+#    include <sal.h>
+
+#    define OSVR_IN _In_
+#    define OSVR_IN_PTR _In_
+#    define OSVR_IN_OPT _In_opt_
+#    define OSVR_IN_STRZ _In_z_
+#    define OSVR_IN_READS(NUM_ELEMENTS) _In_reads_(NUM_ELEMENTS)
+
+#    define OSVR_OUT _Out_
+#    define OSVR_OUT_PTR _Outptr_
+#    define OSVR_OUT_OPT _Out_opt_
+
+#    define OSVR_INOUT _Inout_
+#    define OSVR_INOUT_PTR _Inout_
+
+#    define OSVR_RETURN_WARN_UNUSED _Must_inspect_result_
+#    define OSVR_RETURN_SUCCESS_CONDITION(X) _Return_type_success_(X)
+
+/* end of msvc section */
+#  elif defined(__GNUC__) && (__GNUC__ >= 4)
+/* section for GCC and GCC-alikes */
+
+#    if defined(__clang__)
+/* clang-specific section */
+#    endif
+
+#    define OSVR_FUNC_NONNULL(X) __attribute__((__nonnull__ X))
+#    define OSVR_RETURN_WARN_UNUSED __attribute__((warn_unused_result))
+
+/* end of gcc section and compiler detection */
+#  endif
+
+/* end of ndef disable analysis */
+#endif
+
+/* Fallback declarations */
+/**
+@defgroup annotation_macros Static analysis annotation macros
+@brief Wrappers for Microsoft's SAL annotations and others
+@ingroup Util
+
+Use of these is optional, but recommended particularly for C APIs,
+as well as any methods handling a buffer with a length.
+@{
+*/
+/** @name Parameter annotations
+
+    These indicate the role and valid values for parameters to functions.
+
+    At most one of these should be placed before a parameter's type name in the
+   function parameter list, in both the declaration and definition. (They must
+   match!)
+   @{
+*/
+/** @def OSVR_IN
+    @brief Indicates a required function parameter that serves only as input.
+*/
+#ifndef OSVR_IN
+#  define OSVR_IN
+#endif
+
+/** @def OSVR_IN_PTR
+    @brief Indicates a required pointer (non-null) function parameter that
+    serves only as input.
+*/
+#ifndef OSVR_IN_PTR
+#  define OSVR_IN_PTR
+#endif
+
+/** @def OSVR_IN_OPT
+    @brief Indicates a function parameter (pointer) that serves only as input,
+   but is optional and might be NULL.
+*/
+#ifndef OSVR_IN_OPT
+#  define OSVR_IN_OPT
+#endif
+
+/** @def OSVR_IN_STRZ
+    @brief Indicates a null-terminated string function parameter that serves
+   only as input.
+*/
+#ifndef OSVR_IN_STRZ
+#  define OSVR_IN_STRZ
+#endif
+
+/** @def OSVR_IN_READS(NUM_ELEMENTS)
+    @brief Indicates a buffer containing input with the specified number of
+   elements.
+
+    The specified number of elements is typically the name of another parameter.
+*/
+#ifndef OSVR_IN_READS
+#  define OSVR_IN_READS(NUM_ELEMENTS)
+#endif
+
+/** @def OSVR_OUT
+    @brief Indicates a required function parameter that serves only as output.
+    In C code, since this usually means "pointer", you probably want
+   OSVR_OUT_PTR instead.
+*/
+#ifndef OSVR_OUT
+#  define OSVR_OUT
+#endif
+
+/** @def OSVR_OUT_PTR
+    @brief Indicates a required pointer (non-null) function parameter that
+    serves only as output.
+*/
+#ifndef OSVR_OUT_PTR
+#  define OSVR_OUT_PTR
+#endif
+
+/** @def OSVR_OUT_OPT
+    @brief Indicates a function parameter (pointer) that serves only as output,
+   but is optional and might be NULL
+*/
+#ifndef OSVR_OUT_OPT
+#  define OSVR_OUT_OPT
+#endif
+
+/** @def OSVR_INOUT
+    @brief Indicates a required function parameter that is both read and written
+   to.
+
+    In C code, since this usually means "pointer", you probably want
+   OSVR_INOUT_PTR instead.
+*/
+#ifndef OSVR_INOUT
+#  define OSVR_INOUT
+#endif
+
+/** @def OSVR_INOUT_PTR
+    @brief Indicates a required pointer (non-null) function parameter that is
+    both read and written to.
+*/
+#ifndef OSVR_INOUT_PTR
+#  define OSVR_INOUT_PTR
+#endif
+
+/* End of parameter annotations. */
+/** @} */
+
+/** @name Function annotations
+
+    These indicate particular relevant aspects about a function. Some
+    duplicate the effective meaning of parameter annotations: applying both
+    allows the fullest extent of static analysis tools to analyze the code,
+    and in some compilers, generate warnings.
+
+   @{
+*/
+/** @def OSVR_FUNC_NONNULL(X)
+    @brief Indicates the parameter(s) that must be non-null.
+
+    @param X A parenthesized list of parameters by number (1-based index)
+
+    Should be placed after a function declaration (but before the
+   semicolon). Repeating in the definition is not needed.
+*/
+#ifndef OSVR_FUNC_NONNULL
+#  define OSVR_FUNC_NONNULL(X)
+#endif
+
+/** @def OSVR_RETURN_WARN_UNUSED
+    @brief Indicates the function has a return value that must be used (either a
+   security problem or an obvious bug if not).
+
+    Should be placed before the return value (and virtual keyword, if
+   applicable) in both declaration and definition.
+*/
+#ifndef OSVR_RETURN_WARN_UNUSED
+#  define OSVR_RETURN_WARN_UNUSED
+#endif
+/* End of function annotations. */
+/** @} */
+
+/** @def OSVR_RETURN_SUCCESS_CONDITION
+    @brief Applied to a typedef, indicates the condition for `return` under
+   which a function returning it should be considered to have succeeded (thus
+   holding certain specifications).
+
+    Should be placed before the typename in a typedef, with the parameter
+   including the keyword `return` to substitute for the return value.
+*/
+#ifndef OSVR_RETURN_SUCCESS_CONDITION
+#  define OSVR_RETURN_SUCCESS_CONDITION(X)
+#endif
+
+/* End of annotation group. */
+/** @} */
+#endif
diff --git a/gfx/vr/service/osvr/Util/BoolC.h b/gfx/vr/service/osvr/Util/BoolC.h
new file mode 100644
index 0000000000..b50ec7cfd7
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/BoolC.h
@@ -0,0 +1,59 @@
+/** @file
+    @brief Header providing a C-safe "bool" type, because we can't depend on
+   Visual Studio providing proper C99 support in external-facing APIs.
+
+    Must be c-safe!
+
+    @date 2015
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2015 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_BoolC_h_GUID_4F97BE90_2758_4BA5_B0FC_0CA92DEBA210
+#define INCLUDED_BoolC_h_GUID_4F97BE90_2758_4BA5_B0FC_0CA92DEBA210
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/StdInt.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+/** @addtogroup Util
+@{
+*/
+
+/** @brief A pre-C99-safe bool type. Canonical values for true and false are
+ * provided. Interpretation of other values is not defined. */
+typedef uint8_t OSVR_CBool;
+/** @brief Canonical "true" value for OSVR_CBool */
+#define OSVR_TRUE (1)
+/** @brief Canonical "false" value for OSVR_CBool */
+#define OSVR_FALSE (0)
+
+/** @} */
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/ChannelCountC.h b/gfx/vr/service/osvr/Util/ChannelCountC.h
new file mode 100644
index 0000000000..dc49b3b171
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/ChannelCountC.h
@@ -0,0 +1,57 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2015
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2015 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_ChannelCountC_h_GUID_CF7E5EE7_28B0_4B99_E823_DD701904B5D1
+#define INCLUDED_ChannelCountC_h_GUID_CF7E5EE7_28B0_4B99_E823_DD701904B5D1
+
+/* Internal Includes */
+#include <osvr/Util/StdInt.h>
+#include <osvr/Util/APIBaseC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup PluginKit
+@{
+*/
+
+/** @brief The integer type specifying a number of channels/sensors or a
+channel/sensor index.
+*/
+typedef uint32_t OSVR_ChannelCount;
+
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/ClientCallbackTypesC.h b/gfx/vr/service/osvr/Util/ClientCallbackTypesC.h
new file mode 100644
index 0000000000..4a3c53e822
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/ClientCallbackTypesC.h
@@ -0,0 +1,140 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    GENERATED - do not edit by hand!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_ClientCallbackTypesC_h_GUID_4D43A675_C8A4_4BBF_516F_59E6C785E4EF
+#define INCLUDED_ClientCallbackTypesC_h_GUID_4D43A675_C8A4_4BBF_516F_59E6C785E4EF
+
+/* Internal Includes */
+#include <osvr/Util/ClientReportTypesC.h>
+#include <osvr/Util/ImagingReportTypesC.h>
+#include <osvr/Util/ReturnCodesC.h>
+#include <osvr/Util/TimeValueC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup ClientKit
+    @{
+*/
+
+/** @name Report callback types
+    @{
+*/
+
+/* generated file - do not edit! */
+/** @brief C function type for a Pose callback */
+typedef void (*OSVR_PoseCallback)(void* userdata,
+                                  const struct OSVR_TimeValue* timestamp,
+                                  const struct OSVR_PoseReport* report);
+/** @brief C function type for a Position callback */
+typedef void (*OSVR_PositionCallback)(void* userdata,
+                                      const struct OSVR_TimeValue* timestamp,
+                                      const struct OSVR_PositionReport* report);
+/** @brief C function type for a Orientation callback */
+typedef void (*OSVR_OrientationCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_OrientationReport* report);
+/** @brief C function type for a Velocity callback */
+typedef void (*OSVR_VelocityCallback)(void* userdata,
+                                      const struct OSVR_TimeValue* timestamp,
+                                      const struct OSVR_VelocityReport* report);
+/** @brief C function type for a LinearVelocity callback */
+typedef void (*OSVR_LinearVelocityCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_LinearVelocityReport* report);
+/** @brief C function type for a AngularVelocity callback */
+typedef void (*OSVR_AngularVelocityCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_AngularVelocityReport* report);
+/** @brief C function type for a Acceleration callback */
+typedef void (*OSVR_AccelerationCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_AccelerationReport* report);
+/** @brief C function type for a LinearAcceleration callback */
+typedef void (*OSVR_LinearAccelerationCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_LinearAccelerationReport* report);
+/** @brief C function type for a AngularAcceleration callback */
+typedef void (*OSVR_AngularAccelerationCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_AngularAccelerationReport* report);
+/** @brief C function type for a Button callback */
+typedef void (*OSVR_ButtonCallback)(void* userdata,
+                                    const struct OSVR_TimeValue* timestamp,
+                                    const struct OSVR_ButtonReport* report);
+/** @brief C function type for a Analog callback */
+typedef void (*OSVR_AnalogCallback)(void* userdata,
+                                    const struct OSVR_TimeValue* timestamp,
+                                    const struct OSVR_AnalogReport* report);
+/** @brief C function type for a Imaging callback */
+typedef void (*OSVR_ImagingCallback)(void* userdata,
+                                     const struct OSVR_TimeValue* timestamp,
+                                     const struct OSVR_ImagingReport* report);
+/** @brief C function type for a Location2D callback */
+typedef void (*OSVR_Location2DCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_Location2DReport* report);
+/** @brief C function type for a Direction callback */
+typedef void (*OSVR_DirectionCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_DirectionReport* report);
+/** @brief C function type for a EyeTracker2D callback */
+typedef void (*OSVR_EyeTracker2DCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_EyeTracker2DReport* report);
+/** @brief C function type for a EyeTracker3D callback */
+typedef void (*OSVR_EyeTracker3DCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_EyeTracker3DReport* report);
+/** @brief C function type for a EyeTrackerBlink callback */
+typedef void (*OSVR_EyeTrackerBlinkCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_EyeTrackerBlinkReport* report);
+/** @brief C function type for a NaviVelocity callback */
+typedef void (*OSVR_NaviVelocityCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_NaviVelocityReport* report);
+/** @brief C function type for a NaviPosition callback */
+typedef void (*OSVR_NaviPositionCallback)(
+    void* userdata, const struct OSVR_TimeValue* timestamp,
+    const struct OSVR_NaviPositionReport* report);
+
+/** @} */
+
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/ClientOpaqueTypesC.h b/gfx/vr/service/osvr/Util/ClientOpaqueTypesC.h
new file mode 100644
index 0000000000..84203bb0d4
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/ClientOpaqueTypesC.h
@@ -0,0 +1,69 @@
+/** @file
+    @brief Header declaring opaque types used by @ref Client and @ref ClientKit
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_ClientOpaqueTypesC_h_GUID_24B79ED2_5751_4BA2_1690_BBD250EBC0C1
+#define INCLUDED_ClientOpaqueTypesC_h_GUID_24B79ED2_5751_4BA2_1690_BBD250EBC0C1
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup ClientKit
+    @{
+*/
+/** @brief Opaque handle that should be retained by your application. You need
+    only and exactly one.
+
+    Created by osvrClientInit() at application start.
+
+    You are required to clean up this handle with osvrClientShutdown().
+*/
+typedef struct OSVR_ClientContextObject* OSVR_ClientContext;
+
+/** @brief Opaque handle to an interface used for registering callbacks and
+   getting status.
+
+    You are not required to clean up this handle (it will be automatically
+   cleaned up when the context is), but you can if you are no longer using it,
+   using osvrClientFreeInterface() to inform the context that you no longer need
+   this interface.
+*/
+typedef struct OSVR_ClientInterfaceObject* OSVR_ClientInterface;
+
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/ClientReportTypesC.h b/gfx/vr/service/osvr/Util/ClientReportTypesC.h
new file mode 100644
index 0000000000..09769d2462
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/ClientReportTypesC.h
@@ -0,0 +1,348 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_ClientReportTypesC_h_GUID_E79DAB07_78B7_4795_1EB9_CA6EEB274AEE
+#define INCLUDED_ClientReportTypesC_h_GUID_E79DAB07_78B7_4795_1EB9_CA6EEB274AEE
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/Pose3C.h>
+#include <osvr/Util/StdInt.h>
+
+#include <osvr/Util/Vec2C.h>
+#include <osvr/Util/Vec3C.h>
+#include <osvr/Util/ChannelCountC.h>
+#include <osvr/Util/BoolC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup ClientKit
+    @{
+*/
+
+/** @name State types
+@{
+*/
+/** @brief Type of position state */
+typedef OSVR_Vec3 OSVR_PositionState;
+
+/** @brief Type of orientation state */
+typedef OSVR_Quaternion OSVR_OrientationState;
+
+/** @brief Type of pose state */
+typedef OSVR_Pose3 OSVR_PoseState;
+
+/** @brief Type of linear velocity state */
+typedef OSVR_Vec3 OSVR_LinearVelocityState;
+
+/** @brief The quaternion represents the incremental rotation taking place over
+    a period of dt seconds. Use of dt (which does not necessarily
+    have to be 1, as other velocity/acceleration representations imply) and an
+    incremental quaternion allows device reports to be scaled to avoid aliasing
+*/
+typedef struct OSVR_IncrementalQuaternion {
+  OSVR_Quaternion incrementalRotation;
+  double dt;
+} OSVR_IncrementalQuaternion;
+
+/** @brief Type of angular velocity state: an incremental quaternion, providing
+    the incremental rotation taking place due to velocity over a period of dt
+    seconds.
+*/
+typedef OSVR_IncrementalQuaternion OSVR_AngularVelocityState;
+
+/** @brief Struct for combined velocity state */
+typedef struct OSVR_VelocityState {
+  OSVR_LinearVelocityState linearVelocity;
+  /** @brief Whether the data source reports valid data for
+      #OSVR_VelocityState::linearVelocity */
+  OSVR_CBool linearVelocityValid;
+
+  OSVR_AngularVelocityState angularVelocity;
+  /** @brief Whether the data source reports valid data for
+  #OSVR_VelocityState::angularVelocity */
+  OSVR_CBool angularVelocityValid;
+} OSVR_VelocityState;
+
+/** @brief Type of linear acceleration state */
+typedef OSVR_Vec3 OSVR_LinearAccelerationState;
+
+/** @brief Type of angular acceleration state
+ */
+typedef OSVR_IncrementalQuaternion OSVR_AngularAccelerationState;
+
+/** @brief Struct for combined acceleration state */
+typedef struct OSVR_AccelerationState {
+  OSVR_LinearAccelerationState linearAcceleration;
+  /** @brief Whether the data source reports valid data for
+  #OSVR_AccelerationState::linearAcceleration */
+  OSVR_CBool linearAccelerationValid;
+
+  OSVR_AngularAccelerationState angularAcceleration;
+  /** @brief Whether the data source reports valid data for
+  #OSVR_AccelerationState::angularAcceleration */
+  OSVR_CBool angularAccelerationValid;
+} OSVR_AccelerationState;
+
+/** @brief Type of button state */
+typedef uint8_t OSVR_ButtonState;
+
+/** @brief OSVR_ButtonState value indicating "button down" */
+#define OSVR_BUTTON_PRESSED (1)
+
+/** @brief OSVR_ButtonState value indicating "button up" */
+#define OSVR_BUTTON_NOT_PRESSED (0)
+
+/** @brief Type of analog channel state */
+typedef double OSVR_AnalogState;
+
+/** @} */
+
+/** @name Report types
+    @{
+*/
+/** @brief Report type for a position callback on a tracker interface */
+typedef struct OSVR_PositionReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The position vector */
+  OSVR_PositionState xyz;
+} OSVR_PositionReport;
+
+/** @brief Report type for an orientation callback on a tracker interface */
+typedef struct OSVR_OrientationReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The rotation unit quaternion */
+  OSVR_OrientationState rotation;
+} OSVR_OrientationReport;
+
+/** @brief Report type for a pose (position and orientation) callback on a
+    tracker interface
+*/
+typedef struct OSVR_PoseReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The pose structure, containing a position vector and a rotation
+      quaternion
+  */
+  OSVR_PoseState pose;
+} OSVR_PoseReport;
+
+/** @brief Report type for a velocity (linear and angular) callback on a
+    tracker interface
+*/
+typedef struct OSVR_VelocityReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The data state - note that not all fields are neccesarily valid,
+      use the `Valid` members to check the status of the other fields.
+  */
+  OSVR_VelocityState state;
+} OSVR_VelocityReport;
+
+/** @brief Report type for a linear velocity callback on a tracker interface
+ */
+typedef struct OSVR_LinearVelocityReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The state itself */
+  OSVR_LinearVelocityState state;
+} OSVR_LinearVelocityReport;
+
+/** @brief Report type for an angular velocity callback on a tracker interface
+ */
+typedef struct OSVR_AngularVelocityReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The state itself */
+  OSVR_AngularVelocityState state;
+} OSVR_AngularVelocityReport;
+
+/** @brief Report type for an acceleration (linear and angular) callback on a
+    tracker interface
+*/
+typedef struct OSVR_AccelerationReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The data state - note that not all fields are neccesarily valid,
+      use the `Valid` members to check the status of the other fields.
+  */
+  OSVR_AccelerationState state;
+} OSVR_AccelerationReport;
+
+/** @brief Report type for a linear acceleration callback on a tracker interface
+ */
+typedef struct OSVR_LinearAccelerationReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The state itself */
+  OSVR_LinearAccelerationState state;
+} OSVR_LinearAccelerationReport;
+
+/** @brief Report type for an angular acceleration callback on a tracker
+    interface
+*/
+typedef struct OSVR_AngularAccelerationReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The state itself */
+  OSVR_AngularAccelerationState state;
+} OSVR_AngularAccelerationReport;
+
+/** @brief Report type for a callback on a button interface */
+typedef struct OSVR_ButtonReport {
+  /** @brief Identifies the sensor that the report comes from */
+  int32_t sensor;
+  /** @brief The button state: 1 is pressed, 0 is not pressed. */
+  OSVR_ButtonState state;
+} OSVR_ButtonReport;
+
+/** @brief Report type for a callback on an analog interface */
+typedef struct OSVR_AnalogReport {
+  /** @brief Identifies the sensor/channel that the report comes from */
+  int32_t sensor;
+  /** @brief The analog state. */
+  OSVR_AnalogState state;
+} OSVR_AnalogReport;
+
+/** @brief Type of location within a 2D region/surface, in normalized
+    coordinates (in range [0, 1] in standard OSVR coordinate system)
+*/
+typedef OSVR_Vec2 OSVR_Location2DState;
+
+/** @brief Report type for 2D location */
+typedef struct OSVR_Location2DReport {
+  OSVR_ChannelCount sensor;
+  OSVR_Location2DState location;
+} OSVR_Location2DReport;
+
+/** @brief Type of unit directional vector in 3D with no particular origin */
+typedef OSVR_Vec3 OSVR_DirectionState;
+
+/** @brief Report type for 3D Direction vector */
+typedef struct OSVR_DirectionReport {
+  OSVR_ChannelCount sensor;
+  OSVR_DirectionState direction;
+} OSVR_DirectionReport;
+
+/** @brief Type of eye gaze direction in 3D which contains 3D vector (position)
+    containing gaze base point of the user's respective eye in 3D device
+    coordinates.
+*/
+typedef OSVR_PositionState OSVR_EyeGazeBasePoint3DState;
+
+/** @brief Type of eye gaze position in 2D which contains users's gaze/point of
+    regard in normalized display coordinates (in range [0, 1] in standard OSVR
+    coordinate system)
+*/
+typedef OSVR_Location2DState OSVR_EyeGazePosition2DState;
+
+// typedef OSVR_DirectionState OSVR_EyeGazeBasePoint3DState;
+
+/** @brief Type of 3D vector (direction vector) containing the normalized gaze
+    direction of user's respective eye */
+typedef OSVR_DirectionState OSVR_EyeGazeDirectionState;
+
+/** @brief State for 3D gaze report */
+typedef struct OSVR_EyeTracker3DState {
+  OSVR_CBool directionValid;
+  OSVR_DirectionState direction;
+  OSVR_CBool basePointValid;
+  OSVR_PositionState basePoint;
+} OSVR_EyeTracker3DState;
+
+/** @brief Report type for 3D gaze report */
+typedef struct OSVR_EyeTracker3DReport {
+  OSVR_ChannelCount sensor;
+  OSVR_EyeTracker3DState state;
+} OSVR_EyeTracker3DReport;
+
+/** @brief State for 2D location report */
+typedef OSVR_Location2DState OSVR_EyeTracker2DState;
+
+/** @brief Report type for 2D location report */
+typedef struct OSVR_EyeTracker2DReport {
+  OSVR_ChannelCount sensor;
+  OSVR_EyeTracker2DState state;
+} OSVR_EyeTracker2DReport;
+
+/** @brief State for a blink event */
+typedef OSVR_ButtonState OSVR_EyeTrackerBlinkState;
+
+/** @brief OSVR_EyeTrackerBlinkState value indicating an eyes blink had occurred
+ */
+#define OSVR_EYE_BLINK (1)
+
+/** @brief OSVR_EyeTrackerBlinkState value indicating eyes are not blinking */
+#define OSVR_EYE_NO_BLINK (0)
+
+/** @brief Report type for a blink event */
+typedef struct OSVR_EyeTrackerBlinkReport {
+  OSVR_ChannelCount sensor;
+  OSVR_EyeTrackerBlinkState state;
+} OSVR_EyeTrackerBlinkReport;
+
+/** @brief Report type for an Imaging callback (forward declaration) */
+struct OSVR_ImagingReport;
+
+/** @brief Type of Navigation Velocity state */
+typedef OSVR_Vec2 OSVR_NaviVelocityState;
+
+/** @brief Type of Navigation Position state */
+typedef OSVR_Vec2 OSVR_NaviPositionState;
+
+/** @brief Report type for an navigation velocity callback on a tracker
+ * interface */
+typedef struct OSVR_NaviVelocityReport {
+  OSVR_ChannelCount sensor;
+  /** @brief The 2D vector in world coordinate system, in meters/second */
+  OSVR_NaviVelocityState state;
+} OSVR_NaviVelocityReport;
+
+/** @brief Report type for an navigation position callback on a tracker
+ * interface */
+typedef struct OSVR_NaviPositionReport {
+  OSVR_ChannelCount sensor;
+  /** @brief The 2D vector in world coordinate system, in meters, relative to
+   * starting position */
+  OSVR_NaviPositionState state;
+} OSVR_NaviPositionReport;
+
+/** @} */
+
+/** @} */
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/Export.h b/gfx/vr/service/osvr/Util/Export.h
new file mode 100644
index 0000000000..24e8d388df
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/Export.h
@@ -0,0 +1,139 @@
+/** @file
+    @brief Automatically-generated export header - do not edit!
+
+    @date 2016
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+// Copyright 2016 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef OSVR_UTIL_EXPORT_H
+#define OSVR_UTIL_EXPORT_H
+
+#ifdef OSVR_UTIL_STATIC_DEFINE
+#  define OSVR_UTIL_EXPORT
+#  define OSVR_UTIL_NO_EXPORT
+#endif
+
+/* Per-compiler advance preventative definition */
+#if defined(__BORLANDC__) || defined(__CODEGEARC__) || defined(__HP_aCC) || \
+    defined(__PGI) || defined(__WATCOMC__)
+/* Compilers that don't support deprecated, according to CMake. */
+#  ifndef OSVR_UTIL_DEPRECATED
+#    define OSVR_UTIL_DEPRECATED
+#  endif
+#endif
+
+/* Check for attribute support */
+#if defined(__INTEL_COMPILER)
+/* Checking before GNUC because Intel implements GNU extensions,
+ * so it chooses to define __GNUC__ as well. */
+#  if __INTEL_COMPILER >= 1200
+/* Intel compiler 12.0 or newer can handle these attributes per CMake */
+#    define OSVR_UTIL_EXPORT_HEADER_SUPPORTS_ATTRIBUTES
+#  endif
+
+#elif defined(__GNUC__)
+#  if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 2))
+/* GCC 4.2+ */
+#    define OSVR_UTIL_EXPORT_HEADER_SUPPORTS_ATTRIBUTES
+#  endif
+#endif
+
+/* Per-platform defines */
+#if defined(_MSC_VER)
+/* MSVC on Windows */
+
+#  ifndef OSVR_UTIL_EXPORT
+#    ifdef osvrUtil_EXPORTS
+/* We are building this library */
+#      define OSVR_UTIL_EXPORT __declspec(dllexport)
+#    else
+/* We are using this library */
+#      define OSVR_UTIL_EXPORT __declspec(dllimport)
+#    endif
+#  endif
+
+#  ifndef OSVR_UTIL_DEPRECATED
+#    define OSVR_UTIL_DEPRECATED __declspec(deprecated)
+#  endif
+
+#elif defined(_WIN32) && defined(__GNUC__)
+/* GCC-compatible on Windows */
+
+#  ifndef OSVR_UTIL_EXPORT
+#    ifdef osvrUtil_EXPORTS
+/* We are building this library */
+#      define OSVR_UTIL_EXPORT __attribute__((dllexport))
+#    else
+/* We are using this library */
+#      define OSVR_UTIL_EXPORT __attribute__((dllimport))
+#    endif
+#  endif
+
+#  ifndef OSVR_UTIL_DEPRECATED
+#    define OSVR_UTIL_DEPRECATED __attribute__((__deprecated__))
+#  endif
+
+#elif defined(OSVR_UTIL_EXPORT_HEADER_SUPPORTS_ATTRIBUTES) || \
+    (defined(__APPLE__) && defined(__MACH__))
+/* GCC4.2+ compatible (assuming something *nix-like) and Mac OS X */
+/* (The first macro is defined at the top of the file, if applicable) */
+/* see https://gcc.gnu.org/wiki/Visibility */
+
+#  ifndef OSVR_UTIL_EXPORT
+/* We are building/using this library */
+#    define OSVR_UTIL_EXPORT __attribute__((visibility("default")))
+#  endif
+
+#  ifndef OSVR_UTIL_NO_EXPORT
+#    define OSVR_UTIL_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+
+#  ifndef OSVR_UTIL_DEPRECATED
+#    define OSVR_UTIL_DEPRECATED __attribute__((__deprecated__))
+#  endif
+
+#endif
+/* End of platform ifdefs */
+
+/* fallback def */
+#ifndef OSVR_UTIL_EXPORT
+#  define OSVR_UTIL_EXPORT
+#endif
+
+/* fallback def */
+#ifndef OSVR_UTIL_NO_EXPORT
+#  define OSVR_UTIL_NO_EXPORT
+#endif
+
+/* fallback def */
+#ifndef OSVR_UTIL_DEPRECATED_EXPORT
+#  define OSVR_UTIL_DEPRECATED_EXPORT OSVR_UTIL_EXPORT OSVR_UTIL_DEPRECATED
+#endif
+
+/* fallback def */
+#ifndef OSVR_UTIL_DEPRECATED_NO_EXPORT
+#  define OSVR_UTIL_DEPRECATED_NO_EXPORT \
+    OSVR_UTIL_NO_EXPORT OSVR_UTIL_DEPRECATED
+#endif
+
+/* Clean up after ourselves */
+#undef OSVR_UTIL_EXPORT_HEADER_SUPPORTS_ATTRIBUTES
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/ImagingReportTypesC.h b/gfx/vr/service/osvr/Util/ImagingReportTypesC.h
new file mode 100644
index 0000000000..c3d1a1dee8
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/ImagingReportTypesC.h
@@ -0,0 +1,91 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2015
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2015 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_ImagingReportTypesC_h_GUID_746A7BF8_B92D_4585_CA72_DC5391DEDF24
+#define INCLUDED_ImagingReportTypesC_h_GUID_746A7BF8_B92D_4585_CA72_DC5391DEDF24
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/StdInt.h>
+#include <osvr/Util/ChannelCountC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup ClientKit
+    @{
+*/
+typedef uint32_t OSVR_ImageDimension;
+typedef uint8_t OSVR_ImageChannels;
+typedef uint8_t OSVR_ImageDepth;
+
+/** @brief Type for raw buffer access to image data */
+typedef unsigned char OSVR_ImageBufferElement;
+
+typedef enum OSVR_ImagingValueType {
+  OSVR_IVT_UNSIGNED_INT = 0,
+  OSVR_IVT_SIGNED_INT = 1,
+  OSVR_IVT_FLOATING_POINT = 2
+} OSVR_ImagingValueType;
+
+typedef struct OSVR_ImagingMetadata {
+  /** @brief height in pixels */
+  OSVR_ImageDimension height;
+  /** @brief width in pixels */
+  OSVR_ImageDimension width;
+  /** @brief number of channels of data for each pixel */
+  OSVR_ImageChannels channels;
+  /** @brief the depth (size) in bytes of each channel - valid values are 1,
+   * 2, 4, and 8 */
+  OSVR_ImageDepth depth;
+  /** @brief Whether values are unsigned ints, signed ints, or floating point
+   */
+  OSVR_ImagingValueType type;
+
+} OSVR_ImagingMetadata;
+
+typedef struct OSVR_ImagingState {
+  OSVR_ImagingMetadata metadata;
+  OSVR_ImageBufferElement* data;
+} OSVR_ImagingState;
+
+typedef struct OSVR_ImagingReport {
+  OSVR_ChannelCount sensor;
+  OSVR_ImagingState state;
+} OSVR_ImagingReport;
+
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/MatrixConventionsC.h b/gfx/vr/service/osvr/Util/MatrixConventionsC.h
new file mode 100644
index 0000000000..d9d31ef857
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/MatrixConventionsC.h
@@ -0,0 +1,190 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2015
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2015 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_MatrixConventionsC_h_GUID_6FC7A4C6_E6C5_4A96_1C28_C3D21B909681
+#define INCLUDED_MatrixConventionsC_h_GUID_6FC7A4C6_E6C5_4A96_1C28_C3D21B909681
+
+/* Internal Includes */
+#include <osvr/Util/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/StdInt.h>
+#include <osvr/Util/Pose3C.h>
+#include <osvr/Util/ReturnCodesC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @defgroup MatrixConvention Matrix conventions and bit flags
+    @ingroup UtilMath
+*/
+
+/** @brief Type for passing matrix convention flags.
+    @ingroup MatrixConvention
+*/
+typedef uint16_t OSVR_MatrixConventions;
+
+#ifndef OSVR_DOXYGEN_EXTERNAL
+/** @brief Bitmasks for testing matrix conventions.
+    @ingroup MatrixConvention
+*/
+typedef enum OSVR_MatrixMasks {
+  OSVR_MATRIX_MASK_ROWMAJOR = 0x1,
+  OSVR_MATRIX_MASK_ROWVECTORS = 0x2,
+  OSVR_MATRIX_MASK_LHINPUT = 0x4,
+  OSVR_MATRIX_MASK_UNSIGNEDZ = 0x8
+} OSVR_MatrixMasks;
+#endif
+
+/** @defgroup MatrixFlags Matrix flags
+    @ingroup MatrixConvention
+
+    Bit flags for specifying matrix options. Only one option may be specified
+   per enum, with all the specified options combined with bitwise-or `|`.
+
+    Most methods that take matrix flags only obey ::OSVR_MatrixOrderingFlags and
+   ::OSVR_MatrixVectorFlags - the flags that affect memory order. The remaining
+   flags are for use with projection matrix generation API methods.
+
+    @{
+*/
+/** @brief Flag bit controlling output memory order */
+typedef enum OSVR_MatrixOrderingFlags {
+  /** @brief Column-major memory order (default) */
+  OSVR_MATRIX_COLMAJOR = 0x0,
+  /** @brief Row-major memory order */
+  OSVR_MATRIX_ROWMAJOR = OSVR_MATRIX_MASK_ROWMAJOR
+} OSVR_MatrixOrderingFlags;
+
+/** @brief Flag bit controlling expected input to matrices.
+    (Related to ::OSVR_MatrixOrderingFlags - setting one to non-default results
+    in an output change, but setting both to non-default results in effectively
+    no change in the output. If this blows your mind, just ignore this aside and
+    carry on.)
+*/
+typedef enum OSVR_MatrixVectorFlags {
+  /** @brief Matrix transforms column vectors (default) */
+  OSVR_MATRIX_COLVECTORS = 0x0,
+  /** @brief Matrix transforms row vectors */
+  OSVR_MATRIX_ROWVECTORS = OSVR_MATRIX_MASK_ROWVECTORS
+} OSVR_MatrixVectorFlags;
+
+/** @brief Flag bit to indicate coordinate system input to projection matrix */
+typedef enum OSVR_ProjectionMatrixInputFlags {
+  /** @brief Matrix takes vectors from a right-handed coordinate system
+     (default) */
+  OSVR_MATRIX_RHINPUT = 0x0,
+  /** @brief Matrix takes vectors from a left-handed coordinate system */
+  OSVR_MATRIX_LHINPUT = OSVR_MATRIX_MASK_LHINPUT
+
+} OSVR_ProjectionMatrixInputFlags;
+
+/** @brief Flag bit to indicate the desired post-projection Z value convention
+ */
+typedef enum OSVR_ProjectionMatrixZFlags {
+  /** @brief Matrix maps the near and far planes to signed Z values (in the
+      range [-1, 1])  (default)*/
+  OSVR_MATRIX_SIGNEDZ = 0x0,
+  /** @brief Matrix maps the near and far planes to unsigned Z values (in the
+      range [0, 1]) */
+  OSVR_MATRIX_UNSIGNEDZ = OSVR_MATRIX_MASK_UNSIGNEDZ
+} OSVR_ProjectionMatrixZFlags;
+/** @} */ /* end of matrix flags group */
+
+enum {
+  /** @brief Constant for the number of elements in the matrices we use - 4x4.
+      @ingroup MatrixConvention
+  */
+  OSVR_MATRIX_SIZE = 16
+};
+
+/** @addtogroup UtilMath
+    @{
+*/
+/** @brief Set a matrix of doubles based on a Pose3.
+    @param pose The Pose3 to convert
+    @param flags Memory ordering flag - see @ref MatrixFlags
+    @param[out] mat an array of 16 doubles
+*/
+OSVR_UTIL_EXPORT OSVR_ReturnCode osvrPose3ToMatrixd(
+    OSVR_Pose3 const* pose, OSVR_MatrixConventions flags, double* mat);
+
+/** @brief Set a matrix of floats based on a Pose3.
+    @param pose The Pose3 to convert
+    @param flags Memory ordering flag - see @ref MatrixFlags
+    @param[out] mat an array of 16 floats
+*/
+OSVR_UTIL_EXPORT OSVR_ReturnCode osvrPose3ToMatrixf(
+    OSVR_Pose3 const* pose, OSVR_MatrixConventions flags, float* mat);
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#ifdef __cplusplus
+/** @brief Set a matrix based on a Pose3. (C++-only overload - detecting scalar
+ * type) */
+inline OSVR_ReturnCode osvrPose3ToMatrix(OSVR_Pose3 const* pose,
+                                         OSVR_MatrixConventions flags,
+                                         double* mat) {
+  return osvrPose3ToMatrixd(pose, flags, mat);
+}
+
+/** @brief Set a matrix based on a Pose3. (C++-only overload - detecting scalar
+ * type) */
+inline OSVR_ReturnCode osvrPose3ToMatrix(OSVR_Pose3 const* pose,
+                                         OSVR_MatrixConventions flags,
+                                         float* mat) {
+  return osvrPose3ToMatrixf(pose, flags, mat);
+}
+
+/** @brief Set a matrix based on a Pose3. (C++-only overload - detects scalar
+ * and takes array rather than pointer) */
+template <typename Scalar>
+inline OSVR_ReturnCode osvrPose3ToMatrix(OSVR_Pose3 const* pose,
+                                         OSVR_MatrixConventions flags,
+                                         Scalar mat[OSVR_MATRIX_SIZE]) {
+  return osvrPose3ToMatrix(pose, flags, &(mat[0]));
+}
+/** @brief Set a matrix based on a Pose3. (C++-only overload - detects scalar,
+ * takes array, takes pose by reference) */
+template <typename Scalar>
+inline OSVR_ReturnCode osvrPose3ToMatrix(OSVR_Pose3 const& pose,
+                                         OSVR_MatrixConventions flags,
+                                         Scalar mat[OSVR_MATRIX_SIZE]) {
+  return osvrPose3ToMatrix(&pose, flags, &(mat[0]));
+}
+
+#endif
+
+/** @} */
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/PlatformConfig.h b/gfx/vr/service/osvr/Util/PlatformConfig.h
new file mode 100644
index 0000000000..081712d3a3
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/PlatformConfig.h
@@ -0,0 +1,87 @@
+/** @file
+    @brief Auto-configured header
+
+    If this filename ends in `.h`, don't edit it: your edits will
+    be lost next time this file is regenerated!
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_PlatformConfig_h_GUID_0D10E644_8114_4294_A839_699F39E1F0E0
+#define INCLUDED_PlatformConfig_h_GUID_0D10E644_8114_4294_A839_699F39E1F0E0
+
+/** @def OSVR_HAVE_STRUCT_TIMEVAL_IN_WINSOCK2_H
+    @brief Does the system have struct timeval in <winsock2.h>?
+*/
+#define OSVR_HAVE_STRUCT_TIMEVAL_IN_WINSOCK2_H
+
+/** @def OSVR_HAVE_STRUCT_TIMEVAL_IN_SYS_TIME_H
+    @brief Does the system have struct timeval in <sys/time.h>?
+*/
+
+/*
+    MinGW and similar environments have both winsock and sys/time.h, so
+    we hide this define for disambiguation at the top level.
+*/
+#ifndef OSVR_HAVE_STRUCT_TIMEVAL_IN_WINSOCK2_H
+/* #undef OSVR_HAVE_STRUCT_TIMEVAL_IN_SYS_TIME_H */
+#endif
+
+#if defined(OSVR_HAVE_STRUCT_TIMEVAL_IN_SYS_TIME_H) || \
+    defined(OSVR_HAVE_STRUCT_TIMEVAL_IN_WINSOCK2_H)
+#  define OSVR_HAVE_STRUCT_TIMEVAL
+#endif
+
+/**
+ * Platform-specific variables.
+ *
+ * Prefer testing for specific compiler or platform features instead of relying
+ * on these variables.
+ *
+ */
+//@{
+/* #undef OSVR_AIX */
+/* #undef OSVR_ANDROID */
+/* #undef OSVR_BSDOS */
+/* #undef OSVR_FREEBSD */
+/* #undef OSVR_HPUX */
+/* #undef OSVR_IRIX */
+/* #undef OSVR_LINUX */
+/* #undef OSVR_KFREEBSD */
+/* #undef OSVR_NETBSD */
+/* #undef OSVR_OPENBSD */
+/* #undef OSVR_OFS1 */
+/* #undef OSVR_SCO_SV */
+/* #undef OSVR_UNIXWARE */
+/* #undef OSVR_XENIX */
+/* #undef OSVR_SUNOS */
+/* #undef OSVR_TRU64 */
+/* #undef OSVR_ULTRIX */
+/* #undef OSVR_CYGWIN */
+/* #undef OSVR_MACOSX */
+#define OSVR_WINDOWS
+//@}
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/Pose3C.h b/gfx/vr/service/osvr/Util/Pose3C.h
new file mode 100644
index 0000000000..cf56e7cc53
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/Pose3C.h
@@ -0,0 +1,70 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_Pose3C_h_GUID_066CFCE2_229C_4194_5D2B_2602CCD5C439
+#define INCLUDED_Pose3C_h_GUID_066CFCE2_229C_4194_5D2B_2602CCD5C439
+
+/* Internal Includes */
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/Vec3C.h>
+#include <osvr/Util/QuaternionC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup UtilMath
+    @{
+*/
+
+/** @brief A structure defining a 3D (6DOF) rigid body pose: translation and
+    rotation.
+*/
+typedef struct OSVR_Pose3 {
+  /** @brief Position vector */
+  OSVR_Vec3 translation;
+  /** @brief Orientation as a unit quaternion */
+  OSVR_Quaternion rotation;
+} OSVR_Pose3;
+
+/** @brief Set a pose to identity */
+OSVR_INLINE void osvrPose3SetIdentity(OSVR_Pose3* pose) {
+  osvrQuatSetIdentity(&(pose->rotation));
+  osvrVec3Zero(&(pose->translation));
+}
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/QuaternionC.h b/gfx/vr/service/osvr/Util/QuaternionC.h
new file mode 100644
index 0000000000..065c68bd4e
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/QuaternionC.h
@@ -0,0 +1,92 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_QuaternionC_h_GUID_1470A5FE_8209_41A6_C19E_46077FDF9C66
+#define INCLUDED_QuaternionC_h_GUID_1470A5FE_8209_41A6_C19E_46077FDF9C66
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup UtilMath
+    @{
+*/
+/** @brief A structure defining a quaternion, often a unit quaternion
+ * representing 3D rotation.
+ */
+typedef struct OSVR_Quaternion {
+  /** @brief Internal data - direct access not recommended */
+  double data[4];
+} OSVR_Quaternion;
+
+#define OSVR_QUAT_MEMBER(COMPONENT, INDEX)                                  \
+  /** @brief Accessor for quaternion component COMPONENT */                 \
+  OSVR_INLINE double osvrQuatGet##COMPONENT(OSVR_Quaternion const* q) {     \
+    return q->data[INDEX];                                                  \
+  }                                                                         \
+  /** @brief Setter for quaternion component COMPONENT */                   \
+  OSVR_INLINE void osvrQuatSet##COMPONENT(OSVR_Quaternion* q, double val) { \
+    q->data[INDEX] = val;                                                   \
+  }
+
+OSVR_QUAT_MEMBER(W, 0)
+OSVR_QUAT_MEMBER(X, 1)
+OSVR_QUAT_MEMBER(Y, 2)
+OSVR_QUAT_MEMBER(Z, 3)
+
+#undef OSVR_QUAT_MEMBER
+
+/** @brief Set a quaternion to the identity rotation */
+OSVR_INLINE void osvrQuatSetIdentity(OSVR_Quaternion* q) {
+  osvrQuatSetW(q, 1);
+  osvrQuatSetX(q, 0);
+  osvrQuatSetY(q, 0);
+  osvrQuatSetZ(q, 0);
+}
+
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#ifdef __cplusplus
+template <typename StreamType>
+inline StreamType& operator<<(StreamType& os, OSVR_Quaternion const& quat) {
+  os << "(" << osvrQuatGetW(&quat) << ", (" << osvrQuatGetX(&quat) << ", "
+     << osvrQuatGetY(&quat) << ", " << osvrQuatGetZ(&quat) << "))";
+  return os;
+}
+#endif
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/QuatlibInteropC.h b/gfx/vr/service/osvr/Util/QuatlibInteropC.h
new file mode 100644
index 0000000000..1519f02c10
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/QuatlibInteropC.h
@@ -0,0 +1,84 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_QuatlibInteropC_h_GUID_85D92019_F0CC_419C_5F6D_F5A3134AA5D4
+#define INCLUDED_QuatlibInteropC_h_GUID_85D92019_F0CC_419C_5F6D_F5A3134AA5D4
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/Pose3C.h>
+
+/* Library/third-party includes */
+#include <quat.h>
+
+/* Standard includes */
+#include <string.h>
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup UtilMath
+    @{
+*/
+OSVR_INLINE void osvrQuatToQuatlib(q_type dest, OSVR_Quaternion const* src) {
+  dest[Q_W] = osvrQuatGetW(src);
+  dest[Q_X] = osvrQuatGetX(src);
+  dest[Q_Y] = osvrQuatGetY(src);
+  dest[Q_Z] = osvrQuatGetZ(src);
+}
+
+OSVR_INLINE void osvrQuatFromQuatlib(OSVR_Quaternion* dest, q_type const src) {
+  osvrQuatSetW(dest, src[Q_W]);
+  osvrQuatSetX(dest, src[Q_X]);
+  osvrQuatSetY(dest, src[Q_Y]);
+  osvrQuatSetZ(dest, src[Q_Z]);
+}
+
+OSVR_INLINE void osvrVec3ToQuatlib(q_vec_type dest, OSVR_Vec3 const* src) {
+  memcpy((void*)(dest), (void const*)(src->data), sizeof(double) * 3);
+}
+
+OSVR_INLINE void osvrVec3FromQuatlib(OSVR_Vec3* dest, q_vec_type const src) {
+  memcpy((void*)(dest->data), (void const*)(src), sizeof(double) * 3);
+}
+
+OSVR_INLINE void osvrPose3ToQuatlib(q_xyz_quat_type* dest,
+                                    OSVR_Pose3 const* src) {
+  osvrVec3ToQuatlib(dest->xyz, &(src->translation));
+  osvrQuatToQuatlib(dest->quat, &(src->rotation));
+}
+
+OSVR_INLINE void osvrPose3FromQuatlib(OSVR_Pose3* dest,
+                                      q_xyz_quat_type const* src) {
+  osvrVec3FromQuatlib(&(dest->translation), src->xyz);
+  osvrQuatFromQuatlib(&(dest->rotation), src->quat);
+}
+
+/** @} */
+
+OSVR_EXTERN_C_END
+#endif
diff --git a/gfx/vr/service/osvr/Util/RadialDistortionParametersC.h b/gfx/vr/service/osvr/Util/RadialDistortionParametersC.h
new file mode 100644
index 0000000000..b3fea12625
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/RadialDistortionParametersC.h
@@ -0,0 +1,62 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2015
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2015 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_RadialDistortionParametersC_h_GUID_925BCEB1_BACA_4DA7_5133_FFF560C72EBD
+#define INCLUDED_RadialDistortionParametersC_h_GUID_925BCEB1_BACA_4DA7_5133_FFF560C72EBD
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/Vec2C.h>
+#include <osvr/Util/Vec3C.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup UtilMath
+@{
+*/
+
+/** @brief Parameters for a per-color-component radial distortion shader
+ */
+typedef struct OSVR_RadialDistortionParameters {
+  /** @brief Vector of K1 coefficients for the R, G, B channels*/
+  OSVR_Vec3 k1;
+  /** @brief Center of projection for the radial distortion, relative to the
+      bounds of this surface.
+      */
+  OSVR_Vec2 centerOfProjection;
+} OSVR_RadialDistortionParameters;
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/RenderingTypesC.h b/gfx/vr/service/osvr/Util/RenderingTypesC.h
new file mode 100644
index 0000000000..103d0396d9
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/RenderingTypesC.h
@@ -0,0 +1,134 @@
+/** @file
+    @brief Header with integer types for Viewer, Eye, and Surface
+   counts/indices, as well as viewport information.
+
+    Must be c-safe!
+
+    @date 2015
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2015 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//        http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_RenderingTypesC_h_GUID_6689A6CA_76AC_48AC_A0D0_2902BC95AC35
+#define INCLUDED_RenderingTypesC_h_GUID_6689A6CA_76AC_48AC_A0D0_2902BC95AC35
+
+/* Internal Includes */
+#include <osvr/Util/StdInt.h>
+#include <osvr/Util/APIBaseC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup PluginKit
+@{
+*/
+
+/** @brief A count or index for a display input in a display config.
+ */
+typedef uint8_t OSVR_DisplayInputCount;
+
+/** @brief The integer type used in specification of size or location of a
+    display input, in pixels.
+*/
+typedef int32_t OSVR_DisplayDimension;
+
+/** @brief The integer type specifying a number of viewers in a system.
+
+    A "head" is a viewer (though not all viewers are necessarily heads).
+
+    The count is output from osvrClientGetNumViewers().
+
+    When used as an ID/index, it is zero-based, so values range from 0 to (count
+    - 1) inclusive.
+
+    The most frequent count is 1, though higher values are theoretically
+    possible. If you do not handle higher values, do still check and alert the
+    user if their system reports a higher number, as your application may not
+    behave as the user expects.
+*/
+typedef uint32_t OSVR_ViewerCount;
+
+/** @brief The integer type specifying the number of eyes (viewpoints) of a
+    viewer.
+
+    The count for a given viewer is output from osvrClientGetNumEyesForViewer().
+
+    When used as an ID/index, it is zero-based,so values range from 0 to (count
+    - 1) inclusive, for a given viewer.
+
+    Use as an ID/index is not meaningful except in conjunction with the ID of
+    the corresponding viewer. (that is, there is no overall "eye 0", but "viewer
+    0, eye 0" is meaningful.)
+
+    In practice, the most frequent counts are 1 (e.g. mono) and 2 (e.g. stereo),
+    and for example the latter results in eyes with ID 0 and 1 for the viewer.
+    There is no innate or consistent semantics/meaning ("left" or "right") to
+    indices guaranteed at this time, and applications should not try to infer
+    any.
+*/
+typedef uint8_t OSVR_EyeCount;
+
+/** @brief The integer type specifying the number of surfaces seen by a viewer's
+    eye.
+
+    The count for a given viewer and eye is output from
+    osvrClientGetNumSurfacesForViewerEye(). Note that the count is not
+    necessarily equal between eyes of a viewer.
+
+    When used as an ID/index, it is zero-based, so values range from 0 to (count
+    - 1) inclusive, for a given viewer and eye.
+
+    Use as an ID/index is not meaningful except in conjunction with the IDs of
+    the corresponding viewer and eye. (that is, there is no overall "surface 0",
+    but "viewer 0, eye 0, surface 0" is meaningful.)
+*/
+typedef uint32_t OSVR_SurfaceCount;
+
+/** @brief The integer type used in specification of size or location of a
+    viewport.
+*/
+typedef int32_t OSVR_ViewportDimension;
+
+/** @brief The integer type used to indicate relative priorities of a display
+    distortion strategy. Negative values are defined to mean that strategy is
+    unavailable.
+
+    @sa OSVR_DISTORTION_PRIORITY_UNAVAILABLE
+*/
+typedef int32_t OSVR_DistortionPriority;
+
+/** @brief The constant to return as an OSVR_DistortionPriority if a given
+    strategy is not available for a surface.
+
+    @sa OSVR_DistortionPriority
+*/
+#define OSVR_DISTORTION_PRIORITY_UNAVAILABLE (-1)
+
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/ReturnCodesC.h b/gfx/vr/service/osvr/Util/ReturnCodesC.h
new file mode 100644
index 0000000000..971798ea41
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/ReturnCodesC.h
@@ -0,0 +1,57 @@
+/** @file
+    @brief Header declaring a type and values for simple C return codes.
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_ReturnCodesC_h_GUID_C81A2FDE_E5BB_4AAA_70A4_C616DD7C141A
+#define INCLUDED_ReturnCodesC_h_GUID_C81A2FDE_E5BB_4AAA_70A4_C616DD7C141A
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/AnnotationMacrosC.h>
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup PluginKit
+    @{
+*/
+/** @name Return Codes
+    @{
+*/
+/** @brief The "success" value for an OSVR_ReturnCode */
+#define OSVR_RETURN_SUCCESS (0)
+/** @brief The "failure" value for an OSVR_ReturnCode */
+#define OSVR_RETURN_FAILURE (1)
+/** @brief Return type from C API OSVR functions. */
+typedef OSVR_RETURN_SUCCESS_CONDITION(
+    return == OSVR_RETURN_SUCCESS) char OSVR_ReturnCode;
+/** @} */
+
+/** @} */ /* end of group */
+
+OSVR_EXTERN_C_END
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/StdInt.h b/gfx/vr/service/osvr/Util/StdInt.h
new file mode 100644
index 0000000000..4fe7117cb5
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/StdInt.h
@@ -0,0 +1,42 @@
+/** @file
+    @brief Header wrapping the C99 standard `stdint` header.
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_StdInt_h_GUID_C1AAF35C_C704_4DB7_14AC_615730C4619B
+#define INCLUDED_StdInt_h_GUID_C1AAF35C_C704_4DB7_14AC_615730C4619B
+
+/* IWYU pragma: begin_exports */
+
+#if !defined(_MSC_VER) || (defined(_MSC_VER) && _MSC_VER >= 1600)
+#  include <stdint.h>
+#else
+#  include "MSStdIntC.h"
+#endif
+
+/* IWYU pragma: end_exports */
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/TimeValueC.h b/gfx/vr/service/osvr/Util/TimeValueC.h
new file mode 100644
index 0000000000..eb6a4f7cec
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/TimeValueC.h
@@ -0,0 +1,267 @@
+/** @file
+    @brief Header defining a dependency-free, cross-platform substitute for
+   struct timeval
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_TimeValueC_h_GUID_A02C6917_124D_4CB3_E63E_07F2DA7144E9
+#define INCLUDED_TimeValueC_h_GUID_A02C6917_124D_4CB3_E63E_07F2DA7144E9
+
+/* Internal Includes */
+#include <osvr/Util/Export.h>
+#include <osvr/Util/APIBaseC.h>
+#include <osvr/Util/AnnotationMacrosC.h>
+#include <osvr/Util/PlatformConfig.h>
+#include <osvr/Util/StdInt.h>
+#include <osvr/Util/BoolC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @defgroup UtilTime Timestamp interaction
+    @ingroup Util
+
+    This provides a level of interoperability with struct timeval on systems
+    with that facility. It provides a neutral representation with sufficiently
+    large types.
+
+    For C++ code, use of std::chrono or boost::chrono instead is recommended.
+
+    Note that these time values may not necessarily correlate between processes
+   so should not be used to estimate or measure latency, etc.
+
+    @{
+*/
+
+/** @brief The signed integer type storing the seconds in a struct
+    OSVR_TimeValue */
+typedef int64_t OSVR_TimeValue_Seconds;
+/** @brief The signed integer type storing the microseconds in a struct
+    OSVR_TimeValue */
+typedef int32_t OSVR_TimeValue_Microseconds;
+
+/** @brief Standardized, portable parallel to struct timeval for representing
+   both absolute times and time intervals.
+
+   Where interpreted as an absolute time, its meaning is to be considered the
+   same as that of the POSIX struct timeval:
+   time since 00:00 Coordinated Universal Time (UTC), January 1, 1970.
+
+   For best results, please keep normalized. Output of all functions here
+   is normalized.
+   */
+typedef struct OSVR_TimeValue {
+  /** @brief Seconds portion of the time value. */
+  OSVR_TimeValue_Seconds seconds;
+  /** @brief Microseconds portion of the time value. */
+  OSVR_TimeValue_Microseconds microseconds;
+} OSVR_TimeValue;
+
+#ifdef OSVR_HAVE_STRUCT_TIMEVAL
+/** @brief Gets the current time in the TimeValue. Parallel to gettimeofday. */
+OSVR_UTIL_EXPORT void osvrTimeValueGetNow(OSVR_OUT OSVR_TimeValue* dest)
+    OSVR_FUNC_NONNULL((1));
+
+struct timeval; /* forward declaration */
+
+/** @brief Converts from a TimeValue struct to your system's struct timeval.
+
+    @param dest Pointer to an empty struct timeval for your platform.
+    @param src A pointer to an OSVR_TimeValue you'd like to convert from.
+
+    If either parameter is NULL, the function will return without doing
+   anything.
+*/
+OSVR_UTIL_EXPORT void osvrTimeValueToStructTimeval(
+    OSVR_OUT struct timeval* dest, OSVR_IN_PTR const OSVR_TimeValue* src)
+    OSVR_FUNC_NONNULL((1, 2));
+
+/** @brief Converts from a TimeValue struct to your system's struct timeval.
+    @param dest An OSVR_TimeValue destination pointer.
+    @param src Pointer to a struct timeval you'd like to convert from.
+
+    The result is normalized.
+
+    If either parameter is NULL, the function will return without doing
+   anything.
+*/
+OSVR_UTIL_EXPORT void osvrStructTimevalToTimeValue(
+    OSVR_OUT OSVR_TimeValue* dest, OSVR_IN_PTR const struct timeval* src)
+    OSVR_FUNC_NONNULL((1, 2));
+#endif
+
+/** @brief "Normalizes" a time value so that the absolute number of microseconds
+    is less than 1,000,000, and that the sign of both components is the same.
+
+    @param tv Address of a struct TimeValue to normalize in place.
+
+    If the given pointer is NULL, this function returns without doing anything.
+*/
+OSVR_UTIL_EXPORT void osvrTimeValueNormalize(OSVR_INOUT_PTR OSVR_TimeValue* tv)
+    OSVR_FUNC_NONNULL((1));
+
+/** @brief Sums two time values, replacing the first with the result.
+
+    @param tvA Destination and first source.
+    @param tvB second source
+
+    If a given pointer is NULL, this function returns without doing anything.
+
+    Both parameters are expected to be in normalized form.
+*/
+OSVR_UTIL_EXPORT void osvrTimeValueSum(OSVR_INOUT_PTR OSVR_TimeValue* tvA,
+                                       OSVR_IN_PTR const OSVR_TimeValue* tvB)
+    OSVR_FUNC_NONNULL((1, 2));
+
+/** @brief Computes the difference between two time values, replacing the first
+    with the result.
+
+    Effectively, `*tvA = *tvA - *tvB`
+
+    @param tvA Destination and first source.
+    @param tvB second source
+
+    If a given pointer is NULL, this function returns without doing anything.
+
+    Both parameters are expected to be in normalized form.
+*/
+OSVR_UTIL_EXPORT void osvrTimeValueDifference(
+    OSVR_INOUT_PTR OSVR_TimeValue* tvA, OSVR_IN_PTR const OSVR_TimeValue* tvB)
+    OSVR_FUNC_NONNULL((1, 2));
+
+/** @brief  Compares two time values (assumed to be normalized), returning
+    the same values as strcmp
+
+    @return <0 if A is earlier than B, 0 if they are the same, and >0 if A
+    is later than B.
+*/
+OSVR_UTIL_EXPORT int osvrTimeValueCmp(OSVR_IN_PTR const OSVR_TimeValue* tvA,
+                                      OSVR_IN_PTR const OSVR_TimeValue* tvB)
+    OSVR_FUNC_NONNULL((1, 2));
+
+OSVR_EXTERN_C_END
+
+/** @brief Compute the difference between the two time values, returning the
+    duration as a double-precision floating-point number of seconds.
+
+    Effectively, `ret = *tvA - *tvB`
+
+    @param tvA first source.
+    @param tvB second source
+    @return Duration of timespan in seconds (floating-point)
+*/
+OSVR_INLINE double osvrTimeValueDurationSeconds(
+    OSVR_IN_PTR const OSVR_TimeValue* tvA,
+    OSVR_IN_PTR const OSVR_TimeValue* tvB) {
+  OSVR_TimeValue A = *tvA;
+  osvrTimeValueDifference(&A, tvB);
+  double dt = A.seconds + A.microseconds / 1000000.0;
+  return dt;
+}
+
+/** @brief True if A is later than B */
+OSVR_INLINE OSVR_CBool
+osvrTimeValueGreater(OSVR_IN_PTR const OSVR_TimeValue* tvA,
+                     OSVR_IN_PTR const OSVR_TimeValue* tvB) {
+  if (!tvA || !tvB) {
+    return OSVR_FALSE;
+  }
+  return ((tvA->seconds > tvB->seconds) ||
+          (tvA->seconds == tvB->seconds &&
+           tvA->microseconds > tvB->microseconds))
+             ? OSVR_TRUE
+             : OSVR_FALSE;
+}
+
+#ifdef __cplusplus
+
+#  include <cmath>
+#  include <cassert>
+
+/// Returns true if the time value is normalized. Typically used in assertions.
+inline bool osvrTimeValueIsNormalized(const OSVR_TimeValue& tv) {
+#  ifdef __APPLE__
+  // apparently standard library used on mac only has floating-point abs?
+  return std::abs(double(tv.microseconds)) < 1000000 &&
+#  else
+  return std::abs(tv.microseconds) < 1000000 &&
+#  endif
+         ((tv.seconds > 0) == (tv.microseconds > 0));
+}
+
+/// True if A is later than B
+inline bool osvrTimeValueGreater(const OSVR_TimeValue& tvA,
+                                 const OSVR_TimeValue& tvB) {
+  assert(osvrTimeValueIsNormalized(tvA) &&
+         "First timevalue argument to comparison was not normalized!");
+  assert(osvrTimeValueIsNormalized(tvB) &&
+         "Second timevalue argument to comparison was not normalized!");
+  return (tvA.seconds > tvB.seconds) ||
+         (tvA.seconds == tvB.seconds && tvA.microseconds > tvB.microseconds);
+}
+
+/// Operator > overload for time values
+inline bool operator>(const OSVR_TimeValue& tvA, const OSVR_TimeValue& tvB) {
+  return osvrTimeValueGreater(tvA, tvB);
+}
+
+/// Operator < overload for time values
+inline bool operator<(const OSVR_TimeValue& tvA, const OSVR_TimeValue& tvB) {
+  // Change the order of arguments before forwarding.
+  return osvrTimeValueGreater(tvB, tvA);
+}
+
+/// Operator == overload for time values
+inline bool operator==(const OSVR_TimeValue& tvA, const OSVR_TimeValue& tvB) {
+  assert(osvrTimeValueIsNormalized(tvA) &&
+         "First timevalue argument to equality comparison was not normalized!");
+  assert(
+      osvrTimeValueIsNormalized(tvB) &&
+      "Second timevalue argument to equality comparison was not normalized!");
+  return (tvA.seconds == tvB.seconds) && (tvA.microseconds == tvB.microseconds);
+}
+/// Operator == overload for time values
+inline bool operator!=(const OSVR_TimeValue& tvA, const OSVR_TimeValue& tvB) {
+  assert(osvrTimeValueIsNormalized(tvA) &&
+         "First timevalue argument to "
+         "inequality comparison was not "
+         "normalized!");
+  assert(osvrTimeValueIsNormalized(tvB) &&
+         "Second timevalue argument to "
+         "inequality comparison was not "
+         "normalized!");
+  return (tvA.seconds != tvB.seconds) || (tvA.microseconds != tvB.microseconds);
+}
+#endif
+
+/** @} */
+
+#endif
diff --git a/gfx/vr/service/osvr/Util/Vec2C.h b/gfx/vr/service/osvr/Util/Vec2C.h
new file mode 100644
index 0000000000..0641270c1f
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/Vec2C.h
@@ -0,0 +1,86 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_Vec2C_h_GUID_F9715DE4_2649_4182_0F4C_D62121235D5F
+#define INCLUDED_Vec2C_h_GUID_F9715DE4_2649_4182_0F4C_D62121235D5F
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup UtilMath
+    @{
+*/
+/** @brief A structure defining a 2D vector, which represents position
+ */
+typedef struct OSVR_Vec2 {
+  /** @brief Internal array data. */
+  double data[2];
+} OSVR_Vec2;
+
+#define OSVR_VEC_MEMBER(COMPONENT, INDEX)                             \
+  /** @brief Accessor for Vec2 component COMPONENT */                 \
+  OSVR_INLINE double osvrVec2Get##COMPONENT(OSVR_Vec2 const* v) {     \
+    return v->data[INDEX];                                            \
+  }                                                                   \
+  /** @brief Setter for Vec2 component COMPONENT */                   \
+  OSVR_INLINE void osvrVec2Set##COMPONENT(OSVR_Vec2* v, double val) { \
+    v->data[INDEX] = val;                                             \
+  }
+
+OSVR_VEC_MEMBER(X, 0)
+OSVR_VEC_MEMBER(Y, 1)
+
+#undef OSVR_VEC_MEMBER
+
+/** @brief Set a Vec2 to the zero vector */
+OSVR_INLINE void osvrVec2Zero(OSVR_Vec2* v) {
+  osvrVec2SetX(v, 0);
+  osvrVec2SetY(v, 0);
+}
+
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#ifdef __cplusplus
+template <typename StreamType>
+inline StreamType& operator<<(StreamType& os, OSVR_Vec2 const& vec) {
+  os << "(" << vec.data[0] << ", " << vec.data[1] << ")";
+  return os;
+}
+#endif
+
+#endif  // INCLUDED_Vec2C_h_GUID_F9715DE4_2649_4182_0F4C_D62121235D5F
diff --git a/gfx/vr/service/osvr/Util/Vec3C.h b/gfx/vr/service/osvr/Util/Vec3C.h
new file mode 100644
index 0000000000..f72327c05b
--- /dev/null
+++ b/gfx/vr/service/osvr/Util/Vec3C.h
@@ -0,0 +1,88 @@
+/** @file
+    @brief Header
+
+    Must be c-safe!
+
+    @date 2014
+
+    @author
+    Sensics, Inc.
+    <http://sensics.com/osvr>
+*/
+
+/*
+// Copyright 2014 Sensics, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#ifndef INCLUDED_Vec3C_h_GUID_BF4E98ED_74CF_4785_DB61_109A00BA74DE
+#define INCLUDED_Vec3C_h_GUID_BF4E98ED_74CF_4785_DB61_109A00BA74DE
+
+/* Internal Includes */
+#include <osvr/Util/APIBaseC.h>
+
+/* Library/third-party includes */
+/* none */
+
+/* Standard includes */
+/* none */
+
+OSVR_EXTERN_C_BEGIN
+
+/** @addtogroup UtilMath
+    @{
+*/
+/** @brief A structure defining a 3D vector, often a position/translation.
+ */
+typedef struct OSVR_Vec3 {
+  /** @brief Internal array data. */
+  double data[3];
+} OSVR_Vec3;
+
+#define OSVR_VEC_MEMBER(COMPONENT, INDEX)                             \
+  /** @brief Accessor for Vec3 component COMPONENT */                 \
+  OSVR_INLINE double osvrVec3Get##COMPONENT(OSVR_Vec3 const* v) {     \
+    return v->data[INDEX];                                            \
+  }                                                                   \
+  /** @brief Setter for Vec3 component COMPONENT */                   \
+  OSVR_INLINE void osvrVec3Set##COMPONENT(OSVR_Vec3* v, double val) { \
+    v->data[INDEX] = val;                                             \
+  }
+
+OSVR_VEC_MEMBER(X, 0)
+OSVR_VEC_MEMBER(Y, 1)
+OSVR_VEC_MEMBER(Z, 2)
+
+#undef OSVR_VEC_MEMBER
+
+/** @brief Set a Vec3 to the zero vector */
+OSVR_INLINE void osvrVec3Zero(OSVR_Vec3* v) {
+  osvrVec3SetX(v, 0);
+  osvrVec3SetY(v, 0);
+  osvrVec3SetZ(v, 0);
+}
+
+/** @} */
+
+OSVR_EXTERN_C_END
+
+#ifdef __cplusplus
+template <typename StreamType>
+inline StreamType& operator<<(StreamType& os, OSVR_Vec3 const& vec) {
+  os << "(" << vec.data[0] << ", " << vec.data[1] << ", " << vec.data[2] << ")";
+  return os;
+}
+#endif
+
+#endif