vrclient: Add sdk v1.0.12

vrclient_x64/cppIVRApplications_IVRApplications_006.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_005.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRCompositor_IVRCompositor_022.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVROverlay_IVROverlay_018.cpp

@@ -0,0 +1,428 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVROverlay_IVROverlay_018.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_FindOverlay(void *linux_side, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->FindOverlay((const char *)pchOverlayKey, (vr::VROverlayHandle_t *)pOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_CreateOverlay(void *linux_side, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->CreateOverlay((const char *)pchOverlayKey, (const char *)pchOverlayName, (vr::VROverlayHandle_t *)pOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_DestroyOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->DestroyOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetHighQualityOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->SetHighQualityOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::VROverlayHandle_t cppIVROverlay_IVROverlay_018_GetHighQualityOverlay(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->GetHighQualityOverlay();
+}
+
+uint32_t cppIVROverlay_IVROverlay_018_GetOverlayKey(void *linux_side, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayKey((vr::VROverlayHandle_t)ulOverlayHandle, (char *)pchValue, (uint32_t)unBufferSize, (vr::EVROverlayError *)pError);
+}
+
+uint32_t cppIVROverlay_IVROverlay_018_GetOverlayName(void *linux_side, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayName((vr::VROverlayHandle_t)ulOverlayHandle, (char *)pchValue, (uint32_t)unBufferSize, (vr::EVROverlayError *)pError);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayName(void *linux_side, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayName((vr::VROverlayHandle_t)ulOverlayHandle, (const char *)pchName);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayImageData(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayImageData((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pvBuffer, (uint32_t)unBufferSize, (uint32_t *)punWidth, (uint32_t *)punHeight);
+}
+
+const char * cppIVROverlay_IVROverlay_018_GetOverlayErrorNameFromEnum(void *linux_side, EVROverlayError error)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayErrorNameFromEnum((vr::EVROverlayError)error);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t)unPID);
+}
+
+uint32_t cppIVROverlay_IVROverlay_018_GetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayFlag(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayFlag((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayFlags)eOverlayFlag, (bool)bEnabled);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayFlag(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayFlag((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayFlags)eOverlayFlag, (bool *)pbEnabled);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayColor(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayColor((vr::VROverlayHandle_t)ulOverlayHandle, (float)fRed, (float)fGreen, (float)fBlue);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayColor(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayColor((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfRed, (float *)pfGreen, (float *)pfBlue);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float)fAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float)fTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlaySortOrder(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    return ((IVROverlay*)linux_side)->SetOverlaySortOrder((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t)unSortOrder);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlaySortOrder(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    return ((IVROverlay*)linux_side)->GetOverlaySortOrder((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)punSortOrder);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayAutoCurveDistanceRangeInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fMinDistanceInMeters, (float)fMaxDistanceInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayAutoCurveDistanceRangeInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfMinDistanceInMeters, (float *)pfMaxDistanceInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTextureColorSpace(void *linux_side, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTextureColorSpace((vr::VROverlayHandle_t)ulOverlayHandle, (vr::EColorSpace)eTextureColorSpace);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTextureColorSpace(void *linux_side, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTextureColorSpace((vr::VROverlayHandle_t)ulOverlayHandle, (vr::EColorSpace *)peTextureColorSpace);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTextureBounds(void *linux_side, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTextureBounds((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::VRTextureBounds_t *)pOverlayTextureBounds);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTextureBounds(void *linux_side, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTextureBounds((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VRTextureBounds_t *)pOverlayTextureBounds);
+}
+
+uint32_t cppIVROverlay_IVROverlay_018_GetOverlayRenderModel(void *linux_side, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayRenderModel((vr::VROverlayHandle_t)ulOverlayHandle, (char *)pchValue, (uint32_t)unBufferSize, (vr::HmdColor_t *)pColor, (vr::EVROverlayError *)pError);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayRenderModel(void *linux_side, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayRenderModel((vr::VROverlayHandle_t)ulOverlayHandle, (const char *)pchRenderModel, (const vr::HmdColor_t *)pColor);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformType(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTransformType((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayTransformType *)peTransformType);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTransformAbsolute(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTransformAbsolute((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToOverlayTransform);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformAbsolute(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTransformAbsolute((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin *)peTrackingOrigin, (vr::HmdMatrix34_t *)pmatTrackingOriginToOverlayTransform);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTransformTrackedDeviceRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTransformTrackedDeviceRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::TrackedDeviceIndex_t)unTrackedDevice, (const vr::HmdMatrix34_t *)pmatTrackedDeviceToOverlayTransform);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformTrackedDeviceRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTransformTrackedDeviceRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::TrackedDeviceIndex_t *)punTrackedDevice, (vr::HmdMatrix34_t *)pmatTrackedDeviceToOverlayTransform);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTransformTrackedDeviceComponent(void *linux_side, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTransformTrackedDeviceComponent((vr::VROverlayHandle_t)ulOverlayHandle, (vr::TrackedDeviceIndex_t)unDeviceIndex, (const char *)pchComponentName);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformTrackedDeviceComponent(void *linux_side, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTransformTrackedDeviceComponent((vr::VROverlayHandle_t)ulOverlayHandle, (vr::TrackedDeviceIndex_t *)punDeviceIndex, (char *)pchComponentName, (uint32_t)unComponentNameSize);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformOverlayRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTransformOverlayRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayHandle_t *)ulOverlayHandleParent, (vr::HmdMatrix34_t *)pmatParentOverlayToOverlayTransform);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTransformOverlayRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTransformOverlayRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayHandle_t)ulOverlayHandleParent, (const vr::HmdMatrix34_t *)pmatParentOverlayToOverlayTransform);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_ShowOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ShowOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_HideOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->HideOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+bool cppIVROverlay_IVROverlay_018_IsOverlayVisible(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsOverlayVisible((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinates(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    return ((IVROverlay*)linux_side)->GetTransformForOverlayCoordinates((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (vr::HmdVector2_t)coordinatesInOverlay, (vr::HmdMatrix34_t *)pmatTransform);
+}
+
+bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent)
+{
+    VREvent_t lin;
+    bool _ret;
+    _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, &lin, sizeof(lin));
+    struct_VREvent_t_1012_lin_to_win(&lin, pEvent);
+    return _ret;
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayInputMethod(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayInputMethod((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayInputMethod *)peInputMethod);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayInputMethod(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayInputMethod((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayInputMethod)eInputMethod);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayMouseScale(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayMouseScale((vr::VROverlayHandle_t)ulOverlayHandle, (vr::HmdVector2_t *)pvecMouseScale);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayMouseScale(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayMouseScale((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::HmdVector2_t *)pvecMouseScale);
+}
+
+bool cppIVROverlay_IVROverlay_018_ComputeOverlayIntersection(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    return ((IVROverlay*)linux_side)->ComputeOverlayIntersection((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::VROverlayIntersectionParams_t *)pParams, (vr::VROverlayIntersectionResults_t *)pResults);
+}
+
+bool cppIVROverlay_IVROverlay_018_IsHoverTargetOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsHoverTargetOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::VROverlayHandle_t cppIVROverlay_IVROverlay_018_GetGamepadFocusOverlay(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->GetGamepadFocusOverlay();
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetGamepadFocusOverlay(void *linux_side, VROverlayHandle_t ulNewFocusOverlay)
+{
+    return ((IVROverlay*)linux_side)->SetGamepadFocusOverlay((vr::VROverlayHandle_t)ulNewFocusOverlay);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayNeighbor(void *linux_side, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayNeighbor((vr::EOverlayDirection)eDirection, (vr::VROverlayHandle_t)ulFrom, (vr::VROverlayHandle_t)ulTo);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_MoveGamepadFocusToNeighbor(void *linux_side, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    return ((IVROverlay*)linux_side)->MoveGamepadFocusToNeighbor((vr::EOverlayDirection)eDirection, (vr::VROverlayHandle_t)ulFrom);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayDualAnalogTransform(void *linux_side, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * vCenter, float fRadius)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayDualAnalogTransform((vr::VROverlayHandle_t)ulOverlay, (vr::EDualAnalogWhich)eWhich, *vCenter, (float)fRadius);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayDualAnalogTransform(void *linux_side, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayDualAnalogTransform((vr::VROverlayHandle_t)ulOverlay, (vr::EDualAnalogWhich)eWhich, (vr::HmdVector2_t *)pvCenter, (float *)pfRadius);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::Texture_t *)pTexture);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_ClearOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ClearOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayRaw(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayRaw((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pvBuffer, (uint32_t)unWidth, (uint32_t)unHeight, (uint32_t)unDepth);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayFromFile(void *linux_side, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayFromFile((vr::VROverlayHandle_t)ulOverlayHandle, (const char *)pchFilePath);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle, (void **)pNativeTextureHandle, (void *)pNativeTextureRef, (uint32_t *)pWidth, (uint32_t *)pHeight, (uint32_t *)pNativeFormat, (vr::ETextureType *)pAPIType, (vr::EColorSpace *)pColorSpace, (vr::VRTextureBounds_t *)pTextureBounds);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_ReleaseNativeOverlayHandle(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    return ((IVROverlay*)linux_side)->ReleaseNativeOverlayHandle((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pNativeTextureHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTextureSize(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTextureSize((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)pWidth, (uint32_t *)pHeight);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_CreateDashboardOverlay(void *linux_side, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    return ((IVROverlay*)linux_side)->CreateDashboardOverlay((const char *)pchOverlayKey, (const char *)pchOverlayFriendlyName, (vr::VROverlayHandle_t *)pMainHandle, (vr::VROverlayHandle_t *)pThumbnailHandle);
+}
+
+bool cppIVROverlay_IVROverlay_018_IsDashboardVisible(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->IsDashboardVisible();
+}
+
+bool cppIVROverlay_IVROverlay_018_IsActiveDashboardOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsActiveDashboardOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetDashboardOverlaySceneProcess(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    return ((IVROverlay*)linux_side)->SetDashboardOverlaySceneProcess((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t)unProcessId);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetDashboardOverlaySceneProcess(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    return ((IVROverlay*)linux_side)->GetDashboardOverlaySceneProcess((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)punProcessId);
+}
+
+void cppIVROverlay_IVROverlay_018_ShowDashboard(void *linux_side, const char * pchOverlayToShow)
+{
+    ((IVROverlay*)linux_side)->ShowDashboard((const char *)pchOverlayToShow);
+}
+
+vr::TrackedDeviceIndex_t cppIVROverlay_IVROverlay_018_GetPrimaryDashboardDevice(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->GetPrimaryDashboardDevice();
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_ShowKeyboard(void *linux_side, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    return ((IVROverlay*)linux_side)->ShowKeyboard((vr::EGamepadTextInputMode)eInputMode, (vr::EGamepadTextInputLineMode)eLineInputMode, (const char *)pchDescription, (uint32_t)unCharMax, (const char *)pchExistingText, (bool)bUseMinimalMode, (uint64_t)uUserValue);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_ShowKeyboardForOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    return ((IVROverlay*)linux_side)->ShowKeyboardForOverlay((vr::VROverlayHandle_t)ulOverlayHandle, (vr::EGamepadTextInputMode)eInputMode, (vr::EGamepadTextInputLineMode)eLineInputMode, (const char *)pchDescription, (uint32_t)unCharMax, (const char *)pchExistingText, (bool)bUseMinimalMode, (uint64_t)uUserValue);
+}
+
+uint32_t cppIVROverlay_IVROverlay_018_GetKeyboardText(void *linux_side, char * pchText, uint32_t cchText)
+{
+    return ((IVROverlay*)linux_side)->GetKeyboardText((char *)pchText, (uint32_t)cchText);
+}
+
+void cppIVROverlay_IVROverlay_018_HideKeyboard(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->HideKeyboard();
+}
+
+void cppIVROverlay_IVROverlay_018_SetKeyboardTransformAbsolute(void *linux_side, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    ((IVROverlay*)linux_side)->SetKeyboardTransformAbsolute((vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToKeyboardTransform);
+}
+
+void cppIVROverlay_IVROverlay_018_SetKeyboardPositionForOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    ((IVROverlay*)linux_side)->SetKeyboardPositionForOverlay((vr::VROverlayHandle_t)ulOverlayHandle, (vr::HmdRect2_t)avoidRect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayIntersectionMask(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayIntersectionMask((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayIntersectionMaskPrimitive_t *)pMaskPrimitives, (uint32_t)unNumMaskPrimitives, (uint32_t)unPrimitiveSize);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayFlags(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayFlags((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)pFlags);
+}
+
+vr::VRMessageOverlayResponse cppIVROverlay_IVROverlay_018_ShowMessageOverlay(void *linux_side, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+{
+    return ((IVROverlay*)linux_side)->ShowMessageOverlay((const char *)pchText, (const char *)pchCaption, (const char *)pchButton0Text, (const char *)pchButton1Text, (const char *)pchButton2Text, (const char *)pchButton3Text);
+}
+
+void cppIVROverlay_IVROverlay_018_CloseMessageOverlay(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->CloseMessageOverlay();
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/cppIVROverlay_IVROverlay_018.h

@@ -0,0 +1,88 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVROverlayError cppIVROverlay_IVROverlay_018_FindOverlay(void *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_CreateOverlay(void *, const char *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_DestroyOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetHighQualityOverlay(void *, VROverlayHandle_t);
+extern VROverlayHandle_t cppIVROverlay_IVROverlay_018_GetHighQualityOverlay(void *);
+extern uint32_t cppIVROverlay_IVROverlay_018_GetOverlayKey(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern uint32_t cppIVROverlay_IVROverlay_018_GetOverlayName(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayName(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayImageData(void *, VROverlayHandle_t, void *, uint32_t, uint32_t *, uint32_t *);
+extern const char * cppIVROverlay_IVROverlay_018_GetOverlayErrorNameFromEnum(void *, EVROverlayError);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayRenderingPid(void *, VROverlayHandle_t, uint32_t);
+extern uint32_t cppIVROverlay_IVROverlay_018_GetOverlayRenderingPid(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayColor(void *, VROverlayHandle_t, float, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayColor(void *, VROverlayHandle_t, float *, float *, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayAlpha(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayAlpha(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTexelAspect(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTexelAspect(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayWidthInMeters(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayWidthInMeters(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayAutoCurveDistanceRangeInMeters(void *, VROverlayHandle_t, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayAutoCurveDistanceRangeInMeters(void *, VROverlayHandle_t, float *, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern uint32_t cppIVROverlay_IVROverlay_018_GetOverlayRenderModel(void *, VROverlayHandle_t, char *, uint32_t, HmdColor_t *, EVROverlayError *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayRenderModel(void *, VROverlayHandle_t, const char *, HmdColor_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformType(void *, VROverlayHandle_t, VROverlayTransformType *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, char *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_ShowOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_HideOverlay(void *, VROverlayHandle_t);
+extern bool cppIVROverlay_IVROverlay_018_IsOverlayVisible(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
+extern bool cppIVROverlay_IVROverlay_018_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1012 *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern bool cppIVROverlay_IVROverlay_018_ComputeOverlayIntersection(void *, VROverlayHandle_t, VROverlayIntersectionParams_t *, VROverlayIntersectionResults_t *);
+extern bool cppIVROverlay_IVROverlay_018_IsHoverTargetOverlay(void *, VROverlayHandle_t);
+extern VROverlayHandle_t cppIVROverlay_IVROverlay_018_GetGamepadFocusOverlay(void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetGamepadFocusOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayNeighbor(void *, EOverlayDirection, VROverlayHandle_t, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_MoveGamepadFocusToNeighbor(void *, EOverlayDirection, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayDualAnalogTransform(void *, VROverlayHandle_t, EDualAnalogWhich, HmdVector2_t *, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayDualAnalogTransform(void *, VROverlayHandle_t, EDualAnalogWhich, HmdVector2_t *, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayTexture(void *, VROverlayHandle_t, Texture_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_ClearOverlayTexture(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayRaw(void *, VROverlayHandle_t, void *, uint32_t, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayFromFile(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTexture(void *, VROverlayHandle_t, void **, void *, uint32_t *, uint32_t *, uint32_t *, ETextureType *, EColorSpace *, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_ReleaseNativeOverlayHandle(void *, VROverlayHandle_t, void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayTextureSize(void *, VROverlayHandle_t, uint32_t *, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_CreateDashboardOverlay(void *, const char *, const char *, VROverlayHandle_t *, VROverlayHandle_t *);
+extern bool cppIVROverlay_IVROverlay_018_IsDashboardVisible(void *);
+extern bool cppIVROverlay_IVROverlay_018_IsActiveDashboardOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t *);
+extern void cppIVROverlay_IVROverlay_018_ShowDashboard(void *, const char *);
+extern TrackedDeviceIndex_t cppIVROverlay_IVROverlay_018_GetPrimaryDashboardDevice(void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_ShowKeyboard(void *, EGamepadTextInputMode, EGamepadTextInputLineMode, const char *, uint32_t, const char *, bool, uint64_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_ShowKeyboardForOverlay(void *, VROverlayHandle_t, EGamepadTextInputMode, EGamepadTextInputLineMode, const char *, uint32_t, const char *, bool, uint64_t);
+extern uint32_t cppIVROverlay_IVROverlay_018_GetKeyboardText(void *, char *, uint32_t);
+extern void cppIVROverlay_IVROverlay_018_HideKeyboard(void *);
+extern void cppIVROverlay_IVROverlay_018_SetKeyboardTransformAbsolute(void *, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern void cppIVROverlay_IVROverlay_018_SetKeyboardPositionForOverlay(void *, VROverlayHandle_t, HmdRect2_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_SetOverlayIntersectionMask(void *, VROverlayHandle_t, VROverlayIntersectionMaskPrimitive_t *, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_018_GetOverlayFlags(void *, VROverlayHandle_t, uint32_t *);
+extern VRMessageOverlayResponse cppIVROverlay_IVROverlay_018_ShowMessageOverlay(void *, const char *, const char *, const char *, const char *, const char *, const char *);
+extern void cppIVROverlay_IVROverlay_018_CloseMessageOverlay(void *);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -9,34 +9,34 @@ extern "C" {
 #ifdef __cplusplus
 extern "C" {
 #endif
-vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1011 ** ppRenderModel)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1012 ** ppRenderModel)
 {
     RenderModel_t *lin;
     vr::EVRRenderModelError _ret;
     _ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, &lin);
     if(_ret == 0)
-        *ppRenderModel = struct_RenderModel_t_1011_wrap(lin);
+        *ppRenderModel = struct_RenderModel_t_1012_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *linux_side, winRenderModel_t_1011 * pRenderModel)
+void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *linux_side, winRenderModel_t_1012 * pRenderModel)
 {
-    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1011_unwrap(pRenderModel));
+    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1012_unwrap(pRenderModel));
 }
 
-vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1011 ** ppTexture)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1012 ** ppTexture)
 {
     RenderModel_TextureMap_t *lin;
     vr::EVRRenderModelError _ret;
     _ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, &lin);
     if(_ret == 0)
-        *ppTexture = struct_RenderModel_TextureMap_t_1011_wrap(lin);
+        *ppTexture = struct_RenderModel_TextureMap_t_1012_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_005_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1011 * pTexture)
+void cppIVRRenderModels_IVRRenderModels_005_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1012 * pTexture)
 {
-    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1011_unwrap(pTexture));
+    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1012_unwrap(pTexture));
 }
 
 vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTextureD3D11_Async(void *linux_side, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)

vrclient_x64/cppIVRRenderModels_IVRRenderModels_005.h

@@ -1,10 +1,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1011 **);
-extern void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *, winRenderModel_t_1011 *);
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1011 **);
-extern void cppIVRRenderModels_IVRRenderModels_005_FreeTexture(void *, winRenderModel_TextureMap_t_1011 *);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1012 **);
+extern void cppIVRRenderModels_IVRRenderModels_005_FreeRenderModel(void *, winRenderModel_t_1012 *);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1012 **);
+extern void cppIVRRenderModels_IVRRenderModels_005_FreeTexture(void *, winRenderModel_TextureMap_t_1012 *);
 extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadTextureD3D11_Async(void *, TextureID_t, void *, void **);
 extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_005_LoadIntoTextureD3D11_Async(void *, TextureID_t, void *);
 extern void cppIVRRenderModels_IVRRenderModels_005_FreeTextureD3D11(void *, void *);

vrclient_x64/cppIVRResources_IVRResources_001.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRSettings_IVRSettings_002.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/cppIVRSystem_IVRSystem_019.cpp

@@ -0,0 +1,265 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRSystem_IVRSystem_019.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+void cppIVRSystem_IVRSystem_019_GetRecommendedRenderTargetSize(void *linux_side, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    ((IVRSystem*)linux_side)->GetRecommendedRenderTargetSize((uint32_t *)pnWidth, (uint32_t *)pnHeight);
+}
+
+vr::HmdMatrix44_t cppIVRSystem_IVRSystem_019_GetProjectionMatrix(void *linux_side, EVREye eEye, float fNearZ, float fFarZ)
+{
+    return ((IVRSystem*)linux_side)->GetProjectionMatrix((vr::EVREye)eEye, (float)fNearZ, (float)fFarZ);
+}
+
+void cppIVRSystem_IVRSystem_019_GetProjectionRaw(void *linux_side, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    ((IVRSystem*)linux_side)->GetProjectionRaw((vr::EVREye)eEye, (float *)pfLeft, (float *)pfRight, (float *)pfTop, (float *)pfBottom);
+}
+
+bool cppIVRSystem_IVRSystem_019_ComputeDistortion(void *linux_side, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    return ((IVRSystem*)linux_side)->ComputeDistortion((vr::EVREye)eEye, (float)fU, (float)fV, (vr::DistortionCoordinates_t *)pDistortionCoordinates);
+}
+
+vr::HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetEyeToHeadTransform(void *linux_side, EVREye eEye)
+{
+    return ((IVRSystem*)linux_side)->GetEyeToHeadTransform((vr::EVREye)eEye);
+}
+
+bool cppIVRSystem_IVRSystem_019_GetTimeSinceLastVsync(void *linux_side, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    return ((IVRSystem*)linux_side)->GetTimeSinceLastVsync((float *)pfSecondsSinceLastVsync, (uint64_t *)pulFrameCounter);
+}
+
+int32_t cppIVRSystem_IVRSystem_019_GetD3D9AdapterIndex(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->GetD3D9AdapterIndex();
+}
+
+void cppIVRSystem_IVRSystem_019_GetDXGIOutputInfo(void *linux_side, int32_t * pnAdapterIndex)
+{
+    ((IVRSystem*)linux_side)->GetDXGIOutputInfo((int32_t *)pnAdapterIndex);
+}
+
+void cppIVRSystem_IVRSystem_019_GetOutputDevice(void *linux_side, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
+{
+    ((IVRSystem*)linux_side)->GetOutputDevice((uint64_t *)pnDevice, (vr::ETextureType)textureType, (VkInstance_T *)pInstance);
+}
+
+bool cppIVRSystem_IVRSystem_019_IsDisplayOnDesktop(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->IsDisplayOnDesktop();
+}
+
+bool cppIVRSystem_IVRSystem_019_SetDisplayVisibility(void *linux_side, bool bIsVisibleOnDesktop)
+{
+    return ((IVRSystem*)linux_side)->SetDisplayVisibility((bool)bIsVisibleOnDesktop);
+}
+
+void cppIVRSystem_IVRSystem_019_GetDeviceToAbsoluteTrackingPose(void *linux_side, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    ((IVRSystem*)linux_side)->GetDeviceToAbsoluteTrackingPose((vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsToPhotonsFromNow, (vr::TrackedDevicePose_t *)pTrackedDevicePoseArray, (uint32_t)unTrackedDevicePoseArrayCount);
+}
+
+void cppIVRSystem_IVRSystem_019_ResetSeatedZeroPose(void *linux_side)
+{
+    ((IVRSystem*)linux_side)->ResetSeatedZeroPose();
+}
+
+vr::HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->GetSeatedZeroPoseToStandingAbsoluteTrackingPose();
+}
+
+vr::HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->GetRawZeroPoseToStandingAbsoluteTrackingPose();
+}
+
+uint32_t cppIVRSystem_IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass(void *linux_side, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->GetSortedTrackedDeviceIndicesOfClass((vr::ETrackedDeviceClass)eTrackedDeviceClass, (vr::TrackedDeviceIndex_t *)punTrackedDeviceIndexArray, (uint32_t)unTrackedDeviceIndexArrayCount, (vr::TrackedDeviceIndex_t)unRelativeToTrackedDeviceIndex);
+}
+
+vr::EDeviceActivityLevel cppIVRSystem_IVRSystem_019_GetTrackedDeviceActivityLevel(void *linux_side, TrackedDeviceIndex_t unDeviceId)
+{
+    return ((IVRSystem*)linux_side)->GetTrackedDeviceActivityLevel((vr::TrackedDeviceIndex_t)unDeviceId);
+}
+
+void cppIVRSystem_IVRSystem_019_ApplyTransform(void *linux_side, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    ((IVRSystem*)linux_side)->ApplyTransform((vr::TrackedDevicePose_t *)pOutputPose, (const vr::TrackedDevicePose_t *)pTrackedDevicePose, (const vr::HmdMatrix34_t *)pTransform);
+}
+
+vr::TrackedDeviceIndex_t cppIVRSystem_IVRSystem_019_GetTrackedDeviceIndexForControllerRole(void *linux_side, ETrackedControllerRole unDeviceType)
+{
+    return ((IVRSystem*)linux_side)->GetTrackedDeviceIndexForControllerRole((vr::ETrackedControllerRole)unDeviceType);
+}
+
+vr::ETrackedControllerRole cppIVRSystem_IVRSystem_019_GetControllerRoleForTrackedDeviceIndex(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->GetControllerRoleForTrackedDeviceIndex((vr::TrackedDeviceIndex_t)unDeviceIndex);
+}
+
+vr::ETrackedDeviceClass cppIVRSystem_IVRSystem_019_GetTrackedDeviceClass(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->GetTrackedDeviceClass((vr::TrackedDeviceIndex_t)unDeviceIndex);
+}
+
+bool cppIVRSystem_IVRSystem_019_IsTrackedDeviceConnected(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->IsTrackedDeviceConnected((vr::TrackedDeviceIndex_t)unDeviceIndex);
+}
+
+bool cppIVRSystem_IVRSystem_019_GetBoolTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetBoolTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+float cppIVRSystem_IVRSystem_019_GetFloatTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetFloatTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+int32_t cppIVRSystem_IVRSystem_019_GetInt32TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetInt32TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+uint64_t cppIVRSystem_IVRSystem_019_GetUint64TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetUint64TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+vr::HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetMatrix34TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetMatrix34TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+uint32_t cppIVRSystem_IVRSystem_019_GetArrayTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetArrayTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::PropertyTypeTag_t)propType, (void *)pBuffer, (uint32_t)unBufferSize, (vr::ETrackedPropertyError *)pError);
+}
+
+uint32_t cppIVRSystem_IVRSystem_019_GetStringTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetStringTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (char *)pchValue, (uint32_t)unBufferSize, (vr::ETrackedPropertyError *)pError);
+}
+
+const char * cppIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(void *linux_side, ETrackedPropertyError error)
+{
+    return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
+}
+
+bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *linux_side, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent)
+{
+    VREvent_t lin;
+    bool _ret;
+    _ret = ((IVRSystem*)linux_side)->PollNextEvent(&lin, sizeof(lin));
+    struct_VREvent_t_1012_lin_to_win(&lin, pEvent);
+    return _ret;
+}
+
+bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1012 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    VREvent_t lin;
+    bool _ret;
+    _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, &lin, sizeof(lin), (vr::TrackedDevicePose_t *)pTrackedDevicePose);
+    struct_VREvent_t_1012_lin_to_win(&lin, pEvent);
+    return _ret;
+}
+
+const char * cppIVRSystem_IVRSystem_019_GetEventTypeNameFromEnum(void *linux_side, EVREventType eType)
+{
+    return ((IVRSystem*)linux_side)->GetEventTypeNameFromEnum((vr::EVREventType)eType);
+}
+
+vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_019_GetHiddenAreaMesh(void *linux_side, EVREye eEye, EHiddenAreaMeshType type)
+{
+    return ((IVRSystem*)linux_side)->GetHiddenAreaMesh((vr::EVREye)eEye, (vr::EHiddenAreaMeshType)type);
+}
+
+bool cppIVRSystem_IVRSystem_019_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1012 * pControllerState, uint32_t unControllerStateSize)
+{
+    VRControllerState001_t lin;
+    bool _ret;
+    _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, &lin, (uint32_t)unControllerStateSize);
+    struct_VRControllerState001_t_1012_lin_to_win(&lin, pControllerState);
+    return _ret;
+}
+
+bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1012 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    VRControllerState001_t lin;
+    bool _ret;
+    _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, &lin, (uint32_t)unControllerStateSize, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
+    struct_VRControllerState001_t_1012_lin_to_win(&lin, pControllerState);
+    return _ret;
+}
+
+void cppIVRSystem_IVRSystem_019_TriggerHapticPulse(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    ((IVRSystem*)linux_side)->TriggerHapticPulse((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, (uint32_t)unAxisId, (unsigned short)usDurationMicroSec);
+}
+
+const char * cppIVRSystem_IVRSystem_019_GetButtonIdNameFromEnum(void *linux_side, EVRButtonId eButtonId)
+{
+    return ((IVRSystem*)linux_side)->GetButtonIdNameFromEnum((vr::EVRButtonId)eButtonId);
+}
+
+const char * cppIVRSystem_IVRSystem_019_GetControllerAxisTypeNameFromEnum(void *linux_side, EVRControllerAxisType eAxisType)
+{
+    return ((IVRSystem*)linux_side)->GetControllerAxisTypeNameFromEnum((vr::EVRControllerAxisType)eAxisType);
+}
+
+bool cppIVRSystem_IVRSystem_019_IsInputAvailable(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->IsInputAvailable();
+}
+
+bool cppIVRSystem_IVRSystem_019_IsSteamVRDrawingControllers(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->IsSteamVRDrawingControllers();
+}
+
+bool cppIVRSystem_IVRSystem_019_ShouldApplicationPause(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->ShouldApplicationPause();
+}
+
+bool cppIVRSystem_IVRSystem_019_ShouldApplicationReduceRenderingWork(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->ShouldApplicationReduceRenderingWork();
+}
+
+uint32_t cppIVRSystem_IVRSystem_019_DriverDebugRequest(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, const char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize)
+{
+    return ((IVRSystem*)linux_side)->DriverDebugRequest((vr::TrackedDeviceIndex_t)unDeviceIndex, (const char *)pchRequest, (char *)pchResponseBuffer, (uint32_t)unResponseBufferSize);
+}
+
+vr::EVRFirmwareError cppIVRSystem_IVRSystem_019_PerformFirmwareUpdate(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->PerformFirmwareUpdate((vr::TrackedDeviceIndex_t)unDeviceIndex);
+}
+
+void cppIVRSystem_IVRSystem_019_AcknowledgeQuit_Exiting(void *linux_side)
+{
+    ((IVRSystem*)linux_side)->AcknowledgeQuit_Exiting();
+}
+
+void cppIVRSystem_IVRSystem_019_AcknowledgeQuit_UserPrompt(void *linux_side)
+{
+    ((IVRSystem*)linux_side)->AcknowledgeQuit_UserPrompt();
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/cppIVRSystem_IVRSystem_019.h

@@ -0,0 +1,53 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void cppIVRSystem_IVRSystem_019_GetRecommendedRenderTargetSize(void *, uint32_t *, uint32_t *);
+extern HmdMatrix44_t cppIVRSystem_IVRSystem_019_GetProjectionMatrix(void *, EVREye, float, float);
+extern void cppIVRSystem_IVRSystem_019_GetProjectionRaw(void *, EVREye, float *, float *, float *, float *);
+extern bool cppIVRSystem_IVRSystem_019_ComputeDistortion(void *, EVREye, float, float, DistortionCoordinates_t *);
+extern HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetEyeToHeadTransform(void *, EVREye);
+extern bool cppIVRSystem_IVRSystem_019_GetTimeSinceLastVsync(void *, float *, uint64_t *);
+extern int32_t cppIVRSystem_IVRSystem_019_GetD3D9AdapterIndex(void *);
+extern void cppIVRSystem_IVRSystem_019_GetDXGIOutputInfo(void *, int32_t *);
+extern void cppIVRSystem_IVRSystem_019_GetOutputDevice(void *, uint64_t *, ETextureType, VkInstance_T *);
+extern bool cppIVRSystem_IVRSystem_019_IsDisplayOnDesktop(void *);
+extern bool cppIVRSystem_IVRSystem_019_SetDisplayVisibility(void *, bool);
+extern void cppIVRSystem_IVRSystem_019_GetDeviceToAbsoluteTrackingPose(void *, ETrackingUniverseOrigin, float, TrackedDevicePose_t *, uint32_t);
+extern void cppIVRSystem_IVRSystem_019_ResetSeatedZeroPose(void *);
+extern HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *);
+extern HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *);
+extern uint32_t cppIVRSystem_IVRSystem_019_GetSortedTrackedDeviceIndicesOfClass(void *, ETrackedDeviceClass, TrackedDeviceIndex_t *, uint32_t, TrackedDeviceIndex_t);
+extern EDeviceActivityLevel cppIVRSystem_IVRSystem_019_GetTrackedDeviceActivityLevel(void *, TrackedDeviceIndex_t);
+extern void cppIVRSystem_IVRSystem_019_ApplyTransform(void *, TrackedDevicePose_t *, TrackedDevicePose_t *, HmdMatrix34_t *);
+extern TrackedDeviceIndex_t cppIVRSystem_IVRSystem_019_GetTrackedDeviceIndexForControllerRole(void *, ETrackedControllerRole);
+extern ETrackedControllerRole cppIVRSystem_IVRSystem_019_GetControllerRoleForTrackedDeviceIndex(void *, TrackedDeviceIndex_t);
+extern ETrackedDeviceClass cppIVRSystem_IVRSystem_019_GetTrackedDeviceClass(void *, TrackedDeviceIndex_t);
+extern bool cppIVRSystem_IVRSystem_019_IsTrackedDeviceConnected(void *, TrackedDeviceIndex_t);
+extern bool cppIVRSystem_IVRSystem_019_GetBoolTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern float cppIVRSystem_IVRSystem_019_GetFloatTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern int32_t cppIVRSystem_IVRSystem_019_GetInt32TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern uint64_t cppIVRSystem_IVRSystem_019_GetUint64TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern HmdMatrix34_t cppIVRSystem_IVRSystem_019_GetMatrix34TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern uint32_t cppIVRSystem_IVRSystem_019_GetArrayTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, PropertyTypeTag_t, void *, uint32_t, ETrackedPropertyError *);
+extern uint32_t cppIVRSystem_IVRSystem_019_GetStringTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, char *, uint32_t, ETrackedPropertyError *);
+extern const char * cppIVRSystem_IVRSystem_019_GetPropErrorNameFromEnum(void *, ETrackedPropertyError);
+extern bool cppIVRSystem_IVRSystem_019_PollNextEvent(void *, winVREvent_t_1012 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_019_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1012 *, uint32_t, TrackedDevicePose_t *);
+extern const char * cppIVRSystem_IVRSystem_019_GetEventTypeNameFromEnum(void *, EVREventType);
+extern HiddenAreaMesh_t cppIVRSystem_IVRSystem_019_GetHiddenAreaMesh(void *, EVREye, EHiddenAreaMeshType);
+extern bool cppIVRSystem_IVRSystem_019_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1012 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_019_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1012 *, uint32_t, TrackedDevicePose_t *);
+extern void cppIVRSystem_IVRSystem_019_TriggerHapticPulse(void *, TrackedDeviceIndex_t, uint32_t, unsigned short);
+extern const char * cppIVRSystem_IVRSystem_019_GetButtonIdNameFromEnum(void *, EVRButtonId);
+extern const char * cppIVRSystem_IVRSystem_019_GetControllerAxisTypeNameFromEnum(void *, EVRControllerAxisType);
+extern bool cppIVRSystem_IVRSystem_019_IsInputAvailable(void *);
+extern bool cppIVRSystem_IVRSystem_019_IsSteamVRDrawingControllers(void *);
+extern bool cppIVRSystem_IVRSystem_019_ShouldApplicationPause(void *);
+extern bool cppIVRSystem_IVRSystem_019_ShouldApplicationReduceRenderingWork(void *);
+extern uint32_t cppIVRSystem_IVRSystem_019_DriverDebugRequest(void *, TrackedDeviceIndex_t, const char *, char *, uint32_t);
+extern EVRFirmwareError cppIVRSystem_IVRSystem_019_PerformFirmwareUpdate(void *, TrackedDeviceIndex_t);
+extern void cppIVRSystem_IVRSystem_019_AcknowledgeQuit_Exiting(void *);
+extern void cppIVRSystem_IVRSystem_019_AcknowledgeQuit_UserPrompt(void *);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_003.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.0.11/ivrclientcore.h"
+#include "openvr_v1.0.12/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"

vrclient_x64/gen_wrapper.py

@@ -10,6 +10,7 @@ import os
 import re
 
 sdk_versions = [
+    "v1.0.12",
     "v1.0.11",
     "v1.0.10",
     "v1.0.9",

vrclient_x64/openvr_v1.0.12/ivrclientcore.h

@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation ============//
+
+#include "openvr.h"
+
+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";
+
+
+}