vrclient: Support v1.26.7.

CW-Bug-Id: #22757

openvr

@@ -1 +1 @@
-Subproject commit 08de3821dfd3aa46f778376680c68f33b9fdcb6c
+Subproject commit 5e45960cf44d6eb19bbadcae4a3d32578a380c17

vrclient_x64/gen_wrapper.py

@@ -14,6 +14,7 @@ import os
 import re
 
 sdk_versions = [
+    "v1.26.7",
     "v1.23.7",
     "v1.16.8",
     "v1.14.15",
@@ -379,7 +380,8 @@ def ivroverlay_set_overlay_texture(cppname, method):
             "022" in cppname or \
             "024" in cppname or \
             "025" in cppname or \
-            "026" in cppname
+            "026" in cppname or \
+            "027" in cppname
     return "ivroverlay_set_overlay_texture"
 
 def ivrinput_get_digital_action_data(cppname, method):

vrclient_x64/openvr_v1.26.7/ivrclientcore.h

@@ -0,0 +1,35 @@
+//========= 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";
+
+
+}

vrclient_x64/tests/capi_thunks_autogen.h

@@ -383,171 +383,167 @@ EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_t
 
 EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
 
-void test_capi_thunks_IVROverlay_026(void);
+void test_capi_thunks_IVROverlay_027(void);
 
-EVROverlayError __thiscall IVROverlay_026_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_026_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_026_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-uint32_t __thiscall IVROverlay_026_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+uint32_t __thiscall IVROverlay_027_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
 
-uint32_t __thiscall IVROverlay_026_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+uint32_t __thiscall IVROverlay_027_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
 
-const char * __thiscall IVROverlay_026_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+const char * __thiscall IVROverlay_027_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
 
-uint32_t __thiscall IVROverlay_026_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+uint32_t __thiscall IVROverlay_027_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+EVROverlayError __thiscall IVROverlay_027_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+EVROverlayError __thiscall IVROverlay_027_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float fRadians);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float fRadians);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
+EVROverlayError __thiscall IVROverlay_027_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
+EVROverlayError __thiscall IVROverlay_027_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_026_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+bool __thiscall IVROverlay_027_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_026_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
 
-bool __thiscall IVROverlay_026_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_WaitFrameSync(void *_this, uint32_t nTimeoutMs);
 
-EVROverlayError __thiscall IVROverlay_026_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+bool __thiscall IVROverlay_027_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
 
-EVROverlayError __thiscall IVROverlay_026_WaitFrameSync(void *_this, uint32_t nTimeoutMs);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
 
-bool __thiscall IVROverlay_026_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+bool __thiscall IVROverlay_027_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+bool __thiscall IVROverlay_027_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-bool __thiscall IVROverlay_026_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
 
-bool __thiscall IVROverlay_026_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
 
-EVROverlayError __thiscall IVROverlay_026_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
+EVROverlayError __thiscall IVROverlay_027_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
 
-EVROverlayError __thiscall IVROverlay_026_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
 
-EVROverlayError __thiscall IVROverlay_026_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
 
-EVROverlayError __thiscall IVROverlay_026_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+EVROverlayError __thiscall IVROverlay_027_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
+EVROverlayError __thiscall IVROverlay_027_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
 
-EVROverlayError __thiscall IVROverlay_026_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+EVROverlayError __thiscall IVROverlay_027_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
 
-EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+bool __thiscall IVROverlay_027_IsDashboardVisible(void *_this);
 
-EVROverlayError __thiscall IVROverlay_026_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+bool __thiscall IVROverlay_027_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-bool __thiscall IVROverlay_026_IsDashboardVisible(void *_this);
+EVROverlayError __thiscall IVROverlay_027_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
 
-bool __thiscall IVROverlay_026_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_027_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
 
-EVROverlayError __thiscall IVROverlay_026_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+void __thiscall IVROverlay_027_ShowDashboard(void *_this, const char * pchOverlayToShow);
 
-EVROverlayError __thiscall IVROverlay_026_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+TrackedDeviceIndex_t __thiscall IVROverlay_027_GetPrimaryDashboardDevice(void *_this);
 
-void __thiscall IVROverlay_026_ShowDashboard(void *_this, const char * pchOverlayToShow);
+EVROverlayError __thiscall IVROverlay_027_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
 
-TrackedDeviceIndex_t __thiscall IVROverlay_026_GetPrimaryDashboardDevice(void *_this);
+EVROverlayError __thiscall IVROverlay_027_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
 
-EVROverlayError __thiscall IVROverlay_026_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
+uint32_t __thiscall IVROverlay_027_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
 
-EVROverlayError __thiscall IVROverlay_026_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
+void __thiscall IVROverlay_027_HideKeyboard(void *_this);
 
-uint32_t __thiscall IVROverlay_026_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+void __thiscall IVROverlay_027_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
 
-void __thiscall IVROverlay_026_HideKeyboard(void *_this);
+void __thiscall IVROverlay_027_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
 
-void __thiscall IVROverlay_026_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+VRMessageOverlayResponse __thiscall IVROverlay_027_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
 
-void __thiscall IVROverlay_026_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+void __thiscall IVROverlay_027_CloseMessageOverlay(void *_this);
-
-VRMessageOverlayResponse __thiscall IVROverlay_026_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
-
-void __thiscall IVROverlay_026_CloseMessageOverlay(void *_this);
 
 void test_capi_thunks_IVROverlayView_003(void);
 
@@ -765,6 +761,172 @@ const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_thi
 
 const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
 
+void test_capi_thunks_IVROverlay_026(void);
+
+EVROverlayError __thiscall IVROverlay_026_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+uint32_t __thiscall IVROverlay_026_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_026_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_026_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_026_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float fRadians);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayPreCurvePitch(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
+
+EVROverlayError __thiscall IVROverlay_026_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_026_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+EVROverlayError __thiscall IVROverlay_026_WaitFrameSync(void *_this, uint32_t nTimeoutMs);
+
+bool __thiscall IVROverlay_026_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_026_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_026_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+
+EVROverlayError __thiscall IVROverlay_026_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
+
+EVROverlayError __thiscall IVROverlay_026_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_026_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
+
+EVROverlayError __thiscall IVROverlay_026_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_026_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_026_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_026_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_026_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_026_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_026_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_026_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_026_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_026_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_026_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_026_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_026_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_026_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_026_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_026_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+VRMessageOverlayResponse __thiscall IVROverlay_026_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+
+void __thiscall IVROverlay_026_CloseMessageOverlay(void *_this);
+
 void test_capi_thunks_IVROverlay_025(void);
 
 EVROverlayError __thiscall IVROverlay_025_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);

vrclient_x64/tests/main_autogen.c

@@ -13,7 +13,7 @@ int main(void)
     test_capi_thunks_IVRCompositor_027();
     test_capi_thunks_IVRHeadsetView_001();
     test_capi_thunks_IVRNotifications_002();
-    test_capi_thunks_IVROverlay_026();
+    test_capi_thunks_IVROverlay_027();
     test_capi_thunks_IVROverlayView_003();
     test_capi_thunks_IVRRenderModels_006();
     test_capi_thunks_IVRExtendedDisplay_001();
@@ -24,6 +24,7 @@ int main(void)
     test_capi_thunks_IVRInput_010();
     test_capi_thunks_IVRIOBuffer_002();
     test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVROverlay_026();
     test_capi_thunks_IVROverlay_025();
     test_capi_thunks_IVRCompositor_026();
     test_capi_thunks_IVROverlay_024();

vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp

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

vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_004.cpp

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

vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp

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

vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.cpp

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

vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp

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

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.23.7/ivrclientcore.h"
+#include "openvr_v1.26.7/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -34,63 +34,63 @@ vr::EVRInputError cppIVRInput_IVRInput_010_UpdateActionState(void *linux_side, V
     return ((IVRInput*)linux_side)->UpdateActionState((vr::VRActiveActionSet_t *)pSets, (uint32_t)unSizeOfVRSelectedActionSet_t, (uint32_t)unSetCount);
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputDigitalActionData_t_1237_win_to_lin(pActionData, &lin);
+        struct_InputDigitalActionData_t_1267_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetDigitalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
     if(pActionData)
-        struct_InputDigitalActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputDigitalActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputAnalogActionData_t_1237_win_to_lin(pActionData, &lin);
+        struct_InputAnalogActionData_t_1267_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetAnalogActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
     if(pActionData)
-        struct_InputAnalogActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputAnalogActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputPoseActionData_t_1237_win_to_lin(pActionData, &lin);
+        struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetPoseActionDataRelativeToNow((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsFromNow, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
     if(pActionData)
-        struct_InputPoseActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputPoseActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputPoseActionData_t_1237_win_to_lin(pActionData, &lin);
+        struct_InputPoseActionData_t_1267_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetPoseActionDataForNextFrame((vr::VRActionHandle_t)action, (vr::ETrackingUniverseOrigin)eOrigin, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0, (vr::VRInputValueHandle_t)ulRestrictToDevice);
     if(pActionData)
-        struct_InputPoseActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputPoseActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1237 * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1267 * pActionData, uint32_t unActionDataSize)
 {
     InputSkeletalActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputSkeletalActionData_t_1237_win_to_lin(pActionData, &lin);
+        struct_InputSkeletalActionData_t_1267_win_to_lin(pActionData, &lin);
     _ret = ((IVRInput*)linux_side)->GetSkeletalActionData((vr::VRActionHandle_t)action, pActionData ? &lin : nullptr, unActionDataSize ? sizeof(lin) : 0);
     if(pActionData)
-        struct_InputSkeletalActionData_t_1237_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputSkeletalActionData_t_1267_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.h

@@ -6,11 +6,11 @@ extern EVRInputError cppIVRInput_IVRInput_010_GetActionSetHandle(void *, const c
 extern EVRInputError cppIVRInput_IVRInput_010_GetActionHandle(void *, const char *, VRActionHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_010_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_010_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1237 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1267 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1237 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1267 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1237 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1267 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1237 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1267 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1237 *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1267 *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_010_GetDominantHand(void *, ETrackedControllerRole *);
 extern EVRInputError cppIVRInput_IVRInput_010_SetDominantHand(void *, ETrackedControllerRole);
 extern EVRInputError cppIVRInput_IVRInput_010_GetBoneCount(void *, VRActionHandle_t, uint32_t *);

vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp

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

vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.23.7/ivrclientcore.h"
+#include "openvr_v1.26.7/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -23,7 +23,7 @@ void cppIVROverlayView_IVROverlayView_003_PostOverlayEvent(void *linux_side, VRO
 {
     VREvent_t lin;
     if(pvrEvent)
-        struct_VREvent_t_1237_win_to_lin(pvrEvent, &lin);
+        struct_VREvent_t_1267_win_to_lin(pvrEvent, &lin);
     ((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin : nullptr);
 }
 

vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_027.cpp

@@ -0,0 +1,421 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.26.7/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVROverlay_IVROverlay_027.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_DestroyOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->DestroyOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+uint32_t cppIVROverlay_IVROverlay_027_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_027_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_027_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_027_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_027_GetOverlayErrorNameFromEnum(void *linux_side, EVROverlayError error)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayErrorNameFromEnum((vr::EVROverlayError)error);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_GetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_GetOverlayFlags(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayFlags((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)pFlags);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_SetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float)fAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float)fTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_SetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float)fCurvature);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfCurvature);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fRadians)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayPreCurvePitch((vr::VROverlayHandle_t)ulOverlayHandle, (float)fRadians);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfRadians)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayPreCurvePitch((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfRadians);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_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_027_GetOverlayTextureBounds(void *linux_side, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTextureBounds((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VRTextureBounds_t *)pOverlayTextureBounds);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_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_027_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_027_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_027_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_027_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_027_SetOverlayTransformCursor(void *linux_side, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTransformCursor((vr::VROverlayHandle_t)ulCursorOverlayHandle, (const vr::HmdVector2_t *)pvHotspot);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformCursor(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTransformCursor((vr::VROverlayHandle_t)ulOverlayHandle, (vr::HmdVector2_t *)pvHotspot);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformProjection(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTransformProjection((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToOverlayTransform, (const vr::VROverlayProjection_t *)pProjection, (vr::EVREye)eEye);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_ShowOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ShowOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_HideOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->HideOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+bool cppIVROverlay_IVROverlay_027_IsOverlayVisible(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsOverlayVisible((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_WaitFrameSync(void *linux_side, uint32_t nTimeoutMs)
+{
+    return ((IVROverlay*)linux_side)->WaitFrameSync((uint32_t)nTimeoutMs);
+}
+
+bool cppIVROverlay_IVROverlay_027_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent)
+{
+    VREvent_t lin;
+    bool _ret;
+    if(pEvent)
+        struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
+    _ret = ((IVROverlay*)linux_side)->PollNextOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
+    if(pEvent)
+        struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent);
+    return _ret;
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_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_027_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_027_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_027_IsHoverTargetOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsHoverTargetOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_TriggerLaserMouseHapticVibration(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
+{
+    return ((IVROverlay*)linux_side)->TriggerLaserMouseHapticVibration((vr::VROverlayHandle_t)ulOverlayHandle, (float)fDurationSeconds, (float)fFrequency, (float)fAmplitude);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCursor(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayCursor((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayHandle_t)ulCursorHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayCursorPositionOverride((vr::VROverlayHandle_t)ulOverlayHandle, (const vr::HmdVector2_t *)pvCursor);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ClearOverlayCursorPositionOverride((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_ClearOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ClearOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayRaw(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayRaw((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pvBuffer, (uint32_t)unWidth, (uint32_t)unHeight, (uint32_t)unBytesPerPixel);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_ReleaseNativeOverlayHandle(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    return ((IVROverlay*)linux_side)->ReleaseNativeOverlayHandle((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pNativeTextureHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_IsDashboardVisible(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->IsDashboardVisible();
+}
+
+bool cppIVROverlay_IVROverlay_027_IsActiveDashboardOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsActiveDashboardOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_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_027_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_027_ShowDashboard(void *linux_side, const char * pchOverlayToShow)
+{
+    ((IVROverlay*)linux_side)->ShowDashboard((const char *)pchOverlayToShow);
+}
+
+vr::TrackedDeviceIndex_t cppIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->GetPrimaryDashboardDevice();
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_ShowKeyboard(void *linux_side, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
+{
+    return ((IVROverlay*)linux_side)->ShowKeyboard((vr::EGamepadTextInputMode)eInputMode, (vr::EGamepadTextInputLineMode)eLineInputMode, (uint32_t)unFlags, (const char *)pchDescription, (uint32_t)unCharMax, (const char *)pchExistingText, (uint64_t)uUserValue);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_027_ShowKeyboardForOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
+{
+    return ((IVROverlay*)linux_side)->ShowKeyboardForOverlay((vr::VROverlayHandle_t)ulOverlayHandle, (vr::EGamepadTextInputMode)eInputMode, (vr::EGamepadTextInputLineMode)eLineInputMode, (uint32_t)unFlags, (const char *)pchDescription, (uint32_t)unCharMax, (const char *)pchExistingText, (uint64_t)uUserValue);
+}
+
+uint32_t cppIVROverlay_IVROverlay_027_GetKeyboardText(void *linux_side, char * pchText, uint32_t cchText)
+{
+    return ((IVROverlay*)linux_side)->GetKeyboardText((char *)pchText, (uint32_t)cchText);
+}
+
+void cppIVROverlay_IVROverlay_027_HideKeyboard(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->HideKeyboard();
+}
+
+void cppIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute(void *linux_side, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    ((IVROverlay*)linux_side)->SetKeyboardTransformAbsolute((vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToKeyboardTransform);
+}
+
+void cppIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    ((IVROverlay*)linux_side)->SetKeyboardPositionForOverlay((vr::VROverlayHandle_t)ulOverlayHandle, (vr::HmdRect2_t)avoidRect);
+}
+
+vr::VRMessageOverlayResponse cppIVROverlay_IVROverlay_027_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_027_CloseMessageOverlay(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->CloseMessageOverlay();
+}
+
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_027.h

@@ -0,0 +1,86 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVROverlayError cppIVROverlay_IVROverlay_027_FindOverlay(void *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_CreateOverlay(void *, const char *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_DestroyOverlay(void *, VROverlayHandle_t);
+extern uint32_t cppIVROverlay_IVROverlay_027_GetOverlayKey(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern uint32_t cppIVROverlay_IVROverlay_027_GetOverlayName(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayName(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayImageData(void *, VROverlayHandle_t, void *, uint32_t, uint32_t *, uint32_t *);
+extern const char * cppIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum(void *, EVROverlayError);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayRenderingPid(void *, VROverlayHandle_t, uint32_t);
+extern uint32_t cppIVROverlay_IVROverlay_027_GetOverlayRenderingPid(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayFlags(void *, VROverlayHandle_t, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayColor(void *, VROverlayHandle_t, float, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayColor(void *, VROverlayHandle_t, float *, float *, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayAlpha(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayAlpha(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTexelAspect(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTexelAspect(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayWidthInMeters(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayWidthInMeters(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCurvature(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayCurvature(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformType(void *, VROverlayHandle_t, VROverlayTransformType *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, char *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTransformProjection(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *, VROverlayProjection_t *, EVREye);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_ShowOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_HideOverlay(void *, VROverlayHandle_t);
+extern bool cppIVROverlay_IVROverlay_027_IsOverlayVisible(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_WaitFrameSync(void *, uint32_t);
+extern bool cppIVROverlay_IVROverlay_027_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1267 *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern bool cppIVROverlay_IVROverlay_027_ComputeOverlayIntersection(void *, VROverlayHandle_t, VROverlayIntersectionParams_t *, VROverlayIntersectionResults_t *);
+extern bool cppIVROverlay_IVROverlay_027_IsHoverTargetOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayIntersectionMask(void *, VROverlayHandle_t, VROverlayIntersectionMaskPrimitive_t *, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration(void *, VROverlayHandle_t, float, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCursor(void *, VROverlayHandle_t, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayTexture(void *, VROverlayHandle_t, Texture_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_ClearOverlayTexture(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayRaw(void *, VROverlayHandle_t, void *, uint32_t, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetOverlayFromFile(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTexture(void *, VROverlayHandle_t, void **, void *, uint32_t *, uint32_t *, uint32_t *, ETextureType *, EColorSpace *, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle(void *, VROverlayHandle_t, void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetOverlayTextureSize(void *, VROverlayHandle_t, uint32_t *, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_CreateDashboardOverlay(void *, const char *, const char *, VROverlayHandle_t *, VROverlayHandle_t *);
+extern bool cppIVROverlay_IVROverlay_027_IsDashboardVisible(void *);
+extern bool cppIVROverlay_IVROverlay_027_IsActiveDashboardOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t *);
+extern void cppIVROverlay_IVROverlay_027_ShowDashboard(void *, const char *);
+extern TrackedDeviceIndex_t cppIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice(void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_ShowKeyboard(void *, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_027_ShowKeyboardForOverlay(void *, VROverlayHandle_t, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
+extern uint32_t cppIVROverlay_IVROverlay_027_GetKeyboardText(void *, char *, uint32_t);
+extern void cppIVROverlay_IVROverlay_027_HideKeyboard(void *);
+extern void cppIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute(void *, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern void cppIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay(void *, VROverlayHandle_t, HmdRect2_t);
+extern VRMessageOverlayResponse cppIVROverlay_IVROverlay_027_ShowMessageOverlay(void *, const char *, const char *, const char *, const char *, const char *, const char *);
+extern void cppIVROverlay_IVROverlay_027_CloseMessageOverlay(void *);
+#ifdef __cplusplus
+}
+#endif

vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.23.7/ivrclientcore.h"
+#include "openvr_v1.26.7/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_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1237 ** ppRenderModel)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1267 ** ppRenderModel)
 {
     RenderModel_t *lin;
     vr::EVRRenderModelError _ret;
     _ret = ((IVRRenderModels*)linux_side)->LoadRenderModel_Async((const char *)pchRenderModelName, ppRenderModel ? &lin : nullptr);
     if(_ret == 0)
-        *ppRenderModel = struct_RenderModel_t_1237_wrap(lin);
+        *ppRenderModel = struct_RenderModel_t_1267_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1237 * pRenderModel)
+void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1267 * pRenderModel)
 {
-    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1237_unwrap(pRenderModel));
+    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1267_unwrap(pRenderModel));
 }
 
-vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1237 ** ppTexture)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1267 ** ppTexture)
 {
     RenderModel_TextureMap_t *lin;
     vr::EVRRenderModelError _ret;
     _ret = ((IVRRenderModels*)linux_side)->LoadTexture_Async((vr::TextureID_t)textureId, ppTexture ? &lin : nullptr);
     if(_ret == 0)
-        *ppTexture = struct_RenderModel_TextureMap_t_1237_wrap(lin);
+        *ppTexture = struct_RenderModel_TextureMap_t_1267_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1237 * pTexture)
+void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1267 * pTexture)
 {
-    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1237_unwrap(pTexture));
+    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1267_unwrap(pTexture));
 }
 
 vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(void *linux_side, TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D)
@@ -94,7 +94,7 @@ bool cppIVRRenderModels_IVRRenderModels_006_GetComponentState(void *linux_side,
     VRControllerState001_t lin;
     bool _ret;
     if(pControllerState)
-        struct_VRControllerState001_t_1237_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
     _ret = ((IVRRenderModels*)linux_side)->GetComponentState((const char *)pchRenderModelName, (const char *)pchComponentName, pControllerState ? &lin : nullptr, (const vr::RenderModel_ControllerMode_State_t *)pState, (vr::RenderModel_ComponentState_t *)pComponentState);
     return _ret;
 }

vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h

@@ -1,10 +1,10 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1237 **);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1267 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1237 *);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1267 *);
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1237 **);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1267 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1237 *);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1267 *);
 extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTextureD3D11_Async(void *, TextureID_t, void *, void **);
 extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadIntoTextureD3D11_Async(void *, TextureID_t, void *);
 extern void cppIVRRenderModels_IVRRenderModels_006_FreeTextureD3D11(void *, void *);

vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp

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

vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_003.cpp

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

vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.23.7/ivrclientcore.h"
+#include "openvr_v1.26.7/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -154,27 +154,27 @@ const char * cppIVRSystem_IVRSystem_022_GetPropErrorNameFromEnum(void *linux_sid
     return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
 }
 
-bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent)
+bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent)
 {
     VREvent_t lin;
     bool _ret;
     if(pEvent)
-        struct_VREvent_t_1237_win_to_lin(pEvent, &lin);
+        struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
     _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
     if(pEvent)
-        struct_VREvent_t_1237_lin_to_win(&lin, pEvent, uncbVREvent);
+        struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
 {
     VREvent_t lin;
     bool _ret;
     if(pEvent)
-        struct_VREvent_t_1237_win_to_lin(pEvent, &lin);
+        struct_VREvent_t_1267_win_to_lin(pEvent, &lin);
     _ret = ((IVRSystem*)linux_side)->PollNextEventWithPose((vr::ETrackingUniverseOrigin)eOrigin, pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
     if(pEvent)
-        struct_VREvent_t_1237_lin_to_win(&lin, pEvent, uncbVREvent);
+        struct_VREvent_t_1267_lin_to_win(&lin, pEvent, uncbVREvent);
     return _ret;
 }
 
@@ -188,27 +188,27 @@ vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_022_GetHiddenAreaMesh(void *linux_si
     return ((IVRSystem*)linux_side)->GetHiddenAreaMesh((vr::EVREye)eEye, (vr::EHiddenAreaMeshType)type);
 }
 
-bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize)
+bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 * pControllerState, uint32_t unControllerStateSize)
 {
     VRControllerState001_t lin;
     bool _ret;
     if(pControllerState)
-        struct_VRControllerState001_t_1237_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
     _ret = ((IVRSystem*)linux_side)->GetControllerState((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, unControllerStateSize ? sizeof(lin) : 0);
     if(pControllerState)
-        struct_VRControllerState001_t_1237_lin_to_win(&lin, pControllerState, unControllerStateSize);
+        struct_VRControllerState001_t_1267_lin_to_win(&lin, pControllerState, unControllerStateSize);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     VRControllerState001_t lin;
     bool _ret;
     if(pControllerState)
-        struct_VRControllerState001_t_1237_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_1267_win_to_lin(pControllerState, &lin);
     _ret = ((IVRSystem*)linux_side)->GetControllerStateWithPose((vr::ETrackingUniverseOrigin)eOrigin, (vr::TrackedDeviceIndex_t)unControllerDeviceIndex, pControllerState ? &lin : nullptr, unControllerStateSize ? sizeof(lin) : 0, (vr::TrackedDevicePose_t *)pTrackedDevicePose);
     if(pControllerState)
-        struct_VRControllerState001_t_1237_lin_to_win(&lin, pControllerState, unControllerStateSize);
+        struct_VRControllerState001_t_1267_lin_to_win(&lin, pControllerState, unControllerStateSize);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.h

@@ -30,12 +30,12 @@ extern HmdMatrix34_t cppIVRSystem_IVRSystem_022_GetMatrix34TrackedDeviceProperty
 extern uint32_t cppIVRSystem_IVRSystem_022_GetArrayTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, PropertyTypeTag_t, void *, uint32_t, ETrackedPropertyError *);
 extern uint32_t cppIVRSystem_IVRSystem_022_GetStringTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, char *, uint32_t, ETrackedPropertyError *);
 extern const char * cppIVRSystem_IVRSystem_022_GetPropErrorNameFromEnum(void *, ETrackedPropertyError);
-extern bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *, winVREvent_t_1237 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *, winVREvent_t_1267 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1237 *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1267 *, uint32_t, TrackedDevicePose_t *);
 extern const char * cppIVRSystem_IVRSystem_022_GetEventTypeNameFromEnum(void *, EVREventType);
 extern HiddenAreaMesh_t cppIVRSystem_IVRSystem_022_GetHiddenAreaMesh(void *, EVREye, EHiddenAreaMeshType);
-extern bool cppIVRSystem_IVRSystem_022_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1237 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_022_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1267 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1237 *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1267 *, uint32_t, TrackedDevicePose_t *);
 extern void cppIVRSystem_IVRSystem_022_TriggerHapticPulse(void *, TrackedDeviceIndex_t, uint32_t, unsigned short);
 extern const char * cppIVRSystem_IVRSystem_022_GetButtonIdNameFromEnum(void *, EVRButtonId);
 extern const char * cppIVRSystem_IVRSystem_022_GetControllerAxisTypeNameFromEnum(void *, EVRControllerAxisType);

vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp

@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.23.7/ivrclientcore.h"
+#include "openvr_v1.26.7/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -44,15 +44,15 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_ReleaseVideoS
     return ((IVRTrackedCamera*)linux_side)->ReleaseVideoStreamingService((vr::TrackedCameraHandle_t)hTrackedCamera);
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1237_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
     _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamFrameBuffer((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pFrameBuffer, (uint32_t)nFrameBufferSize, pFrameHeader ? &lin : nullptr, nFrameHeaderSize ? sizeof(lin) : 0);
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1237_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
     return _ret;
 }
 
@@ -61,27 +61,27 @@ vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStrea
     return ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureSize((vr::TrackedDeviceIndex_t)nDeviceIndex, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::VRTextureBounds_t *)pTextureBounds, (uint32_t *)pnWidth, (uint32_t *)pnHeight);
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1237_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
     _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureD3D11((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView, pFrameHeader ? &lin : nullptr, nFrameHeaderSize ? sizeof(lin) : 0);
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1237_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
     return _ret;
 }
 
-vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1237_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(pFrameHeader, &lin);
     _ret = ((IVRTrackedCamera*)linux_side)->GetVideoStreamTextureGL((vr::TrackedCameraHandle_t)hTrackedCamera, (vr::EVRTrackedCameraFrameType)eFrameType, (vr::glUInt_t *)pglTextureId, pFrameHeader ? &lin : nullptr, nFrameHeaderSize ? sizeof(lin) : 0);
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1237_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
     return _ret;
 }
 

vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.h

@@ -8,10 +8,10 @@ extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetCameraI
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetCameraProjection(void *, TrackedDeviceIndex_t, uint32_t, EVRTrackedCameraFrameType, float, float, HmdMatrix44_t *);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_AcquireVideoStreamingService(void *, TrackedDeviceIndex_t, TrackedCameraHandle_t *);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_ReleaseVideoStreamingService(void *, TrackedCameraHandle_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1237 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1267 *, uint32_t);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureSize(void *, TrackedDeviceIndex_t, EVRTrackedCameraFrameType, VRTextureBounds_t *, uint32_t *, uint32_t *);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_1237 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_1267 *, uint32_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1237 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1267 *, uint32_t);
 extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_ReleaseVideoStreamTextureGL(void *, TrackedCameraHandle_t, glUInt_t);
 extern void cppIVRTrackedCamera_IVRTrackedCamera_006_SetCameraTrackingSpace(void *, ETrackingUniverseOrigin);
 extern ETrackingUniverseOrigin cppIVRTrackedCamera_IVRTrackedCamera_006_GetCameraTrackingSpace(void *);

vrclient_x64/vrclient_x64/struct_converters.h

@@ -1,3 +1,37 @@
+typedef struct winVRVulkanTextureArrayData_t_1267 winVRVulkanTextureArrayData_t_1267;
+extern void struct_VRVulkanTextureArrayData_t_1267_lin_to_win(void *l, void *w);
+extern void struct_VRVulkanTextureArrayData_t_1267_win_to_lin(void *w, void *l);
+typedef struct winVREvent_t_1267 winVREvent_t_1267;
+extern void struct_VREvent_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_VREvent_t_1267_win_to_lin(void *w, void *l);
+typedef struct winVRControllerState001_t_1267 winVRControllerState001_t_1267;
+extern void struct_VRControllerState001_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_VRControllerState001_t_1267_win_to_lin(void *w, void *l);
+typedef struct winCameraVideoStreamFrameHeader_t_1267 winCameraVideoStreamFrameHeader_t_1267;
+extern void struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(void *w, void *l);
+typedef struct winRenderModel_TextureMap_t_1267 winRenderModel_TextureMap_t_1267;
+extern void struct_RenderModel_TextureMap_t_1267_lin_to_win(void *l, void *w);
+extern void struct_RenderModel_TextureMap_t_1267_win_to_lin(void *w, void *l);
+extern struct winRenderModel_TextureMap_t_1267 *struct_RenderModel_TextureMap_t_1267_wrap(void *l);
+extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1267_unwrap(winRenderModel_TextureMap_t_1267 *w);
+typedef struct winRenderModel_t_1267 winRenderModel_t_1267;
+extern void struct_RenderModel_t_1267_lin_to_win(void *l, void *w);
+extern void struct_RenderModel_t_1267_win_to_lin(void *w, void *l);
+extern struct winRenderModel_t_1267 *struct_RenderModel_t_1267_wrap(void *l);
+extern RenderModel_t *struct_RenderModel_t_1267_unwrap(winRenderModel_t_1267 *w);
+typedef struct winInputAnalogActionData_t_1267 winInputAnalogActionData_t_1267;
+extern void struct_InputAnalogActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputAnalogActionData_t_1267_win_to_lin(void *w, void *l);
+typedef struct winInputDigitalActionData_t_1267 winInputDigitalActionData_t_1267;
+extern void struct_InputDigitalActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputDigitalActionData_t_1267_win_to_lin(void *w, void *l);
+typedef struct winInputPoseActionData_t_1267 winInputPoseActionData_t_1267;
+extern void struct_InputPoseActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputPoseActionData_t_1267_win_to_lin(void *w, void *l);
+typedef struct winInputSkeletalActionData_t_1267 winInputSkeletalActionData_t_1267;
+extern void struct_InputSkeletalActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputSkeletalActionData_t_1267_win_to_lin(void *w, void *l);
 typedef struct winVRVulkanTextureArrayData_t_1237 winVRVulkanTextureArrayData_t_1237;
 extern void struct_VRVulkanTextureArrayData_t_1237_lin_to_win(void *l, void *w);
 extern void struct_VRVulkanTextureArrayData_t_1237_win_to_lin(void *w, void *l);

vrclient_x64/vrclient_x64/struct_converters_1267.cpp

@@ -0,0 +1,362 @@
+#include <stdlib.h>
+#include <string.h>
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.26.7/openvr.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+#pragma pack(push, 8)
+struct winVRVulkanTextureArrayData_t_1267 {
+    uint32_t m_unArrayIndex;
+    uint32_t m_unArraySize;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VRVulkanTextureArrayData_t_1267_lin_to_win(void *l, void *w)
+{
+    struct winVRVulkanTextureArrayData_t_1267 *win = (struct winVRVulkanTextureArrayData_t_1267 *)w;
+    VRVulkanTextureArrayData_t *lin = (VRVulkanTextureArrayData_t *)l;
+    win->m_unArrayIndex = lin->m_unArrayIndex;
+    win->m_unArraySize = lin->m_unArraySize;
+}
+
+void struct_VRVulkanTextureArrayData_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winVRVulkanTextureArrayData_t_1267 *win = (struct winVRVulkanTextureArrayData_t_1267 *)w;
+    VRVulkanTextureArrayData_t *lin = (VRVulkanTextureArrayData_t *)l;
+    lin->m_unArrayIndex = win->m_unArrayIndex;
+    lin->m_unArraySize = win->m_unArraySize;
+}
+
+#pragma pack(push, 8)
+struct winVREvent_t_1267 {
+    uint32_t eventType;
+    vr::TrackedDeviceIndex_t trackedDeviceIndex;
+    float eventAgeSeconds;
+    vr::VREvent_Data_t data __attribute__((aligned(8)));
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VREvent_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winVREvent_t_1267 *win = (struct winVREvent_t_1267 *)w;
+    VREvent_t *lin = (VREvent_t *)l;
+    win->eventType = lin->eventType;
+    win->trackedDeviceIndex = lin->trackedDeviceIndex;
+    win->eventAgeSeconds = lin->eventAgeSeconds;
+    memcpy(&win->data, &lin->data, sz - (((char*)&win->data) - ((char*)win)));
+}
+
+void struct_VREvent_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winVREvent_t_1267 *win = (struct winVREvent_t_1267 *)w;
+    VREvent_t *lin = (VREvent_t *)l;
+    lin->eventType = win->eventType;
+    lin->trackedDeviceIndex = win->trackedDeviceIndex;
+    lin->eventAgeSeconds = win->eventAgeSeconds;
+    lin->data = win->data;
+}
+
+#pragma pack(push, 8)
+struct winVRControllerState001_t_1267 {
+    uint32_t unPacketNum;
+    uint64_t ulButtonPressed;
+    uint64_t ulButtonTouched;
+    vr::VRControllerAxis_t rAxis[5];
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VRControllerState001_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winVRControllerState001_t_1267 *win = (struct winVRControllerState001_t_1267 *)w;
+    VRControllerState001_t *lin = (VRControllerState001_t *)l;
+    win->unPacketNum = lin->unPacketNum;
+    win->ulButtonPressed = lin->ulButtonPressed;
+    win->ulButtonTouched = lin->ulButtonTouched;
+    memcpy(win->rAxis, lin->rAxis, sizeof(win->rAxis));
+}
+
+void struct_VRControllerState001_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winVRControllerState001_t_1267 *win = (struct winVRControllerState001_t_1267 *)w;
+    VRControllerState001_t *lin = (VRControllerState001_t *)l;
+    lin->unPacketNum = win->unPacketNum;
+    lin->ulButtonPressed = win->ulButtonPressed;
+    lin->ulButtonTouched = win->ulButtonTouched;
+    memcpy(lin->rAxis, win->rAxis, sizeof(lin->rAxis));
+}
+
+#pragma pack(push, 8)
+struct winCameraVideoStreamFrameHeader_t_1267 {
+    vr::EVRTrackedCameraFrameType eFrameType;
+    uint32_t nWidth;
+    uint32_t nHeight;
+    uint32_t nBytesPerPixel;
+    uint32_t nFrameSequence;
+    vr::TrackedDevicePose_t trackedDevicePose __attribute__((aligned(4)));
+    uint64_t ulFrameExposureTime;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_CameraVideoStreamFrameHeader_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winCameraVideoStreamFrameHeader_t_1267 *win = (struct winCameraVideoStreamFrameHeader_t_1267 *)w;
+    CameraVideoStreamFrameHeader_t *lin = (CameraVideoStreamFrameHeader_t *)l;
+    win->eFrameType = lin->eFrameType;
+    win->nWidth = lin->nWidth;
+    win->nHeight = lin->nHeight;
+    win->nBytesPerPixel = lin->nBytesPerPixel;
+    win->nFrameSequence = lin->nFrameSequence;
+    win->trackedDevicePose = lin->trackedDevicePose;
+    win->ulFrameExposureTime = lin->ulFrameExposureTime;
+}
+
+void struct_CameraVideoStreamFrameHeader_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winCameraVideoStreamFrameHeader_t_1267 *win = (struct winCameraVideoStreamFrameHeader_t_1267 *)w;
+    CameraVideoStreamFrameHeader_t *lin = (CameraVideoStreamFrameHeader_t *)l;
+    lin->eFrameType = win->eFrameType;
+    lin->nWidth = win->nWidth;
+    lin->nHeight = win->nHeight;
+    lin->nBytesPerPixel = win->nBytesPerPixel;
+    lin->nFrameSequence = win->nFrameSequence;
+    lin->trackedDevicePose = win->trackedDevicePose;
+    lin->ulFrameExposureTime = win->ulFrameExposureTime;
+}
+
+#pragma pack(push, 8)
+struct winRenderModel_TextureMap_t_1267 {
+    uint16_t unWidth;
+    uint16_t unHeight;
+    const uint8_t * rubTextureMapData;
+    vr::EVRRenderModelTextureFormat format;
+    uint16_t unMipLevels;
+
+    RenderModel_TextureMap_t *linux_side;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_RenderModel_TextureMap_t_1267_lin_to_win(void *l, void *w)
+{
+    struct winRenderModel_TextureMap_t_1267 *win = (struct winRenderModel_TextureMap_t_1267 *)w;
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    win->unWidth = lin->unWidth;
+    win->unHeight = lin->unHeight;
+    win->rubTextureMapData = lin->rubTextureMapData;
+    win->format = lin->format;
+    win->unMipLevels = lin->unMipLevels;
+}
+
+void struct_RenderModel_TextureMap_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winRenderModel_TextureMap_t_1267 *win = (struct winRenderModel_TextureMap_t_1267 *)w;
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    lin->unWidth = win->unWidth;
+    lin->unHeight = win->unHeight;
+    lin->rubTextureMapData = win->rubTextureMapData;
+    lin->format = win->format;
+    lin->unMipLevels = win->unMipLevels;
+}
+
+struct winRenderModel_TextureMap_t_1267 *struct_RenderModel_TextureMap_t_1267_wrap(void *l)
+{
+    struct winRenderModel_TextureMap_t_1267 *win = (struct winRenderModel_TextureMap_t_1267 *)malloc(sizeof(*win));
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    win->unWidth = lin->unWidth;
+    win->unHeight = lin->unHeight;
+    win->rubTextureMapData = lin->rubTextureMapData;
+    win->format = lin->format;
+    win->unMipLevels = lin->unMipLevels;
+    win->linux_side = lin;
+    return win;
+}
+
+struct RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1267_unwrap(winRenderModel_TextureMap_t_1267 *w)
+{
+    RenderModel_TextureMap_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winRenderModel_t_1267 {
+    const vr::RenderModel_Vertex_t * rVertexData;
+    uint32_t unVertexCount;
+    const uint16_t * rIndexData;
+    uint32_t unTriangleCount;
+    vr::TextureID_t diffuseTextureId;
+
+    RenderModel_t *linux_side;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_RenderModel_t_1267_lin_to_win(void *l, void *w)
+{
+    struct winRenderModel_t_1267 *win = (struct winRenderModel_t_1267 *)w;
+    RenderModel_t *lin = (RenderModel_t *)l;
+    win->rVertexData = lin->rVertexData;
+    win->unVertexCount = lin->unVertexCount;
+    win->rIndexData = lin->rIndexData;
+    win->unTriangleCount = lin->unTriangleCount;
+    win->diffuseTextureId = lin->diffuseTextureId;
+}
+
+void struct_RenderModel_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winRenderModel_t_1267 *win = (struct winRenderModel_t_1267 *)w;
+    RenderModel_t *lin = (RenderModel_t *)l;
+    lin->rVertexData = win->rVertexData;
+    lin->unVertexCount = win->unVertexCount;
+    lin->rIndexData = win->rIndexData;
+    lin->unTriangleCount = win->unTriangleCount;
+    lin->diffuseTextureId = win->diffuseTextureId;
+}
+
+struct winRenderModel_t_1267 *struct_RenderModel_t_1267_wrap(void *l)
+{
+    struct winRenderModel_t_1267 *win = (struct winRenderModel_t_1267 *)malloc(sizeof(*win));
+    RenderModel_t *lin = (RenderModel_t *)l;
+    win->rVertexData = lin->rVertexData;
+    win->unVertexCount = lin->unVertexCount;
+    win->rIndexData = lin->rIndexData;
+    win->unTriangleCount = lin->unTriangleCount;
+    win->diffuseTextureId = lin->diffuseTextureId;
+    win->linux_side = lin;
+    return win;
+}
+
+struct RenderModel_t *struct_RenderModel_t_1267_unwrap(winRenderModel_t_1267 *w)
+{
+    RenderModel_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winInputAnalogActionData_t_1267 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    float x;
+    float y;
+    float z;
+    float deltaX;
+    float deltaY;
+    float deltaZ;
+    float fUpdateTime;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputAnalogActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputAnalogActionData_t_1267 *win = (struct winInputAnalogActionData_t_1267 *)w;
+    InputAnalogActionData_t *lin = (InputAnalogActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+    win->x = lin->x;
+    win->y = lin->y;
+    win->z = lin->z;
+    win->deltaX = lin->deltaX;
+    win->deltaY = lin->deltaY;
+    win->deltaZ = lin->deltaZ;
+    win->fUpdateTime = lin->fUpdateTime;
+}
+
+void struct_InputAnalogActionData_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winInputAnalogActionData_t_1267 *win = (struct winInputAnalogActionData_t_1267 *)w;
+    InputAnalogActionData_t *lin = (InputAnalogActionData_t *)l;
+    lin->bActive = win->bActive;
+    lin->activeOrigin = win->activeOrigin;
+    lin->x = win->x;
+    lin->y = win->y;
+    lin->z = win->z;
+    lin->deltaX = win->deltaX;
+    lin->deltaY = win->deltaY;
+    lin->deltaZ = win->deltaZ;
+    lin->fUpdateTime = win->fUpdateTime;
+}
+
+#pragma pack(push, 8)
+struct winInputDigitalActionData_t_1267 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    bool bState;
+    bool bChanged;
+    float fUpdateTime;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputDigitalActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputDigitalActionData_t_1267 *win = (struct winInputDigitalActionData_t_1267 *)w;
+    InputDigitalActionData_t *lin = (InputDigitalActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+    win->bState = lin->bState;
+    win->bChanged = lin->bChanged;
+    win->fUpdateTime = lin->fUpdateTime;
+}
+
+void struct_InputDigitalActionData_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winInputDigitalActionData_t_1267 *win = (struct winInputDigitalActionData_t_1267 *)w;
+    InputDigitalActionData_t *lin = (InputDigitalActionData_t *)l;
+    lin->bActive = win->bActive;
+    lin->activeOrigin = win->activeOrigin;
+    lin->bState = win->bState;
+    lin->bChanged = win->bChanged;
+    lin->fUpdateTime = win->fUpdateTime;
+}
+
+#pragma pack(push, 8)
+struct winInputPoseActionData_t_1267 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    vr::TrackedDevicePose_t pose __attribute__((aligned(4)));
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputPoseActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputPoseActionData_t_1267 *win = (struct winInputPoseActionData_t_1267 *)w;
+    InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+    win->pose = lin->pose;
+}
+
+void struct_InputPoseActionData_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winInputPoseActionData_t_1267 *win = (struct winInputPoseActionData_t_1267 *)w;
+    InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
+    lin->bActive = win->bActive;
+    lin->activeOrigin = win->activeOrigin;
+    lin->pose = win->pose;
+}
+
+#pragma pack(push, 8)
+struct winInputSkeletalActionData_t_1267 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputSkeletalActionData_t_1267_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputSkeletalActionData_t_1267 *win = (struct winInputSkeletalActionData_t_1267 *)w;
+    InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+}
+
+void struct_InputSkeletalActionData_t_1267_win_to_lin(void *w, void *l)
+{
+    struct winInputSkeletalActionData_t_1267 *win = (struct winInputSkeletalActionData_t_1267 *)w;
+    InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
+    lin->bActive = win->bActive;
+    lin->activeOrigin = win->activeOrigin;
+}
+
+
+}

vrclient_x64/vrclient_x64/vrclient_main.c

@@ -37,10 +37,10 @@ typedef struct winRenderModel_t_1015 winRenderModel_t_1015;
 typedef struct winRenderModel_TextureMap_t_1015 winRenderModel_TextureMap_t_1015;
 #include "cppIVRRenderModels_IVRRenderModels_005.h"
 
-/* this is converted to 1237 during load_linux_texture_map, so ensure new
+/* this is converted to 1267 during load_linux_texture_map, so ensure new
  * structure is compatible before updating this number */
-typedef struct winRenderModel_t_1237 winRenderModel_t_1237;
+typedef struct winRenderModel_t_1267 winRenderModel_t_1267;
-typedef struct winRenderModel_TextureMap_t_1237 winRenderModel_TextureMap_t_1237;
+typedef struct winRenderModel_TextureMap_t_1267 winRenderModel_TextureMap_t_1267;
 #include "cppIVRRenderModels_IVRRenderModels_006.h"
 
 #include "wine/unixlib.h"

vrclient_x64/vrclient_x64/winIVRInput.c

@@ -63,35 +63,35 @@ EVRInputError __thiscall winIVRInput_IVRInput_010_UpdateActionState(winIVRInput_
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetDigitalActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return ivrinput_get_digital_action_data(cppIVRInput_IVRInput_010_GetDigitalActionData, _this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice, 10);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetAnalogActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_010_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow, 36)
-EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame, 32)
-EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1237 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1267 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(_this->linux_side, action, eOrigin, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetSkeletalActionData, 20)
-EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1237 * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1267 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_010_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);

vrclient_x64/vrclient_x64/winIVROverlay.c

@@ -18,6 +18,785 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVROverlay_IVROverlay_027.h"
+
+typedef struct __winIVROverlay_IVROverlay_027 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVROverlay_IVROverlay_027;
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_FindOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_FindOverlay(winIVROverlay_IVROverlay_027 *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_FindOverlay(_this->linux_side, pchOverlayKey, pOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_CreateOverlay, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_CreateOverlay(winIVROverlay_IVROverlay_027 *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_CreateOverlay(_this->linux_side, pchOverlayKey, pchOverlayName, pOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_DestroyOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_DestroyOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_DestroyOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayKey, 24)
+uint32_t __thiscall winIVROverlay_IVROverlay_027_GetOverlayKey(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayKey(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayName, 24)
+uint32_t __thiscall winIVROverlay_IVROverlay_027_GetOverlayName(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayName(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayName, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayName(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayName(_this->linux_side, ulOverlayHandle, pchName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayImageData, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayImageData(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayImageData(_this->linux_side, ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum, 8)
+const char * __thiscall winIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum(winIVROverlay_IVROverlay_027 *_this, EVROverlayError error)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum(_this->linux_side, error);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayRenderingPid, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayRenderingPid(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayRenderingPid(_this->linux_side, ulOverlayHandle, unPID);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayRenderingPid, 12)
+uint32_t __thiscall winIVROverlay_IVROverlay_027_GetOverlayRenderingPid(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayRenderingPid(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayFlag, 17)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayFlag(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, bEnabled);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayFlag, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayFlag(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, pbEnabled);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayFlags, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayFlags(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayFlags(_this->linux_side, ulOverlayHandle, pFlags);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayColor, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayColor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayColor(_this->linux_side, ulOverlayHandle, fRed, fGreen, fBlue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayColor, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayColor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayColor(_this->linux_side, ulOverlayHandle, pfRed, pfGreen, pfBlue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayAlpha, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayAlpha(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayAlpha(_this->linux_side, ulOverlayHandle, fAlpha);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayAlpha, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayAlpha(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayAlpha(_this->linux_side, ulOverlayHandle, pfAlpha);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTexelAspect, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTexelAspect(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, fTexelAspect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTexelAspect, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTexelAspect(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, pfTexelAspect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlaySortOrder, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlaySortOrder(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlaySortOrder(_this->linux_side, ulOverlayHandle, unSortOrder);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlaySortOrder, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlaySortOrder(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlaySortOrder(_this->linux_side, ulOverlayHandle, punSortOrder);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayWidthInMeters, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayWidthInMeters(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, fWidthInMeters);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayWidthInMeters, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayWidthInMeters(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, pfWidthInMeters);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayCurvature, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayCurvature(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayCurvature(_this->linux_side, ulOverlayHandle, fCurvature);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayCurvature, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayCurvature(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayCurvature(_this->linux_side, ulOverlayHandle, pfCurvature);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fRadians)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch(_this->linux_side, ulOverlayHandle, fRadians);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRadians)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch(_this->linux_side, ulOverlayHandle, pfRadians);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, eTextureColorSpace);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, peTextureColorSpace);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTextureBounds, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTextureBounds(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTextureBounds, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTextureBounds(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformType, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformType(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTransformType(_this->linux_side, ulOverlayHandle, peTransformType);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, unDeviceIndex, pchComponentName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformCursor, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformCursor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayTransformCursor(_this->linux_side, ulCursorOverlayHandle, pvHotspot);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTransformCursor, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTransformCursor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTransformCursor(_this->linux_side, ulOverlayHandle, pvHotspot);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTransformProjection, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTransformProjection(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayTransformProjection(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform, pProjection, eEye);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ShowOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_ShowOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_HideOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_HideOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_HideOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_IsOverlayVisible, 12)
+bool __thiscall winIVROverlay_IVROverlay_027_IsOverlayVisible(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_IsOverlayVisible(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates(_this->linux_side, ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_WaitFrameSync, 8)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_WaitFrameSync(winIVROverlay_IVROverlay_027 *_this, uint32_t nTimeoutMs)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_WaitFrameSync(_this->linux_side, nTimeoutMs);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_PollNextOverlayEvent, 20)
+bool __thiscall winIVROverlay_IVROverlay_027_PollNextOverlayEvent(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayInputMethod, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayInputMethod(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayInputMethod(_this->linux_side, ulOverlayHandle, peInputMethod);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayInputMethod, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayInputMethod(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayInputMethod(_this->linux_side, ulOverlayHandle, eInputMethod);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayMouseScale, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayMouseScale(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayMouseScale, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayMouseScale(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ComputeOverlayIntersection, 20)
+bool __thiscall winIVROverlay_IVROverlay_027_ComputeOverlayIntersection(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_ComputeOverlayIntersection(_this->linux_side, ulOverlayHandle, pParams, pResults);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_IsHoverTargetOverlay, 12)
+bool __thiscall winIVROverlay_IVROverlay_027_IsHoverTargetOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_IsHoverTargetOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayIntersectionMask, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayIntersectionMask(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayIntersectionMask(_this->linux_side, ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration(_this->linux_side, ulOverlayHandle, fDurationSeconds, fFrequency, fAmplitude);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayCursor, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayCursor(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayCursor(_this->linux_side, ulOverlayHandle, ulCursorHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle, pvCursor);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayTexture, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayTexture(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    TRACE("%p\n", _this);
+    return ivroverlay_set_overlay_texture(cppIVROverlay_IVROverlay_027_SetOverlayTexture, _this->linux_side, ulOverlayHandle, pTexture, 27);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ClearOverlayTexture, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ClearOverlayTexture(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_ClearOverlayTexture(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayRaw, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayRaw(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayRaw(_this->linux_side, ulOverlayHandle, pvBuffer, unWidth, unHeight, unBytesPerPixel);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetOverlayFromFile, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetOverlayFromFile(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    char lin_pchFilePath[PATH_MAX];
+    vrclient_dos_path_to_unix_path(pchFilePath, lin_pchFilePath);
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetOverlayFromFile(_this->linux_side, ulOverlayHandle, pchFilePath ? lin_pchFilePath : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTexture, 44)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTexture(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTexture(_this->linux_side, ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle(_this->linux_side, ulOverlayHandle, pNativeTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetOverlayTextureSize, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetOverlayTextureSize(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetOverlayTextureSize(_this->linux_side, ulOverlayHandle, pWidth, pHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_CreateDashboardOverlay, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_CreateDashboardOverlay(winIVROverlay_IVROverlay_027 *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_CreateDashboardOverlay(_this->linux_side, pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_IsDashboardVisible, 4)
+bool __thiscall winIVROverlay_IVROverlay_027_IsDashboardVisible(winIVROverlay_IVROverlay_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_IsDashboardVisible(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_IsActiveDashboardOverlay, 12)
+bool __thiscall winIVROverlay_IVROverlay_027_IsActiveDashboardOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_IsActiveDashboardOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, unProcessId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, punProcessId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowDashboard, 8)
+void __thiscall winIVROverlay_IVROverlay_027_ShowDashboard(winIVROverlay_IVROverlay_027 *_this, const char * pchOverlayToShow)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_027_ShowDashboard(_this->linux_side, pchOverlayToShow);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice, 4)
+TrackedDeviceIndex_t __thiscall winIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice(winIVROverlay_IVROverlay_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowKeyboard, 36)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ShowKeyboard(winIVROverlay_IVROverlay_027 *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_ShowKeyboard(_this->linux_side, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowKeyboardForOverlay, 44)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_027_ShowKeyboardForOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_ShowKeyboardForOverlay(_this->linux_side, ulOverlayHandle, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_GetKeyboardText, 12)
+uint32_t __thiscall winIVROverlay_IVROverlay_027_GetKeyboardText(winIVROverlay_IVROverlay_027 *_this, char * pchText, uint32_t cchText)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_GetKeyboardText(_this->linux_side, pchText, cchText);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_HideKeyboard, 4)
+void __thiscall winIVROverlay_IVROverlay_027_HideKeyboard(winIVROverlay_IVROverlay_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_027_HideKeyboard(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute, 12)
+void __thiscall winIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute(winIVROverlay_IVROverlay_027 *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute(_this->linux_side, eTrackingOrigin, pmatTrackingOriginToKeyboardTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay, 28)
+void __thiscall winIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay(winIVROverlay_IVROverlay_027 *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay(_this->linux_side, ulOverlayHandle, avoidRect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_ShowMessageOverlay, 28)
+VRMessageOverlayResponse __thiscall winIVROverlay_IVROverlay_027_ShowMessageOverlay(winIVROverlay_IVROverlay_027 *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_027_ShowMessageOverlay(_this->linux_side, pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_027_CloseMessageOverlay, 4)
+void __thiscall winIVROverlay_IVROverlay_027_CloseMessageOverlay(winIVROverlay_IVROverlay_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_027_CloseMessageOverlay(_this->linux_side);
+}
+
+extern vtable_ptr winIVROverlay_IVROverlay_027_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVROverlay_IVROverlay_027,
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_FindOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_CreateOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_DestroyOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayKey)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayName)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayName)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayImageData)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayRenderingPid)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayRenderingPid)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayFlag)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayFlag)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayFlags)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayColor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayColor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayAlpha)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayAlpha)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTexelAspect)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTexelAspect)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlaySortOrder)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlaySortOrder)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayWidthInMeters)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayWidthInMeters)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayCurvature)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayCurvature)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTextureBounds)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTextureBounds)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformType)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTransformCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTransformProjection)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_HideOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_IsOverlayVisible)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_WaitFrameSync)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_PollNextOverlayEvent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayInputMethod)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayInputMethod)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayMouseScale)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayMouseScale)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ComputeOverlayIntersection)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_IsHoverTargetOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayIntersectionMask)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ClearOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayRaw)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetOverlayFromFile)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetOverlayTextureSize)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_CreateDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_IsDashboardVisible)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_IsActiveDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowDashboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowKeyboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowKeyboardForOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_GetKeyboardText)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_HideKeyboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_ShowMessageOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_027_CloseMessageOverlay)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVROverlay_IVROverlay_027 *create_winIVROverlay_IVROverlay_027(void *linux_side)
+{
+    winIVROverlay_IVROverlay_027 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_027));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVROverlay_IVROverlay_027_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVROverlay_IVROverlay_027(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVROverlay_IVROverlay_027 *create_winIVROverlay_IVROverlay_027_FnTable(void *linux_side)
+{
+    winIVROverlay_IVROverlay_027 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_027));
+    struct thunk *thunks = alloc_thunks(80);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 80 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_027_FindOverlay, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_027_CreateOverlay, 3, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_027_DestroyOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_027_GetOverlayKey, 4, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_027_GetOverlayName, 4, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_027_SetOverlayName, 2, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_027_GetOverlayImageData, 5, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_027_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_027_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_027_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_027_SetOverlayFlag, 3, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_027_GetOverlayFlag, 3, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_027_GetOverlayFlags, 2, FALSE, FALSE);
+    init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_027_SetOverlayColor, 4, TRUE, TRUE);
+    init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_027_GetOverlayColor, 4, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_027_SetOverlayAlpha, 2, TRUE, FALSE);
+    init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_027_GetOverlayAlpha, 2, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_027_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_027_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_027_SetOverlaySortOrder, 2, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_027_GetOverlaySortOrder, 2, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_027_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_027_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_027_SetOverlayCurvature, 2, TRUE, FALSE);
+    init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_027_GetOverlayCurvature, 2, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_027_SetOverlayPreCurvePitch, 2, TRUE, FALSE);
+    init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_027_GetOverlayPreCurvePitch, 2, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_027_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_027_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_027_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_027_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_027_GetOverlayTransformType, 2, FALSE, FALSE);
+    init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_027_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_027_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_027_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_027_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_027_SetOverlayTransformCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_027_GetOverlayTransformCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_027_SetOverlayTransformProjection, 5, FALSE, FALSE);
+    init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_027_ShowOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_027_HideOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_027_IsOverlayVisible, 1, FALSE, FALSE);
+    init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_027_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_027_WaitFrameSync, 1, FALSE, FALSE);
+    init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_027_PollNextOverlayEvent, 3, FALSE, FALSE);
+    init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_027_GetOverlayInputMethod, 2, FALSE, FALSE);
+    init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_027_SetOverlayInputMethod, 2, FALSE, FALSE);
+    init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_027_GetOverlayMouseScale, 2, FALSE, FALSE);
+    init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_027_SetOverlayMouseScale, 2, FALSE, FALSE);
+    init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_027_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_027_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_027_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_027_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
+    init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_027_SetOverlayCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_027_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
+    init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_027_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
+    init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_027_SetOverlayTexture, 2, FALSE, FALSE);
+    init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_027_ClearOverlayTexture, 1, FALSE, FALSE);
+    init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_027_SetOverlayRaw, 5, FALSE, FALSE);
+    init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_027_SetOverlayFromFile, 2, FALSE, FALSE);
+    init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_027_GetOverlayTexture, 9, FALSE, FALSE);
+    init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_027_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_027_GetOverlayTextureSize, 3, FALSE, FALSE);
+    init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_027_CreateDashboardOverlay, 4, FALSE, FALSE);
+    init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_027_IsDashboardVisible, 0, FALSE, FALSE);
+    init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_027_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_027_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_027_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_027_ShowDashboard, 1, FALSE, FALSE);
+    init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_027_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_027_ShowKeyboard, 7, FALSE, FALSE);
+    init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_027_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_027_GetKeyboardText, 2, FALSE, FALSE);
+    init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_027_HideKeyboard, 0, FALSE, FALSE);
+    init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_027_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_027_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    init_thunk(&thunks[78], r, winIVROverlay_IVROverlay_027_ShowMessageOverlay, 6, FALSE, FALSE);
+    init_thunk(&thunks[79], r, winIVROverlay_IVROverlay_027_CloseMessageOverlay, 0, FALSE, FALSE);
+    for (i = 0; i < 80; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVROverlay_IVROverlay_027_FnTable(void *object)
+{
+    winIVROverlay_IVROverlay_027 *win_object = object;
+    TRACE("%p\n", win_object);
+    VirtualFree(win_object->vtable[0], 0, MEM_RELEASE);
+    HeapFree(GetProcessHeap(), 0, win_object->vtable);
+    HeapFree(GetProcessHeap(), 0, win_object);
+}
+
 #include "cppIVROverlay_IVROverlay_026.h"
 
 typedef struct __winIVROverlay_IVROverlay_026 {

vrclient_x64/vrclient_x64/winIVRRenderModels.c

@@ -26,28 +26,28 @@ typedef struct __winIVRRenderModels_IVRRenderModels_006 {
 } winIVRRenderModels_IVRRenderModels_006;
 
 DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async, 12)
-EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1237 ** ppRenderModel)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1267 ** ppRenderModel)
 {
     TRACE("%p\n", _this);
     return cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(_this->linux_side, pchRenderModelName, ppRenderModel);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_FreeRenderModel, 8)
-void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1237 * pRenderModel)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1267 * pRenderModel)
 {
     TRACE("%p\n", _this);
     cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(_this->linux_side, pRenderModel);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async, 12)
-EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1237 ** ppTexture)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1267 ** ppTexture)
 {
     TRACE("%p\n", _this);
     return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(_this->linux_side, textureId, ppTexture);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRRenderModels_IVRRenderModels_006_FreeTexture, 8)
-void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1237 * pTexture)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1267 * pTexture)
 {
     TRACE("%p\n", _this);
     cppIVRRenderModels_IVRRenderModels_006_FreeTexture(_this->linux_side, pTexture);

vrclient_x64/vrclient_x64/winIVRSystem.c

@@ -234,14 +234,14 @@ const char * __thiscall winIVRSystem_IVRSystem_022_GetPropErrorNameFromEnum(winI
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_022_PollNextEvent, 12)
-bool __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(winIVRSystem_IVRSystem_022 *_this, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent)
+bool __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(winIVRSystem_IVRSystem_022 *_this, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_022_PollNextEvent(_this->linux_side, pEvent, uncbVREvent);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_022_PollNextEventWithPose, 20)
-bool __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1237 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1267 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_022_PollNextEventWithPose(_this->linux_side, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose);
@@ -263,14 +263,14 @@ HiddenAreaMesh_t *__thiscall winIVRSystem_IVRSystem_022_GetHiddenAreaMesh(winIVR
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_022_GetControllerState, 16)
-bool __thiscall winIVRSystem_IVRSystem_022_GetControllerState(winIVRSystem_IVRSystem_022 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize)
+bool __thiscall winIVRSystem_IVRSystem_022_GetControllerState(winIVRSystem_IVRSystem_022 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 * pControllerState, uint32_t unControllerStateSize)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_022_GetControllerState(_this->linux_side, unControllerDeviceIndex, pControllerState, unControllerStateSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_022_GetControllerStateWithPose, 24)
-bool __thiscall winIVRSystem_IVRSystem_022_GetControllerStateWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1237 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_022_GetControllerStateWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1267 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);

vrclient_x64/vrclient_x64/winIVRTrackedCamera.c

@@ -75,7 +75,7 @@ EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_Releas
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer, 32)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(_this->linux_side, hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, pFrameHeader, nFrameHeaderSize);
@@ -89,14 +89,14 @@ EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVid
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11, 32)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(_this->linux_side, hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ppD3D11ShaderResourceView, pFrameHeader, nFrameHeaderSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL, 28)
-EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1237 * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1267 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(_this->linux_side, hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize);

vrclient_x64/vrclient_x64/win_constructors.h

@@ -14,8 +14,8 @@ extern void *create_winIVRHeadsetView_IVRHeadsetView_001(void *);
 extern void *create_winIVRHeadsetView_IVRHeadsetView_001_FnTable(void *);
 extern void *create_winIVRNotifications_IVRNotifications_002(void *);
 extern void *create_winIVRNotifications_IVRNotifications_002_FnTable(void *);
-extern void *create_winIVROverlay_IVROverlay_026(void *);
+extern void *create_winIVROverlay_IVROverlay_027(void *);
-extern void *create_winIVROverlay_IVROverlay_026_FnTable(void *);
+extern void *create_winIVROverlay_IVROverlay_027_FnTable(void *);
 extern void *create_winIVROverlayView_IVROverlayView_003(void *);
 extern void *create_winIVROverlayView_IVROverlayView_003_FnTable(void *);
 extern void *create_winIVRRenderModels_IVRRenderModels_006(void *);
@@ -36,6 +36,8 @@ extern void *create_winIVRIOBuffer_IVRIOBuffer_002(void *);
 extern void *create_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *);
 extern void *create_winIVRClientCore_IVRClientCore_003(void *);
 extern void *create_winIVRClientCore_IVRClientCore_003_FnTable(void *);
+extern void *create_winIVROverlay_IVROverlay_026(void *);
+extern void *create_winIVROverlay_IVROverlay_026_FnTable(void *);
 extern void *create_winIVROverlay_IVROverlay_025(void *);
 extern void *create_winIVROverlay_IVROverlay_025_FnTable(void *);
 extern void *create_winIVRCompositor_IVRCompositor_026(void *);

vrclient_x64/vrclient_x64/win_constructors_table.dat

@@ -14,8 +14,8 @@
     {"FnTable:IVRHeadsetView_001", &create_winIVRHeadsetView_IVRHeadsetView_001_FnTable, &destroy_winIVRHeadsetView_IVRHeadsetView_001_FnTable},
     {"IVRNotifications_002", &create_winIVRNotifications_IVRNotifications_002, &destroy_winIVRNotifications_IVRNotifications_002},
     {"FnTable:IVRNotifications_002", &create_winIVRNotifications_IVRNotifications_002_FnTable, &destroy_winIVRNotifications_IVRNotifications_002_FnTable},
-    {"IVROverlay_026", &create_winIVROverlay_IVROverlay_026, &destroy_winIVROverlay_IVROverlay_026},
+    {"IVROverlay_027", &create_winIVROverlay_IVROverlay_027, &destroy_winIVROverlay_IVROverlay_027},
-    {"FnTable:IVROverlay_026", &create_winIVROverlay_IVROverlay_026_FnTable, &destroy_winIVROverlay_IVROverlay_026_FnTable},
+    {"FnTable:IVROverlay_027", &create_winIVROverlay_IVROverlay_027_FnTable, &destroy_winIVROverlay_IVROverlay_027_FnTable},
     {"IVROverlayView_003", &create_winIVROverlayView_IVROverlayView_003, &destroy_winIVROverlayView_IVROverlayView_003},
     {"FnTable:IVROverlayView_003", &create_winIVROverlayView_IVROverlayView_003_FnTable, &destroy_winIVROverlayView_IVROverlayView_003_FnTable},
     {"IVRRenderModels_006", &create_winIVRRenderModels_IVRRenderModels_006, &destroy_winIVRRenderModels_IVRRenderModels_006},
@@ -36,6 +36,8 @@
     {"FnTable:IVRIOBuffer_002", &create_winIVRIOBuffer_IVRIOBuffer_002_FnTable, &destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable},
     {"IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003, &destroy_winIVRClientCore_IVRClientCore_003},
     {"FnTable:IVRClientCore_003", &create_winIVRClientCore_IVRClientCore_003_FnTable, &destroy_winIVRClientCore_IVRClientCore_003_FnTable},
+    {"IVROverlay_026", &create_winIVROverlay_IVROverlay_026, &destroy_winIVROverlay_IVROverlay_026},
+    {"FnTable:IVROverlay_026", &create_winIVROverlay_IVROverlay_026_FnTable, &destroy_winIVROverlay_IVROverlay_026_FnTable},
     {"IVROverlay_025", &create_winIVROverlay_IVROverlay_025, &destroy_winIVROverlay_IVROverlay_025},
     {"FnTable:IVROverlay_025", &create_winIVROverlay_IVROverlay_025_FnTable, &destroy_winIVROverlay_IVROverlay_025_FnTable},
     {"IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026, &destroy_winIVRCompositor_IVRCompositor_026},

vrclient_x64/vrclient_x64/win_destructors.h

@@ -14,8 +14,8 @@ extern void destroy_winIVRHeadsetView_IVRHeadsetView_001(void *);
 extern void destroy_winIVRHeadsetView_IVRHeadsetView_001_FnTable(void *);
 extern void destroy_winIVRNotifications_IVRNotifications_002(void *);
 extern void destroy_winIVRNotifications_IVRNotifications_002_FnTable(void *);
-extern void destroy_winIVROverlay_IVROverlay_026(void *);
+extern void destroy_winIVROverlay_IVROverlay_027(void *);
-extern void destroy_winIVROverlay_IVROverlay_026_FnTable(void *);
+extern void destroy_winIVROverlay_IVROverlay_027_FnTable(void *);
 extern void destroy_winIVROverlayView_IVROverlayView_003(void *);
 extern void destroy_winIVROverlayView_IVROverlayView_003_FnTable(void *);
 extern void destroy_winIVRRenderModels_IVRRenderModels_006(void *);
@@ -36,6 +36,8 @@ extern void destroy_winIVRIOBuffer_IVRIOBuffer_002(void *);
 extern void destroy_winIVRIOBuffer_IVRIOBuffer_002_FnTable(void *);
 extern void destroy_winIVRClientCore_IVRClientCore_003(void *);
 extern void destroy_winIVRClientCore_IVRClientCore_003_FnTable(void *);
+extern void destroy_winIVROverlay_IVROverlay_026(void *);
+extern void destroy_winIVROverlay_IVROverlay_026_FnTable(void *);
 extern void destroy_winIVROverlay_IVROverlay_025(void *);
 extern void destroy_winIVROverlay_IVROverlay_025_FnTable(void *);
 extern void destroy_winIVRCompositor_IVRCompositor_026(void *);