vrclient: Support v1.16.8.

Signed-off-by: Paul Gofman <pgofman@codeweavers.com>

45 files changed, 11855 insertions, 1190 deletions

diff --git a/vrclient_x64/gen_wrapper.py b/vrclient_x64/gen_wrapper.py
index 5dbecf84..74c942f3 100755
--- a/vrclient_x64/gen_wrapper.py
+++ b/vrclient_x64/gen_wrapper.py
@@ -14,6 +14,7 @@ import os
 import re
 
 sdk_versions = [
+    "v1.16.8",
     "v1.14.15",
     "v1.13.10",
     "v1.12.5",
@@ -376,7 +377,8 @@ def ivroverlay_set_overlay_texture(cppname, method):
             "020" in cppname or \
             "021" in cppname or \
             "022" in cppname or \
-            "024" in cppname
+            "024" in cppname or \
+            "025" in cppname
     return "ivroverlay_set_overlay_texture"
 
 method_overrides = [
diff --git a/vrclient_x64/openvr_v1.16.8/ivrclientcore.h b/vrclient_x64/openvr_v1.16.8/ivrclientcore.h
new file mode 100644
index 00000000..873bd600
--- /dev/null
+++ b/vrclient_x64/openvr_v1.16.8/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";
+
+
+}
diff --git a/vrclient_x64/openvr_v1.16.8/openvr.h b/vrclient_x64/openvr_v1.16.8/openvr.h
new file mode 100644
index 00000000..4c94a3eb
--- /dev/null
+++ b/vrclient_x64/openvr_v1.16.8/openvr.h
@@ -0,0 +1,5623 @@
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+
+
+// version.h
+
+namespace vr
+{
+	static const uint32_t k_nSteamVRVersionMajor = 1;
+	static const uint32_t k_nSteamVRVersionMinor = 16;
+	static const uint32_t k_nSteamVRVersionBuild = 8;
+} // namespace vr
+
+// public_vrtypes.h
+
+#ifndef _INCLUDE_CORE_VRTYPES_PUBLIC_H
+#define _INCLUDE_CORE_VRTYPES_PUBLIC_H
+
+namespace vr
+{
+#pragma pack( push, 8 )
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is forward
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix33_t
+{
+	float m[3][3];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdQuaternionf_t
+{
+	float w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[ 4 ];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Holds the transform for a single bone */
+struct VRBoneTransform_t
+{
+	HmdVector4_t position;
+	HmdQuaternionf_t orientation;
+};
+
+#pragma pack( pop )
+
+} // namespace vr
+
+#endif
+
+// vrtypes.h
+
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack( push, 8 )
+
+/** A handle for a spatial anchor.  This handle is only valid during the session it was created in.
+* Anchors that live beyond one session should be saved by their string descriptors. */
+typedef uint32_t SpatialAnchorHandle_t;
+
+typedef void* glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+
+/** Used to return the post-distortion UVs for each color channel.
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_Invalid = -1, // Handle has been invalidated
+	TextureType_DirectX = 0, // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef, deprecated in favor of TextureType_Metal on supported platforms
+	TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
+	TextureType_DXGISharedHandle = 5, // Handle is a HANDLE DXGI share handle, only supported for Overlay render targets.
+									  // this texture is used directly by our renderer, so only perform atomic (copyresource or resolve) on it
+	TextureType_Metal = 6, // Handle is a MTLTexture conforming to the MTLSharedTexture protocol. Textures submitted to IVRCompositor::Submit which
+						   // are of type MTLTextureType2DArray assume layer 0 is the left eye texture (vr::EVREye::Eye_left), layer 1 is the right
+						   // eye texture (vr::EVREye::Eye_Right)
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,	// Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,	// Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,	// Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void* handle; // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE	((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized			= 1,
+
+	TrackingResult_Calibrating_InProgress	= 100,
+	TrackingResult_Calibrating_OutOfRange	= 101,
+
+	TrackingResult_Running_OK				= 200,
+	TrackingResult_Running_OutOfRange		= 201,
+
+	TrackingResult_Fallback_RotationOnly	= 300,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 64;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,				// the ID was not valid.
+	TrackedDeviceClass_HMD = 1,					// Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,			// Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,		// Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,	// Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,		// Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+
+	TrackedDeviceClass_Max
+};
+
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,					// Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,					// Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,				// Tracked device associated with the right hand
+	TrackedControllerRole_OptOut = 3,					// Tracked device is opting out of left/right hand selection
+	TrackedControllerRole_Treadmill = 4,				// Tracked device is a treadmill or other locomotion device
+	TrackedControllerRole_Stylus = 5,					// Tracked device is a stylus
+	TrackedControllerRole_Max = 5
+};
+
+
+/** Returns true if the tracked controller role is allowed to be a hand */
+inline bool IsRoleAllowedAsHand( ETrackedControllerRole eRole )
+{
+	switch ( eRole )
+	{
+	case TrackedControllerRole_Invalid:
+	case TrackedControllerRole_LeftHand:
+	case TrackedControllerRole_RightHand:
+		return true;
+	default:
+		return false;
+	}
+}
+
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking;
+	HmdVector3_t vVelocity;				// velocity in tracker space in m/s
+	HmdVector3_t vAngularVelocity;		// angular velocity in radians/s (?)
+	ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+
+	// This indicates that there is a device connected for this spot in the pose array.
+	// It could go from true to false if the user unplugs the device.
+	bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,		// Poses are provided relative to the seated zero pose
+	TrackingUniverseStanding = 1,	// Poses are provided relative to the safe bounds configured by the user
+	TrackingUniverseRawAndUncalibrated = 2,	// Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+enum EAdditionalRadioFeatures
+{
+	AdditionalRadioFeatures_None           = 0x00000000,
+	AdditionalRadioFeatures_HTCLinkBox     = 0x00000001,
+	AdditionalRadioFeatures_InternalDongle = 0x00000002,
+	AdditionalRadioFeatures_ExternalDongle = 0x00000004,
+};
+
+typedef uint64_t WebConsoleHandle_t;
+#define INVALID_WEB_CONSOLE_HANDLE	((vr::WebConsoleHandle_t)0)
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+typedef PropertyContainerHandle_t DriverHandle_t;
+static const PropertyContainerHandle_t k_ulInvalidDriverHandle = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+static const PropertyTypeTag_t k_unErrorPropertyTag = 6;
+static const PropertyTypeTag_t k_unDoublePropertyTag = 7;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+static const PropertyTypeTag_t k_unHmdVector2PropertyTag = 24;
+static const PropertyTypeTag_t k_unHmdQuadPropertyTag = 25;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+static const PropertyTypeTag_t k_unPathHandleInfoTag = 31;
+static const PropertyTypeTag_t k_unActionPropertyTag = 32;
+static const PropertyTypeTag_t k_unInputValuePropertyTag = 33;
+static const PropertyTypeTag_t k_unWildcardPropertyTag = 34;
+static const PropertyTypeTag_t k_unHapticVibrationPropertyTag = 35;
+static const PropertyTypeTag_t k_unSkeletonPropertyTag = 36;
+
+static const PropertyTypeTag_t k_unSpatialAnchorPosePropertyTag = 40;
+static const PropertyTypeTag_t k_unJsonPropertyTag = 41;
+static const PropertyTypeTag_t k_unActiveActionSetPropertyTag = 42;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+	Prop_Invalid								= 0,
+
+	// general properties that apply to all device classes
+	Prop_TrackingSystemName_String				= 1000,
+	Prop_ModelNumber_String						= 1001,
+	Prop_SerialNumber_String					= 1002,
+	Prop_RenderModelName_String					= 1003,
+	Prop_WillDriftInYaw_Bool					= 1004,
+	Prop_ManufacturerName_String				= 1005,
+	Prop_TrackingFirmwareVersion_String			= 1006,
+	Prop_HardwareRevision_String				= 1007,
+	Prop_AllWirelessDongleDescriptions_String	= 1008,
+	Prop_ConnectedWirelessDongle_String			= 1009,
+	Prop_DeviceIsWireless_Bool					= 1010,
+	Prop_DeviceIsCharging_Bool					= 1011,
+	Prop_DeviceBatteryPercentage_Float			= 1012, // 0 is empty, 1 is full
+	Prop_StatusDisplayTransform_Matrix34		= 1013,
+	Prop_Firmware_UpdateAvailable_Bool			= 1014,
+	Prop_Firmware_ManualUpdate_Bool				= 1015,
+	Prop_Firmware_ManualUpdateURL_String		= 1016,
+	Prop_HardwareRevision_Uint64				= 1017,
+	Prop_FirmwareVersion_Uint64					= 1018,
+	Prop_FPGAVersion_Uint64						= 1019,
+	Prop_VRCVersion_Uint64						= 1020,
+	Prop_RadioVersion_Uint64					= 1021,
+	Prop_DongleVersion_Uint64					= 1022,
+	Prop_BlockServerShutdown_Bool				= 1023,
+	Prop_CanUnifyCoordinateSystemWithHmd_Bool	= 1024,
+	Prop_ContainsProximitySensor_Bool			= 1025,
+	Prop_DeviceProvidesBatteryStatus_Bool		= 1026,
+	Prop_DeviceCanPowerOff_Bool					= 1027,
+	Prop_Firmware_ProgrammingTarget_String		= 1028,
+	Prop_DeviceClass_Int32						= 1029,
+	Prop_HasCamera_Bool							= 1030,
+	Prop_DriverVersion_String                   = 1031,
+	Prop_Firmware_ForceUpdateRequired_Bool      = 1032,
+	Prop_ViveSystemButtonFixRequired_Bool		= 1033,
+	Prop_ParentDriver_Uint64					= 1034,
+	Prop_ResourceRoot_String					= 1035,
+	Prop_RegisteredDeviceType_String			= 1036,
+	Prop_InputProfilePath_String				= 1037, // input profile to use for this device in the input system. Will default to tracking system name if this isn't provided
+	Prop_NeverTracked_Bool						= 1038, // Used for devices that will never have a valid pose by design
+	Prop_NumCameras_Int32						= 1039,
+	Prop_CameraFrameLayout_Int32				= 1040, // EVRTrackedCameraFrameLayout value
+	Prop_CameraStreamFormat_Int32				= 1041, // ECameraVideoStreamFormat value
+	Prop_AdditionalDeviceSettingsPath_String	= 1042, // driver-relative path to additional device and global configuration settings
+	Prop_Identifiable_Bool						= 1043, // Whether device supports being identified from vrmonitor (e.g. blink LED, vibrate haptics, etc)
+	Prop_BootloaderVersion_Uint64			    = 1044,
+	Prop_AdditionalSystemReportData_String		= 1045, // additional string to include in system reports about a tracked device
+	Prop_CompositeFirmwareVersion_String        = 1046, // additional FW components from a device that gets propagated into reports
+	Prop_Firmware_RemindUpdate_Bool             = 1047,
+	Prop_PeripheralApplicationVersion_Uint64	= 1048,
+	Prop_ManufacturerSerialNumber_String		= 1049,
+	Prop_ComputedSerialNumber_String			= 1050,
+	Prop_EstimatedDeviceFirstUseTime_Int32		= 1051,
+
+	// Properties that are unique to TrackedDeviceClass_HMD
+	Prop_ReportsTimeSinceVSync_Bool				= 2000,
+	Prop_SecondsFromVsyncToPhotons_Float		= 2001,
+	Prop_DisplayFrequency_Float					= 2002,
+	Prop_UserIpdMeters_Float					= 2003,
+	Prop_CurrentUniverseId_Uint64				= 2004,
+	Prop_PreviousUniverseId_Uint64				= 2005,
+	Prop_DisplayFirmwareVersion_Uint64			= 2006,
+	Prop_IsOnDesktop_Bool						= 2007,
+	Prop_DisplayMCType_Int32					= 2008,
+	Prop_DisplayMCOffset_Float					= 2009,
+	Prop_DisplayMCScale_Float					= 2010,
+	Prop_EdidVendorID_Int32						= 2011,
+	Prop_DisplayMCImageLeft_String              = 2012,
+	Prop_DisplayMCImageRight_String             = 2013,
+	Prop_DisplayGCBlackClamp_Float				= 2014,
+	Prop_EdidProductID_Int32					= 2015,
+	Prop_CameraToHeadTransform_Matrix34			= 2016,
+	Prop_DisplayGCType_Int32					= 2017,
+	Prop_DisplayGCOffset_Float					= 2018,
+	Prop_DisplayGCScale_Float					= 2019,
+	Prop_DisplayGCPrescale_Float				= 2020,
+	Prop_DisplayGCImage_String					= 2021,
+	Prop_LensCenterLeftU_Float					= 2022,
+	Prop_LensCenterLeftV_Float					= 2023,
+	Prop_LensCenterRightU_Float					= 2024,
+	Prop_LensCenterRightV_Float					= 2025,
+	Prop_UserHeadToEyeDepthMeters_Float			= 2026,
+	Prop_CameraFirmwareVersion_Uint64			= 2027,
+	Prop_CameraFirmwareDescription_String		= 2028,
+	Prop_DisplayFPGAVersion_Uint64				= 2029,
+	Prop_DisplayBootloaderVersion_Uint64		= 2030,
+	Prop_DisplayHardwareVersion_Uint64			= 2031,
+	Prop_AudioFirmwareVersion_Uint64			= 2032,
+	Prop_CameraCompatibilityMode_Int32			= 2033,
+	Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	Prop_DisplaySuppressed_Bool					= 2036,
+	Prop_DisplayAllowNightMode_Bool				= 2037,
+	Prop_DisplayMCImageWidth_Int32				= 2038,
+	Prop_DisplayMCImageHeight_Int32				= 2039,
+	Prop_DisplayMCImageNumChannels_Int32		= 2040,
+	Prop_DisplayMCImageData_Binary				= 2041,
+	Prop_SecondsFromPhotonsToVblank_Float		= 2042,
+	Prop_DriverDirectModeSendsVsyncEvents_Bool	= 2043,
+	Prop_DisplayDebugMode_Bool					= 2044,
+	Prop_GraphicsAdapterLuid_Uint64				= 2045,
+	Prop_DriverProvidedChaperonePath_String		= 2048,
+	Prop_ExpectedTrackingReferenceCount_Int32	= 2049, // expected number of sensors or basestations to reserve UI space for
+	Prop_ExpectedControllerCount_Int32			= 2050, // expected number of tracked controllers to reserve UI space for
+	Prop_NamedIconPathControllerLeftDeviceOff_String	= 2051, // placeholder icon for "left" controller if not yet detected/loaded
+	Prop_NamedIconPathControllerRightDeviceOff_String	= 2052, // placeholder icon for "right" controller if not yet detected/loaded
+	Prop_NamedIconPathTrackingReferenceDeviceOff_String	= 2053, // placeholder icon for sensor/base if not yet detected/loaded
+	Prop_DoNotApplyPrediction_Bool				= 2054, // currently no effect. was used to disable HMD pose prediction on MR, which is now done by MR driver setting velocity=0
+	Prop_CameraToHeadTransforms_Matrix34_Array	= 2055,
+	Prop_DistortionMeshResolution_Int32			= 2056, // custom resolution of compositor calls to IVRSystem::ComputeDistortion
+	Prop_DriverIsDrawingControllers_Bool		= 2057,
+	Prop_DriverRequestsApplicationPause_Bool	= 2058,
+	Prop_DriverRequestsReducedRendering_Bool	= 2059,
+	Prop_MinimumIpdStepMeters_Float				= 2060,
+	Prop_AudioBridgeFirmwareVersion_Uint64		= 2061,
+	Prop_ImageBridgeFirmwareVersion_Uint64		= 2062,
+	Prop_ImuToHeadTransform_Matrix34			= 2063,
+	Prop_ImuFactoryGyroBias_Vector3				= 2064,
+	Prop_ImuFactoryGyroScale_Vector3			= 2065,
+	Prop_ImuFactoryAccelerometerBias_Vector3	= 2066,
+	Prop_ImuFactoryAccelerometerScale_Vector3	= 2067,
+	// reserved 2068
+	Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069,
+	Prop_AdditionalRadioFeatures_Uint64         = 2070,
+	Prop_CameraWhiteBalance_Vector4_Array		= 2071, // Prop_NumCameras_Int32-sized array of float[4] RGBG white balance calibration data (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionFunction_Int32_Array	= 2072, // Prop_NumCameras_Int32-sized array of vr::EVRDistortionFunctionType values (max size is vr::k_unMaxCameras)
+	Prop_CameraDistortionCoefficients_Float_Array = 2073, // Prop_NumCameras_Int32-sized array of double[vr::k_unMaxDistortionFunctionParameters] (max size is vr::k_unMaxCameras)
+	Prop_ExpectedControllerType_String			= 2074,
+	Prop_HmdTrackingStyle_Int32					= 2075, // one of EHmdTrackingStyle
+	Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
+	Prop_HmdColumnCorrectionSettingPrefix_String = 2077,
+	Prop_CameraSupportsCompatibilityModes_Bool	= 2078,
+	Prop_SupportsRoomViewDepthProjection_Bool	= 2079,
+	Prop_DisplayAvailableFrameRates_Float_Array = 2080, // populated by compositor from actual EDID list when available from GPU driver
+	Prop_DisplaySupportsMultipleFramerates_Bool = 2081, // if this is true but Prop_DisplayAvailableFrameRates_Float_Array is empty, explain to user
+	Prop_DisplayColorMultLeft_Vector3			= 2082,
+	Prop_DisplayColorMultRight_Vector3			= 2083,
+	Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084,
+	Prop_DisplaySupportsAnalogGain_Bool 		= 2085,
+	Prop_DisplayMinAnalogGain_Float 			= 2086,
+	Prop_DisplayMaxAnalogGain_Float 			= 2087,
+    Prop_CameraExposureTime_Float               = 2088,
+    Prop_CameraGlobalGain_Float                 = 2089,
+	// Prop_DashboardLayoutPathName_String 		= 2090, // DELETED
+	Prop_DashboardScale_Float 					= 2091,
+	Prop_IpdUIRangeMinMeters_Float 				= 2100,
+	Prop_IpdUIRangeMaxMeters_Float 				= 2101,
+	Prop_Hmd_SupportsHDCP14LegacyCompat_Bool	= 2102,
+	Prop_Hmd_SupportsMicMonitoring_Bool 		= 2103,
+
+	// Driver requested mura correction properties
+	Prop_DriverRequestedMuraCorrectionMode_Int32		= 2200,
+	Prop_DriverRequestedMuraFeather_InnerLeft_Int32		= 2201,
+	Prop_DriverRequestedMuraFeather_InnerRight_Int32	= 2202,
+	Prop_DriverRequestedMuraFeather_InnerTop_Int32		= 2203,
+	Prop_DriverRequestedMuraFeather_InnerBottom_Int32	= 2204,
+	Prop_DriverRequestedMuraFeather_OuterLeft_Int32		= 2205,
+	Prop_DriverRequestedMuraFeather_OuterRight_Int32	= 2206,
+	Prop_DriverRequestedMuraFeather_OuterTop_Int32		= 2207,
+	Prop_DriverRequestedMuraFeather_OuterBottom_Int32	= 2208,
+
+	Prop_Audio_DefaultPlaybackDeviceId_String		= 2300,
+	Prop_Audio_DefaultRecordingDeviceId_String		= 2301,
+	Prop_Audio_DefaultPlaybackDeviceVolume_Float = 2302,
+	Prop_Audio_SupportsDualSpeakerAndJackOutput_Bool = 2303,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String				= 3000,
+	Prop_SupportedButtons_Uint64				= 3001,
+	Prop_Axis0Type_Int32						= 3002, // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32						= 3003, // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32						= 3004, // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32						= 3005, // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32						= 3006, // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32				= 3007, // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float			= 4000,
+	Prop_FieldOfViewRightDegrees_Float			= 4001,
+	Prop_FieldOfViewTopDegrees_Float			= 4002,
+	Prop_FieldOfViewBottomDegrees_Float			= 4003,
+	Prop_TrackingRangeMinimumMeters_Float		= 4004,
+	Prop_TrackingRangeMaximumMeters_Float		= 4005,
+	Prop_ModeLabel_String						= 4006,
+	Prop_CanWirelessIdentify_Bool               = 4007, // volatile, based on radio presence and fw discovery
+	Prop_Nonce_Int32                            = 4008,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String						= 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String				= 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String		= 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String	= 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String			= 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String		= 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String			= 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String			= 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String			= 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandbyAlert_String		= 5009, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start				= 5100,
+	Prop_DisplayHiddenArea_Binary_End				= 5150,
+	Prop_ParentContainer							= 5151,
+	Prop_OverrideContainer_Uint64					= 5152,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String					= 6000,
+	Prop_InstallPath_String						= 6001,
+	Prop_HasDisplayComponent_Bool				= 6002,
+	Prop_HasControllerComponent_Bool			= 6003,
+	Prop_HasCameraComponent_Bool				= 6004,
+	Prop_HasDriverDirectModeComponent_Bool		= 6005,
+	Prop_HasVirtualDisplayComponent_Bool		= 6006,
+	Prop_HasSpatialAnchorsSupport_Bool		    = 6007,
+
+	// Properties that are set internally based on other information provided by drivers
+	Prop_ControllerType_String					= 7000,
+	//Prop_LegacyInputProfile_String				= 7001, // This is no longer used. See "legacy_binding" in the input profile instead.
+	Prop_ControllerHandSelectionPriority_Int32	= 7002, // Allows hand assignments to prefer some controllers over others. High numbers are selected over low numbers
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start			= 10000,
+	Prop_VendorSpecific_Reserved_End			= 10999,
+
+	Prop_TrackedDeviceProperty_Max				= 1000000,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success						= 0,
+	TrackedProp_WrongDataType				= 1,
+	TrackedProp_WrongDeviceClass			= 2,
+	TrackedProp_BufferTooSmall				= 3,
+	TrackedProp_UnknownProperty				= 4, // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice				= 5,
+	TrackedProp_CouldNotContactServer		= 6,
+	TrackedProp_ValueNotProvidedByDevice	= 7,
+	TrackedProp_StringExceedsMaximumLength	= 8,
+	TrackedProp_NotYetAvailable				= 9, // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied			= 10,
+	TrackedProp_InvalidOperation			= 11,
+	TrackedProp_CannotWriteToWildcards		= 12,
+	TrackedProp_IPCReadFailure				= 13,
+	TrackedProp_OutOfMemory					= 14,
+	TrackedProp_InvalidContainer			= 15,
+};
+
+/** Used to drive certain text in the UI when talking about the tracking system for the HMD */
+enum EHmdTrackingStyle
+{
+	HmdTrackingStyle_Unknown				= 0,
+
+	HmdTrackingStyle_Lighthouse				= 1, // base stations and lasers
+	HmdTrackingStyle_OutsideInCameras		= 2, // Cameras and LED, Rift 1 style
+	HmdTrackingStyle_InsideOutCameras		= 3, // Cameras on HMD looking at the world
+};
+
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+
+static const VRActionHandle_t k_ulInvalidActionHandle = 0;
+static const VRActionSetHandle_t k_ulInvalidActionSetHandle = 0;
+static const VRInputValueHandle_t k_ulInvalidInputValueHandle = 0;
+
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+	float uMin, vMin;
+	float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+	HmdMatrix34_t mDeviceToAbsoluteTracking; // Actual pose used to render scene textures.
+};
+
+struct VRTextureDepthInfo_t
+{
+	void* handle; // See ETextureType definition above
+	HmdMatrix44_t mProjection;
+	HmdVector2_t vRange; // 0..1
+};
+
+struct VRTextureWithDepth_t : public Texture_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+struct VRTextureWithPoseAndDepth_t : public VRTextureWithPose_t
+{
+	VRTextureDepthInfo_t depth;
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	// This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithPose = 0x08,
+
+	// Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
+	// This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithDepth = 0x10,
+
+	// Set to indicate a discontinuity between this and the last frame.
+	// This will prevent motion smoothing from attempting to extrapolate using the pair.
+	Submit_FrameDiscontinuty = 0x20,
+
+	// Set to indicate that pTexture->handle is a contains VRVulkanTextureArrayData_t
+	Submit_VulkanTextureWithArrayData = 0x40,
+
+	// If the texture pointer passed in is an OpenGL Array texture, set this flag
+	Submit_GlArrayTexture = 0x80,
+
+	// Do not use
+	Submit_Reserved2 = 0x8000,
+
+
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources.
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage; // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing Vulkan texture arrays to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources.
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureArrayData_t : public VRVulkanTextureData_t
+{
+	uint32_t m_unArrayIndex;
+	uint32_t m_unArraySize;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated		= 100,
+	VREvent_TrackedDeviceDeactivated	= 101,
+	VREvent_TrackedDeviceUpdated		= 102,
+	VREvent_TrackedDeviceUserInteractionStarted	= 103,
+	VREvent_TrackedDeviceUserInteractionEnded	= 104,
+	VREvent_IpdChanged					= 105,
+	VREvent_EnterStandbyMode			= 106,
+	VREvent_LeaveStandbyMode			= 107,
+	VREvent_TrackedDeviceRoleChanged	= 108,
+	VREvent_WatchdogWakeUpRequested		= 109,
+	VREvent_LensDistortionChanged		= 110,
+	VREvent_PropertyChanged				= 111,
+	VREvent_WirelessDisconnect			= 112,
+	VREvent_WirelessReconnect			= 113,
+
+	VREvent_ButtonPress					= 200, // data is controller
+	VREvent_ButtonUnpress				= 201, // data is controller
+	VREvent_ButtonTouch					= 202, // data is controller
+	VREvent_ButtonUntouch				= 203, // data is controller
+
+	// VREvent_DualAnalog_Press			= 250, // No longer sent
+	// VREvent_DualAnalog_Unpress		= 251, // No longer sent
+	// VREvent_DualAnalog_Touch			= 252, // No longer sent
+	// VREvent_DualAnalog_Untouch		= 253, // No longer sent
+	// VREvent_DualAnalog_Move			= 254, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch1	= 255, // No longer sent
+	// VREvent_DualAnalog_ModeSwitch2	= 256, // No longer sent
+	VREvent_Modal_Cancel				= 257, // Sent to overlays with the
+
+	VREvent_MouseMove					= 300, // data is mouse
+	VREvent_MouseButtonDown				= 301, // data is mouse
+	VREvent_MouseButtonUp				= 302, // data is mouse
+	VREvent_FocusEnter					= 303, // data is overlay
+	VREvent_FocusLeave					= 304, // data is overlay
+	VREvent_ScrollDiscrete				= 305, // data is scroll
+	VREvent_TouchPadMove				= 306, // data is mouse
+	VREvent_OverlayFocusChanged			= 307, // data is overlay, global event
+	VREvent_ReloadOverlays				= 308,
+	VREvent_ScrollSmooth				= 309, // data is scroll
+	VREvent_LockMousePosition			= 310,
+	VREvent_UnlockMousePosition			= 311,
+
+	VREvent_InputFocusCaptured			= 400, // data is process DEPRECATED
+	VREvent_InputFocusReleased			= 401, // data is process DEPRECATED
+	// VREvent_SceneFocusLost			= 402, // data is process
+	// VREvent_SceneFocusGained			= 403, // data is process
+	VREvent_SceneApplicationChanged		= 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+	VREvent_SceneFocusChanged			= 405, // data is process - New app got access to draw the scene
+	VREvent_InputFocusChanged			= 406, // data is process
+	// VREvent_SceneApplicationSecondaryRenderingStarted = 407,
+	VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, // data is process
+	VREvent_ActionBindingReloaded		 = 409, // data is process - The App that action binds reloaded for
+
+	VREvent_HideRenderModels			= 410, // Sent to the scene application to request hiding render models temporarily
+	VREvent_ShowRenderModels			= 411, // Sent to the scene application to request restoring render model visibility
+
+	VREvent_SceneApplicationStateChanged = 412, // No data; but query VRApplications()->GetSceneApplicationState();
+
+	VREvent_ConsoleOpened               = 420,
+	VREvent_ConsoleClosed               = 421,
+
+	VREvent_OverlayShown				= 500,
+	VREvent_OverlayHidden				= 501,
+	VREvent_DashboardActivated			= 502,
+	VREvent_DashboardDeactivated		= 503,
+	//VREvent_DashboardThumbSelected		= 504, // Sent to the overlay manager - data is overlay - No longer sent
+	VREvent_DashboardRequested			= 505, // Sent to the overlay manager - data is overlay
+	VREvent_ResetDashboard				= 506, // Send to the overlay manager
+	//VREvent_RenderToast					= 507, // Send to the dashboard to render a toast - data is the notification ID -- no longer sent
+	VREvent_ImageLoaded					= 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard				= 509, // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard				= 510, // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained	= 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost		= 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	//VREvent_DashboardGuideButtonDown	= 514, // These are no longer sent
+	//VREvent_DashboardGuideButtonUp		= 515,
+	VREvent_ScreenshotTriggered			= 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed					= 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated		= 518,
+	VREvent_SwitchGamepadFocus			= 519,
+
+	// Screenshot API
+	VREvent_RequestScreenshot				= 520, // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken					= 521, // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed				= 522, // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard		= 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard	= 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged	= 525,
+	VREvent_RoomViewShown					= 526, // Sent by compositor whenever room-view is enabled
+	VREvent_RoomViewHidden					= 527, // Sent by compositor whenever room-view is disabled
+	VREvent_ShowUI							= 528, // data is showUi
+	VREvent_ShowDevTools					= 529, // data is showDevTools
+	VREvent_DesktopViewUpdating				= 530,
+	VREvent_DesktopViewReady				= 531,
+
+	VREvent_Notification_Shown				= 600,
+	VREvent_Notification_Hidden				= 601,
+	VREvent_Notification_BeginInteraction	= 602,
+	VREvent_Notification_Destroyed			= 603,
+
+	VREvent_Quit							= 700, // data is process
+	VREvent_ProcessQuit						= 701, // data is process
+	//VREvent_QuitAborted_UserPrompt			= 702, // data is process
+	VREvent_QuitAcknowledged				= 703, // data is process
+	VREvent_DriverRequestedQuit				= 704, // The driver has requested that SteamVR shut down
+	VREvent_RestartRequested				= 705, // A driver or other component wants the user to restart SteamVR
+
+	VREvent_ChaperoneDataHasChanged			= 800, // this will never happen with the new chaperone system
+	VREvent_ChaperoneUniverseHasChanged		= 801,
+	VREvent_ChaperoneTempDataHasChanged		= 802, // this will never happen with the new chaperone system
+	VREvent_ChaperoneSettingsHaveChanged	= 803,
+	VREvent_SeatedZeroPoseReset				= 804,
+	VREvent_ChaperoneFlushCache				= 805, // Sent when the process needs to reload any cached data it retrieved from VRChaperone()
+	VREvent_ChaperoneRoomSetupStarting	    = 806, // Triggered by CVRChaperoneClient::RoomSetupStarting
+	VREvent_ChaperoneRoomSetupFinished	    = 807, // Triggered by CVRChaperoneClient::CommitWorkingCopy
+	VREvent_StandingZeroPoseReset			= 808,
+
+	VREvent_AudioSettingsHaveChanged		= 820,
+
+	VREvent_BackgroundSettingHasChanged				= 850,
+	VREvent_CameraSettingsHaveChanged				= 851,
+	VREvent_ReprojectionSettingHasChanged			= 852,
+	VREvent_ModelSkinSettingsHaveChanged			= 853,
+	VREvent_EnvironmentSettingsHaveChanged			= 854,
+	VREvent_PowerSettingsHaveChanged				= 855,
+	VREvent_EnableHomeAppSettingsHaveChanged		= 856,
+	VREvent_SteamVRSectionSettingChanged			= 857,
+	VREvent_LighthouseSectionSettingChanged			= 858,
+	VREvent_NullSectionSettingChanged				= 859,
+	VREvent_UserInterfaceSectionSettingChanged		= 860,
+	VREvent_NotificationsSectionSettingChanged		= 861,
+	VREvent_KeyboardSectionSettingChanged			= 862,
+	VREvent_PerfSectionSettingChanged				= 863,
+	VREvent_DashboardSectionSettingChanged			= 864,
+	VREvent_WebInterfaceSectionSettingChanged		= 865,
+	VREvent_TrackersSectionSettingChanged			= 866,
+	VREvent_LastKnownSectionSettingChanged			= 867,
+	VREvent_DismissedWarningsSectionSettingChanged	= 868,
+	VREvent_GpuSpeedSectionSettingChanged			= 869,
+	VREvent_WindowsMRSectionSettingChanged			= 870,
+	VREvent_OtherSectionSettingChanged				= 871,
+
+	VREvent_StatusUpdate					= 900,
+
+	VREvent_WebInterface_InstallDriverCompleted = 950,
+
+	VREvent_MCImageUpdated					= 1000,
+
+	VREvent_FirmwareUpdateStarted			= 1100,
+	VREvent_FirmwareUpdateFinished			= 1101,
+
+	VREvent_KeyboardClosed					= 1200,
+	VREvent_KeyboardCharInput				= 1201,
+	VREvent_KeyboardDone					= 1202, // Sent when DONE button clicked on keyboard
+
+	//VREvent_ApplicationTransitionStarted		= 1300,
+	//VREvent_ApplicationTransitionAborted		= 1301,
+	//VREvent_ApplicationTransitionNewAppStarted	= 1302,
+	VREvent_ApplicationListUpdated				= 1303,
+	VREvent_ApplicationMimeTypeLoad				= 1304,
+	// VREvent_ApplicationTransitionNewAppLaunchComplete = 1305,
+	VREvent_ProcessConnected					= 1306,
+	VREvent_ProcessDisconnected					= 1307,
+
+	//VREvent_Compositor_MirrorWindowShown		= 1400, // DEPRECATED
+	//VREvent_Compositor_MirrorWindowHidden		= 1401, // DEPRECATED
+	VREvent_Compositor_ChaperoneBoundsShown		= 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden	= 1411,
+	VREvent_Compositor_DisplayDisconnected		= 1412,
+	VREvent_Compositor_DisplayReconnected		= 1413,
+	VREvent_Compositor_HDCPError				= 1414, // data is hdcpError
+	VREvent_Compositor_ApplicationNotResponding	= 1415,
+	VREvent_Compositor_ApplicationResumed		= 1416,
+	VREvent_Compositor_OutOfVideoMemory			= 1417,
+	VREvent_Compositor_DisplayModeNotSupported	= 1418, // k_pch_SteamVR_PreferredRefreshRate
+	VREvent_Compositor_StageOverrideReady		= 1419,
+
+	VREvent_TrackedCamera_StartVideoStream  = 1500,
+	VREvent_TrackedCamera_StopVideoStream   = 1501,
+	VREvent_TrackedCamera_PauseVideoStream  = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface    = 1550,
+
+	VREvent_PerformanceTest_EnableCapture	= 1600,
+	VREvent_PerformanceTest_DisableCapture	= 1601,
+	VREvent_PerformanceTest_FidelityLevel	= 1602,
+
+	VREvent_MessageOverlay_Closed			= 1650,
+	VREvent_MessageOverlayCloseRequested	= 1651,
+
+	VREvent_Input_HapticVibration			= 1700, // data is hapticVibration
+	VREvent_Input_BindingLoadFailed			= 1701, // data is inputBinding
+	VREvent_Input_BindingLoadSuccessful		= 1702, // data is inputBinding
+	VREvent_Input_ActionManifestReloaded	= 1703, // no data
+	VREvent_Input_ActionManifestLoadFailed	= 1704, // data is actionManifest
+	VREvent_Input_ProgressUpdate			= 1705, // data is progressUpdate
+	VREvent_Input_TrackerActivated			= 1706,
+	VREvent_Input_BindingsUpdated			= 1707,
+	VREvent_Input_BindingSubscriptionChanged = 1708,
+
+	VREvent_SpatialAnchors_PoseUpdated		= 1800,        // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_DescriptorUpdated = 1801,       // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_RequestPoseUpdate = 1802,       // data is spatialAnchor. sent to specific driver
+	VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, // data is spatialAnchor. sent to specific driver
+
+	VREvent_SystemReport_Started			= 1900, // user or system initiated generation of a system report. broadcast
+
+	VREvent_Monitor_ShowHeadsetView			= 2000, // data is process
+	VREvent_Monitor_HideHeadsetView			= 2001, // data is process
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start	= 10000,
+	VREvent_VendorSpecific_Reserved_End		= 19999,
+};
+
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,						// No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,				// Activity (movement or prox sensor) is happening now
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,		// No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,						// Idle for at least 5 seconds (configurable in Settings -> Power Management)
+	k_EDeviceActivityLevel_Idle_Timeout = 4,
+};
+
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System			= 0,
+	k_EButton_ApplicationMenu	= 1,
+	k_EButton_Grip				= 2,
+	k_EButton_DPad_Left			= 3,
+	k_EButton_DPad_Up			= 4,
+	k_EButton_DPad_Right		= 5,
+	k_EButton_DPad_Down			= 6,
+	k_EButton_A					= 7,
+
+	k_EButton_ProximitySensor   = 31,
+
+	k_EButton_Axis0				= 32,
+	k_EButton_Axis1				= 33,
+	k_EButton_Axis2				= 34,
+	k_EButton_Axis3				= 35,
+	k_EButton_Axis4				= 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad	= k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger	= k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back	= k_EButton_Grip,
+
+	k_EButton_IndexController_A		= k_EButton_Grip,
+	k_EButton_IndexController_B		= k_EButton_ApplicationMenu,
+	k_EButton_IndexController_JoyStick	= k_EButton_Axis3,
+
+	k_EButton_Max				= 64
+};
+
+inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button; // EVRButtonId enum
+};
+
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left					= 0x0001,
+	VRMouseButton_Right					= 0x0002,
+	VRMouseButton_Middle				= 0x0004,
+};
+
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button; // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;
+	uint32_t unused;
+	float viewportscale; // For scrolling on an overlay with laser mouse, this is the overlay's vertical size relative to the overlay height. Range: [0,1]
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it). These events are sent to overlays with the VROverlayFlags_SendVRTouchpadEvents
+   flag set.
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+	// If the associated event was triggered by a connection loss
+	bool bConnectionLost;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+	uint64_t devicePath;
+	uint64_t memoryBlockId;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState; // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];	// Up to 11 bytes of new input
+	uint64_t uUserValue;	// Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+	uint64_t reserved2;
+	uint64_t reserved3;
+	uint64_t reserved4;
+	uint64_t reserved5;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+struct VREvent_HapticVibration_t
+{
+	uint64_t containerHandle; // property container handle of the device with the haptic component
+	uint64_t componentHandle; // Which haptic component needs to vibrate
+	float fDurationSeconds;
+	float fFrequency;
+	float fAmplitude;
+};
+
+struct VREvent_WebConsole_t
+{
+	WebConsoleHandle_t webConsoleHandle;
+};
+
+struct VREvent_InputBindingLoad_t
+{
+	vr::PropertyContainerHandle_t ulAppContainer;
+	uint64_t pathMessage;
+	uint64_t pathUrl;
+	uint64_t pathControllerType;
+};
+
+struct VREvent_InputActionManifestLoad_t
+{
+	uint64_t pathAppKey;
+	uint64_t pathMessage;
+	uint64_t pathMessageParam;
+	uint64_t pathManifestPath;
+};
+
+struct VREvent_SpatialAnchor_t
+{
+	SpatialAnchorHandle_t unHandle;
+};
+
+struct VREvent_ProgressUpdate_t
+{
+	uint64_t ulApplicationPropertyContainer;
+	uint64_t pathDevice;
+	uint64_t pathInputSource;
+	uint64_t pathProgressAction;
+	uint64_t pathIcon;
+	float fProgress;
+};
+
+enum EShowUIType
+{
+	ShowUI_ControllerBinding = 0,
+	ShowUI_ManageTrackers = 1,
+	// ShowUI_QuickStart = 2, // Deprecated
+	ShowUI_Pairing = 3,
+	ShowUI_Settings = 4,
+	ShowUI_DebugCommands = 5,
+	ShowUI_FullControllerBinding = 6,
+	ShowUI_ManageDrivers = 7,
+};
+
+struct VREvent_ShowUI_t
+{
+	EShowUIType eType;
+};
+
+struct VREvent_ShowDevTools_t
+{
+	int32_t nBrowserIdentifier;
+};
+
+enum EHDCPError
+{
+	HDCPError_None = 0,
+	HDCPError_LinkLost = 1,
+	HDCPError_Tampered = 2,
+	HDCPError_DeviceRevoked = 3,
+	HDCPError_Unknown = 4
+};
+
+struct VREvent_HDCPError_t
+{
+	EHDCPError eCode;
+};
+
+typedef union
+{
+	VREvent_Reserved_t reserved;
+	VREvent_Controller_t controller;
+	VREvent_Mouse_t mouse;
+	VREvent_Scroll_t scroll;
+	VREvent_Process_t process;
+	VREvent_Notification_t notification;
+	VREvent_Overlay_t overlay;
+	VREvent_Status_t status;
+	VREvent_Keyboard_t keyboard;
+	VREvent_Ipd_t ipd;
+	VREvent_Chaperone_t chaperone;
+	VREvent_PerformanceTest_t performanceTest;
+	VREvent_TouchPadMove_t touchPadMove;
+	VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	VREvent_Screenshot_t screenshot;
+	VREvent_ScreenshotProgress_t screenshotProgress;
+	VREvent_ApplicationLaunch_t applicationLaunch;
+	VREvent_EditingCameraSurface_t cameraSurface;
+	VREvent_MessageOverlay_t messageOverlay;
+	VREvent_Property_t property;
+	VREvent_HapticVibration_t hapticVibration;
+	VREvent_WebConsole_t webConsole;
+	VREvent_InputBindingLoad_t inputBinding;
+	VREvent_InputActionManifestLoad_t actionManifest;
+	VREvent_SpatialAnchor_t spatialAnchor;
+	VREvent_ProgressUpdate_t progressUpdate;
+	VREvent_ShowUI_t showUi;
+	VREvent_ShowDevTools_t showDevTools;
+	VREvent_HDCPError_t hdcpError;
+    /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+} VREvent_Data_t;
+
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack( push, 4 )
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+	uint32_t eventType; // EVREventType enum
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	float eventAgeSeconds;
+	// event data must be the end of the struct as its size is variable
+	VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( pop )
+#endif
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+	VRComponentProperty_IsStatic = (1 << 0),
+	VRComponentProperty_IsVisible = (1 << 1),
+	VRComponentProperty_IsTouched = (1 << 2),
+	VRComponentProperty_IsPressed = (1 << 3),
+	VRComponentProperty_IsScrolled = (1 << 4),
+	VRComponentProperty_IsHighlighted = (1 << 5),
+};
+
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+	HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+	HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+	VRComponentProperties uProperties;
+};
+
+
+enum EVRInputError
+{
+	VRInputError_None = 0,
+	VRInputError_NameNotFound = 1,
+	VRInputError_WrongType = 2,
+	VRInputError_InvalidHandle = 3,
+	VRInputError_InvalidParam = 4,
+	VRInputError_NoSteam = 5,
+	VRInputError_MaxCapacityReached = 6,
+	VRInputError_IPCError = 7,
+	VRInputError_NoActiveActionSet = 8,
+	VRInputError_InvalidDevice = 9,
+	VRInputError_InvalidSkeleton = 10,
+	VRInputError_InvalidBoneCount = 11,
+	VRInputError_InvalidCompressedData = 12,
+	VRInputError_NoData = 13,
+	VRInputError_BufferTooSmall = 14,
+	VRInputError_MismatchedActionManifest = 15,
+	VRInputError_MissingSkeletonData = 16,
+	VRInputError_InvalidBoneIndex = 17,
+	VRInputError_InvalidPriority = 18,
+	VRInputError_PermissionDenied = 19,
+	VRInputError_InvalidRenderModel = 20,
+};
+
+enum EVRSpatialAnchorError
+{
+	VRSpatialAnchorError_Success = 0,
+	VRSpatialAnchorError_Internal = 1,
+	VRSpatialAnchorError_UnknownHandle = 2,
+	VRSpatialAnchorError_ArrayTooSmall = 3,
+	VRSpatialAnchorError_InvalidDescriptorChar = 4,
+	VRSpatialAnchorError_NotYetAvailable = 5,
+	VRSpatialAnchorError_NotAvailableInThisUniverse = 6,
+	VRSpatialAnchorError_PermanentlyUnavailable = 7,
+	VRSpatialAnchorError_WrongDriver = 8,
+	VRSpatialAnchorError_DescriptorTooLong = 9,
+	VRSpatialAnchorError_Unknown = 10,
+	VRSpatialAnchorError_NoRoomCalibration = 11,
+	VRSpatialAnchorError_InvalidArgument = 12,
+	VRSpatialAnchorError_UnknownDriver = 13,
+};
+
+/** The mesh to draw into the stencil (or depth) buffer to perform
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion.
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+	const HmdVector2_t *pVertexData;
+	uint32_t unTriangleCount;
+};
+
+
+enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+
+	k_eHiddenAreaMesh_Max = 3,
+};
+
+
+/** Identifies what kind of axis is on the controller at index n. Read this type
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
+};
+
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+	float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+	float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack( push, 4 )
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+	// If packet num matches that on your prior call, then the controller state hasn't been changed since
+	// your last call and there is no need to process it
+	uint32_t unPacketNum;
+
+	// bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+
+	// Axis data for the controller's analog inputs
+	VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( pop )
+#endif
+
+
+typedef VRControllerState001_t VRControllerState_t;
+
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+};
+
+
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+	COLLISION_BOUNDS_STYLE_SQUARES,
+	COLLISION_BOUNDS_STYLE_ADVANCED,
+	COLLISION_BOUNDS_STYLE_NONE,
+
+	COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None						= 0,
+
+	VROverlayError_UnknownOverlay			= 10,
+	VROverlayError_InvalidHandle			= 11,
+	VROverlayError_PermissionDenied			= 12,
+	VROverlayError_OverlayLimitExceeded		= 13, // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType		= 14,
+	VROverlayError_KeyTooLong				= 15,
+	VROverlayError_NameTooLong				= 16,
+	VROverlayError_KeyInUse					= 17,
+	VROverlayError_WrongTransformType		= 18,
+	VROverlayError_InvalidTrackedDevice		= 19,
+	VROverlayError_InvalidParameter			= 20,
+	VROverlayError_ThumbnailCantBeDestroyed	= 21,
+	VROverlayError_ArrayTooSmall			= 22,
+	VROverlayError_RequestFailed			= 23,
+	VROverlayError_InvalidTexture			= 24,
+	VROverlayError_UnableToLoadFile			= 25,
+	VROverlayError_KeyboardAlreadyInUse		= 26,
+	VROverlayError_NoNeighbor				= 27,
+	VROverlayError_TooManyMaskPrimitives	= 29,
+	VROverlayError_BadMaskPrimitive			= 30,
+	VROverlayError_TextureAlreadyLocked		= 31,
+	VROverlayError_TextureLockCapacityReached = 32,
+	VROverlayError_TextureNotLocked			= 33,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,		// Some other kind of application that isn't covered by the other entries
+	VRApplication_Scene	= 1,		// Application will submit 3D frames
+	VRApplication_Overlay = 2,		// Application only interacts with overlays
+	VRApplication_Background = 3,	// Application should not start SteamVR if it's not already running, and should not
+									// keep it running if everything else quits.
+	VRApplication_Utility = 4,		// Init should not try to load any drivers. The application needs access to utility
+									// interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,	// Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,// Reserved for Steam
+	VRApplication_Bootstrapper = 7, // reserved for vrstartup
+	VRApplication_WebHelper = 8,	// reserved for vrwebhelper
+	VRApplication_OpenXRInstance = 9, // reserved for openxr (created instance, but not session yet)
+	VRApplication_OpenXRScene = 10,	  // reserved for openxr (started session)
+	VRApplication_OpenXROverlay = 11, // reserved for openxr (started overlay session)
+	VRApplication_Prism = 12,		// reserved for the vrprismhost process
+
+	VRApplication_Max
+};
+
+
+/** returns true if the specified application type is one of the
+* OpenXR types */
+inline bool IsOpenXRAppType( EVRApplicationType eType )
+{
+	return eType == VRApplication_OpenXRInstance
+		|| eType == VRApplication_OpenXRScene
+		|| eType == VRApplication_OpenXROverlay;
+}
+
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+
+enum EVRSkeletalMotionRange
+{
+	// The range of motion of the skeleton takes into account any physical limits imposed by
+	// the controller itself.  This will tend to be the most accurate pose compared to the user's
+	// actual hand pose, but might not allow a closed fist for example
+	VRSkeletalMotionRange_WithController = 0,
+
+	// Retarget the range of motion provided by the input device to make the hand appear to move
+	// as if it was not holding a controller.  eg: map "hand grasping controller" to "closed fist"
+	VRSkeletalMotionRange_WithoutController = 1,
+};
+
+enum EVRSkeletalTrackingLevel
+{
+	// body part location can't be directly determined by the device. Any skeletal pose provided by
+	// the device is estimated by assuming the position required to active buttons, triggers, joysticks,
+	// or other input sensors.
+	// E.g. Vive Controller, Gamepad
+	VRSkeletalTracking_Estimated = 0,
+
+	// body part location can be measured directly but with fewer degrees of freedom than the actual body
+	// part. Certain body part positions may be unmeasured by the device and estimated from other input data.
+	// E.g. Index Controllers, gloves that only measure finger curl
+	VRSkeletalTracking_Partial = 1,
+
+	// Body part location can be measured directly throughout the entire range of motion of the body part.
+	// E.g. Mocap suit for the full body, gloves that measure rotation of each finger segment
+	VRSkeletalTracking_Full = 2,
+
+	VRSkeletalTrackingLevel_Count,
+	VRSkeletalTrackingLevel_Max = VRSkeletalTrackingLevel_Count - 1
+};
+
+
+/** Type used for referring to bones by their index */
+typedef int32_t BoneIndex_t;
+const BoneIndex_t k_unInvalidBoneIndex = -1;
+
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None	= 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound			= 100,
+	VRInitError_Init_InstallationCorrupt			= 101,
+	VRInitError_Init_VRClientDLLNotFound			= 102,
+	VRInitError_Init_FileNotFound					= 103,
+	VRInitError_Init_FactoryNotFound				= 104,
+	VRInitError_Init_InterfaceNotFound				= 105,
+	VRInitError_Init_InvalidInterface				= 106,
+	VRInitError_Init_UserConfigDirectoryInvalid		= 107,
+	VRInitError_Init_HmdNotFound					= 108,
+	VRInitError_Init_NotInitialized					= 109,
+	VRInitError_Init_PathRegistryNotFound			= 110,
+	VRInitError_Init_NoConfigPath					= 111,
+	VRInitError_Init_NoLogPath						= 112,
+	VRInitError_Init_PathRegistryNotWritable		= 113,
+	VRInitError_Init_AppInfoInitFailed				= 114,
+	VRInitError_Init_Retry							= 115, // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser				= 116, // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching			= 117,
+	VRInitError_Init_SettingsInitFailed				= 118,
+	VRInitError_Init_ShuttingDown					= 119,
+	VRInitError_Init_TooManyObjects					= 120,
+	VRInitError_Init_NoServerForBackgroundApp		= 121,
+	VRInitError_Init_NotSupportedWithCompositor		= 122,
+	VRInitError_Init_NotAvailableToUtilityApps		= 123,
+	VRInitError_Init_Internal				 		= 124,
+	VRInitError_Init_HmdDriverIdIsNone		 		= 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed 		= 126,
+	VRInitError_Init_VRMonitorNotFound				= 127,
+	VRInitError_Init_VRMonitorStartupFailed			= 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported	= 129,
+	VRInitError_Init_InvalidApplicationType			= 130,
+	VRInitError_Init_NotAvailableToWatchdogApps		= 131,
+	VRInitError_Init_WatchdogDisabledInSettings		= 132,
+	VRInitError_Init_VRDashboardNotFound			= 133,
+	VRInitError_Init_VRDashboardStartupFailed		= 134,
+	VRInitError_Init_VRHomeNotFound					= 135,
+	VRInitError_Init_VRHomeStartupFailed			= 136,
+	VRInitError_Init_RebootingBusy					= 137,
+	VRInitError_Init_FirmwareUpdateBusy				= 138,
+	VRInitError_Init_FirmwareRecoveryBusy			= 139,
+	VRInitError_Init_USBServiceBusy					= 140,
+	VRInitError_Init_VRWebHelperStartupFailed		= 141,
+	VRInitError_Init_TrackerManagerInitFailed		= 142,
+	VRInitError_Init_AlreadyRunning					= 143,
+	VRInitError_Init_FailedForVrMonitor				= 144,
+	VRInitError_Init_PropertyManagerInitFailed		= 145,
+	VRInitError_Init_WebServerFailed				= 146,
+	VRInitError_Init_IllegalTypeTransition			= 147,
+	VRInitError_Init_MismatchedRuntimes				= 148,
+	VRInitError_Init_InvalidProcessId				= 149,
+	VRInitError_Init_VRServiceStartupFailed			= 150,
+	VRInitError_Init_PrismNeedsNewDrivers			= 151,
+	VRInitError_Init_PrismStartupTimedOut			= 152,
+	VRInitError_Init_CouldNotStartPrism				= 153,
+	VRInitError_Init_CreateDriverDirectDeviceFailed = 154,
+	VRInitError_Init_PrismExitedUnexpectedly		= 155,
+
+	VRInitError_Driver_Failed						= 200,
+	VRInitError_Driver_Unknown						= 201,
+	VRInitError_Driver_HmdUnknown					= 202,
+	VRInitError_Driver_NotLoaded					= 203,
+	VRInitError_Driver_RuntimeOutOfDate				= 204,
+	VRInitError_Driver_HmdInUse						= 205,
+	VRInitError_Driver_NotCalibrated				= 206,
+	VRInitError_Driver_CalibrationInvalid			= 207,
+	VRInitError_Driver_HmdDisplayNotFound			= 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds		= 211,
+	VRInitError_Driver_HmdDisplayMirrored			= 212,
+	VRInitError_Driver_HmdDisplayNotFoundLaptop		= 213,
+	// Never make error 259 because we return it from main and it would conflict with STILL_ACTIVE
+
+	VRInitError_IPC_ServerInitFailed				= 300,
+	VRInitError_IPC_ConnectFailed					= 301,
+	VRInitError_IPC_SharedStateInitFailed			= 302,
+	VRInitError_IPC_CompositorInitFailed			= 303,
+	VRInitError_IPC_MutexInitFailed					= 304,
+	VRInitError_IPC_Failed							= 305,
+	VRInitError_IPC_CompositorConnectFailed			= 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
+	VRInitError_IPC_NamespaceUnavailable			 = 310,
+
+	VRInitError_Compositor_Failed												= 400,
+	VRInitError_Compositor_D3D11HardwareRequired								= 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate								= 402,
+	VRInitError_Compositor_OverlayInitFailed									= 403,
+	VRInitError_Compositor_ScreenshotsInitFailed								= 404,
+	VRInitError_Compositor_UnableToCreateDevice									= 405,
+	VRInitError_Compositor_SharedStateIsNull									= 406,
+	VRInitError_Compositor_NotificationManagerIsNull							= 407,
+	VRInitError_Compositor_ResourceManagerClientIsNull							= 408,
+	VRInitError_Compositor_MessageOverlaySharedStateInitFailure					= 409,
+	VRInitError_Compositor_PropertiesInterfaceIsNull							= 410,
+	VRInitError_Compositor_CreateFullscreenWindowFailed							= 411,
+	VRInitError_Compositor_SettingsInterfaceIsNull								= 412,
+	VRInitError_Compositor_FailedToShowWindow									= 413,
+	VRInitError_Compositor_DistortInterfaceIsNull								= 414,
+	VRInitError_Compositor_DisplayFrequencyFailure								= 415,
+	VRInitError_Compositor_RendererInitializationFailed							= 416,
+	VRInitError_Compositor_DXGIFactoryInterfaceIsNull							= 417,
+	VRInitError_Compositor_DXGIFactoryCreateFailed								= 418,
+	VRInitError_Compositor_DXGIFactoryQueryFailed								= 419,
+	VRInitError_Compositor_InvalidAdapterDesktop								= 420,
+	VRInitError_Compositor_InvalidHmdAttachment									= 421,
+	VRInitError_Compositor_InvalidOutputDesktop									= 422,
+	VRInitError_Compositor_InvalidDeviceProvided								= 423,
+	VRInitError_Compositor_D3D11RendererInitializationFailed					= 424,
+	VRInitError_Compositor_FailedToFindDisplayMode								= 425,
+	VRInitError_Compositor_FailedToCreateSwapChain								= 426,
+	VRInitError_Compositor_FailedToGetBackBuffer								= 427,
+	VRInitError_Compositor_FailedToCreateRenderTarget							= 428,
+	VRInitError_Compositor_FailedToCreateDXGI2SwapChain							= 429,
+	VRInitError_Compositor_FailedtoGetDXGI2BackBuffer							= 430,
+	VRInitError_Compositor_FailedToCreateDXGI2RenderTarget						= 431,
+	VRInitError_Compositor_FailedToGetDXGIDeviceInterface						= 432,
+	VRInitError_Compositor_SelectDisplayMode									= 433,
+	VRInitError_Compositor_FailedToCreateNvAPIRenderTargets						= 434,
+	VRInitError_Compositor_NvAPISetDisplayMode									= 435,
+	VRInitError_Compositor_FailedToCreateDirectModeDisplay						= 436,
+	VRInitError_Compositor_InvalidHmdPropertyContainer							= 437,
+	VRInitError_Compositor_UpdateDisplayFrequency								= 438,
+	VRInitError_Compositor_CreateRasterizerState								= 439,
+	VRInitError_Compositor_CreateWireframeRasterizerState						= 440,
+	VRInitError_Compositor_CreateSamplerState									= 441,
+	VRInitError_Compositor_CreateClampToBorderSamplerState						= 442,
+	VRInitError_Compositor_CreateAnisoSamplerState								= 443,
+	VRInitError_Compositor_CreateOverlaySamplerState							= 444,
+	VRInitError_Compositor_CreatePanoramaSamplerState							= 445,
+	VRInitError_Compositor_CreateFontSamplerState								= 446,
+	VRInitError_Compositor_CreateNoBlendState									= 447,
+	VRInitError_Compositor_CreateBlendState										= 448,
+	VRInitError_Compositor_CreateAlphaBlendState								= 449,
+	VRInitError_Compositor_CreateBlendStateMaskR								= 450,
+	VRInitError_Compositor_CreateBlendStateMaskG								= 451,
+	VRInitError_Compositor_CreateBlendStateMaskB								= 452,
+	VRInitError_Compositor_CreateDepthStencilState								= 453,
+	VRInitError_Compositor_CreateDepthStencilStateNoWrite						= 454,
+	VRInitError_Compositor_CreateDepthStencilStateNoDepth						= 455,
+	VRInitError_Compositor_CreateFlushTexture									= 456,
+	VRInitError_Compositor_CreateDistortionSurfaces								= 457,
+	VRInitError_Compositor_CreateConstantBuffer									= 458,
+	VRInitError_Compositor_CreateHmdPoseConstantBuffer							= 459,
+	VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer					= 460,
+	VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer					= 461,
+	VRInitError_Compositor_CreateOverlayConstantBuffer							= 462,
+	VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer				= 463,
+	VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer		= 464,
+	VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer		= 465,
+	VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer			= 466,
+	VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer	= 467,
+	VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer					= 468,
+	VRInitError_Compositor_CreateGeomConstantBuffer								= 469,
+	VRInitError_Compositor_CreatePanelMaskConstantBuffer						= 470,
+	VRInitError_Compositor_CreatePixelSimUBO									= 471,
+	VRInitError_Compositor_CreateMSAARenderTextures								= 472,
+	VRInitError_Compositor_CreateResolveRenderTextures							= 473,
+	VRInitError_Compositor_CreateComputeResolveRenderTextures					= 474,
+	VRInitError_Compositor_CreateDriverDirectModeResolveTextures				= 475,
+	VRInitError_Compositor_OpenDriverDirectModeResolveTextures					= 476,
+	VRInitError_Compositor_CreateFallbackSyncTexture							= 477,
+	VRInitError_Compositor_ShareFallbackSyncTexture								= 478,
+	VRInitError_Compositor_CreateOverlayIndexBuffer								= 479,
+	VRInitError_Compositor_CreateOverlayVertexBuffer							= 480,
+	VRInitError_Compositor_CreateTextVertexBuffer								= 481,
+	VRInitError_Compositor_CreateTextIndexBuffer								= 482,
+	VRInitError_Compositor_CreateMirrorTextures									= 483,
+	VRInitError_Compositor_CreateLastFrameRenderTexture							= 484,
+	VRInitError_Compositor_CreateMirrorOverlay									= 485,
+	VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer				= 486,
+	VRInitError_Compositor_DisplayModeNotSupported								= 487,
+	VRInitError_Compositor_CreateOverlayInvalidCall								= 488,
+	VRInitError_Compositor_CreateOverlayAlreadyInitialized						= 489,
+	VRInitError_Compositor_FailedToCreateMailbox								= 490,
+	VRInitError_Compositor_WindowInterfaceIsNull								= 491,
+	VRInitError_Compositor_SystemLayerCreateInstance							= 492,
+	VRInitError_Compositor_SystemLayerCreateSession								= 493,
+
+	VRInitError_VendorSpecific_UnableToConnectToOculusRuntime		= 1000,
+	VRInitError_VendorSpecific_WindowsNotInDevMode					= 1001,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice 				= 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart	= 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig 				= 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig 				= 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall 				= 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib 			= 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion 	= 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart	= 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart	= 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext		= 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange		= 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError				= 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck		= 1113,
+	VRInitError_VendorSpecific_OculusRuntimeBadInstall				= 1114,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+
+	// Strictly a placeholder
+	VRInitError_LastError
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1, // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None                       = 0,
+	VRTrackedCameraError_OperationFailed            = 100,
+	VRTrackedCameraError_InvalidHandle              = 101,
+	VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
+	VRTrackedCameraError_OutOfHandles               = 103,
+	VRTrackedCameraError_IPCFailure                 = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice  = 105,
+	VRTrackedCameraError_SharedMemoryFailure        = 106,
+	VRTrackedCameraError_FrameBufferingFailure      = 107,
+	VRTrackedCameraError_StreamSetupFailure         = 108,
+	VRTrackedCameraError_InvalidGLTextureId         = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId     = 111,
+	VRTrackedCameraError_SharedTextureFailure       = 112,
+	VRTrackedCameraError_NoFrameAvailable           = 113,
+	VRTrackedCameraError_InvalidArgument            = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize     = 115,
+};
+
+enum EVRTrackedCameraFrameLayout
+{
+	EVRTrackedCameraFrameLayout_Mono				= 0x0001,
+	EVRTrackedCameraFrameLayout_Stereo				= 0x0002,
+	EVRTrackedCameraFrameLayout_VerticalLayout		= 0x0010,	// Stereo frames are Top/Bottom (left/right)
+	EVRTrackedCameraFrameLayout_HorizontalLayout	= 0x0020,	// Stereo frames are Left/Right
+};
+
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,			// This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,			// In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,	// In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+enum EVRDistortionFunctionType
+{
+	VRDistortionFunctionType_None,
+	VRDistortionFunctionType_FTheta,
+	VRDistortionFunctionType_Extended_FTheta,
+	MAX_DISTORTION_FUNCTION_TYPES,
+};
+
+static const uint32_t k_unMaxDistortionFunctionParameters = 8;
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE	((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t trackedDevicePose;
+
+	uint64_t ulFrameExposureTime;						// mid-point of the exposure of the image in host system ticks
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+/** Compositor frame timing reprojection flags. */
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;	// This flag indicates the async reprojection mode is active,
+															// but does not indicate if reprojection actually happened or not.
+															// Use the ReprojectionReason flags above to check if reprojection
+															// was actually applied (i.e. scene texture was reused).
+															// NumFramePresents > 1 also indicates the scene texture was reused,
+															// and also the number of times that it was presented in total.
+
+const uint32_t VRCompositor_ReprojectionMotion = 0x08;	// This flag indicates whether or not motion smoothing was triggered for this frame
+
+const uint32_t VRCompositor_PredictionMask = 0xF0;	// The runtime may predict more than one frame (up to four) ahead if
+															// it detects the application is taking too long to render. These two
+															// bits will contain the count of additional frames (normally zero).
+															// Use the VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+const uint32_t VRCompositor_ThrottleMask = 0xF00;	// Number of frames the compositor is throttling the application.
+															// Use the VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+#define VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_PredictionMask ) >> 4 )
+#define VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_ThrottleMask ) >> 8 )
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents; // number of times this frame was presented
+	uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
+
+	uint32_t m_nNumVSyncsReadyForUse;
+	uint32_t m_nNumVSyncsToFirstView;
+};
+
+/** Provides compositor benchmark results to the app */
+struct Compositor_BenchmarkResults
+{
+	float m_flMegaPixelsPerSecond; // Measurement of GPU MP/s performed by compositor benchmark
+	float m_flHmdRecommendedMegaPixelsPerSecond; // Recommended default MP/s given the HMD resolution, refresh, and panel mask.
+};
+
+/** Frame timing data provided by direct mode drivers. */
+struct DriverDirectMode_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( DriverDirectMode_FrameTiming )
+	uint32_t m_nNumFramePresents; // number of times frame was presented
+	uint32_t m_nNumMisPresented; // number of times frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out (i.e. compositor missed vsync)
+	uint32_t m_nReprojectionFlags;
+};
+
+/** These flags will be set on DriverDirectMode_FrameTiming::m_nReprojectionFlags when IVRDriverDirectModeComponent::GetFrameTiming is called for drivers to optionally respond to. */
+const uint32_t VRCompositor_ReprojectionMotion_Enabled = 0x100; // Motion Smoothing is enabled in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_ForcedOn = 0x200; // Motion Smoothing is forced on in the UI for the currently running application
+const uint32_t VRCompositor_ReprojectionMotion_AppThrottled = 0x400; // Application is requesting throttling via ForceInterleavedReprojectionOn
+
+
+enum EVSync
+{
+	VSync_None,
+	VSync_WaitRender,	// block following render work until vsync
+	VSync_NoWaitRender,	// do not block following render work (allow to get started early)
+};
+
+enum EVRMuraCorrectionMode
+{
+	EVRMuraCorrectionMode_Default = 0,
+	EVRMuraCorrectionMode_NoCorrection
+};
+
+/** raw IMU data provided by IVRIOBuffer from paths to tracked devices with IMUs */
+enum Imu_OffScaleFlags
+{
+	OffScale_AccelX	= 0x01,
+	OffScale_AccelY	= 0x02,
+	OffScale_AccelZ	= 0x04,
+	OffScale_GyroX	= 0x08,
+	OffScale_GyroY	= 0x10,
+	OffScale_GyroZ	= 0x20,
+};
+
+struct ImuSample_t
+{
+	double fSampleTime;
+	HmdVector3d_t vAccel;
+	HmdVector3d_t vGyro;
+	uint32_t unOffScaleFlags;
+};
+
+#pragma pack( pop )
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+  #if !defined(OPENVR_BUILD_STATIC)
+    #ifdef VR_API_EXPORT
+      #define VR_INTERFACE extern "C" __declspec( dllexport )
+    #else
+      #define VR_INTERFACE extern "C" __declspec( dllimport )
+    #endif
+  #else
+    #define VR_INTERFACE extern "C"
+  #endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+  #define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+  #define VR_INTERFACE extern "C"
+#endif
+
+#else
+  #error "Unsupported Platform."
+#endif
+
+
+#if defined( _WIN32 )
+  #define VR_CALLTYPE __cdecl
+#else
+  #define VR_CALLTYPE
+#endif
+
+} // namespace vr
+#endif // _INCLUDE_VRTYPES_H
+
+// vrannotation.h
+
+#ifdef API_GEN
+# define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
+#else
+# define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
+#define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
+#define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
+#define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
+#define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
+
+// ivrsystem.h
+
+namespace vr
+{
+
+class IVRSystem
+{
+public:
+
+
+	// ------------------------------------
+	// Display Methods
+	// ------------------------------------
+
+	/** Suggested size for the intermediate render target that the distortion pulls from. */
+	virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+	/** The projection matrix for the specified eye */
+	virtual HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) = 0;
+
+	/** The components necessary to build your own projection matrix in case your
+	* application is doing something fancy like infinite Z */
+	virtual void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
+
+	/** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in
+	* the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+	* Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+	virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) = 0;
+
+	/** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+	* space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection.
+	* Normally View and Eye^-1 will be multiplied together and treated as View in your application.
+	*/
+	virtual HmdMatrix34_t GetEyeToHeadTransform( EVREye eEye ) = 0;
+
+	/** Returns the number of elapsed seconds since the last recorded vsync event. This
+	*	will come from a vsync timer event in the timer if possible or from the application-reported
+	*   time if that is not available. If no vsync times are available the function will
+	*   return zero for vsync time and frame counter and return false from the method. */
+	virtual bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) = 0;
+
+	/** [D3D9 Only]
+	* Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+	* a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+	*/
+	virtual int32_t GetD3D9AdapterIndex() = 0;
+
+	/** [D3D10/11 Only]
+	* Returns the adapter index that the user should pass into EnumAdapters to create the device
+	* and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+	*/
+	virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex ) = 0;
+
+	/**
+	 * Returns platform- and texture-type specific adapter identification so that applications and the
+	 * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+	 * will be set to 0.
+	 * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+	 * [D3D10/11/12 Only (D3D9 Not Supported)]
+	 *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+	 *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+	 *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+	 *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+	 * [Vulkan Only]
+	 *  Returns the VkPhysicalDevice that should be used by the application.
+	 *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+	 *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+	 * [macOS Only]
+	 *  For TextureType_IOSurface returns the id<MTLDevice> that should be used by the application.
+	 *  On 10.13+ for TextureType_OpenGL returns the 'registryId' of the renderer which should be used
+	 *   by the application. See Apple Technical Q&A QA1168 for information on enumerating GL Renderers, and the
+	 *   new kCGLRPRegistryIDLow and kCGLRPRegistryIDHigh CGLRendererProperty values in the 10.13 SDK.
+	 *  Pre 10.13 for TextureType_OpenGL returns 0, as there is no dependable way to correlate the HMDs MTLDevice
+	 *   with a GL Renderer.
+	 */
+	virtual void GetOutputDevice( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr ) = 0;
+
+	// ------------------------------------
+	// Display Mode methods
+	// ------------------------------------
+
+	/** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+	virtual bool IsDisplayOnDesktop() = 0;
+
+	/** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+	virtual bool SetDisplayVisibility( bool bIsVisibleOnDesktop ) = 0;
+
+	// ------------------------------------
+	// Tracking Methods
+	// ------------------------------------
+
+	/** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the
+	* future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+	* calculate the time until the photons will be emitted from the display and pass that time into the method.
+	*
+	* This is roughly analogous to the inverse of the view matrix in most applications, though
+	* many games will need to do some additional rotation or translation on top of the rotation
+	* and translation provided by the head pose.
+	*
+	* For devices where bPoseIsValid is true the application can use the pose to position the device
+	* in question. The provided array can be any size up to k_unMaxTrackedDeviceCount.
+	*
+	* Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+	* to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding
+	* and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should
+	* probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+	* poses relative to the hardware-specific coordinate system in the driver.
+	*/
+	virtual void GetDeviceToAbsoluteTrackingPose( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) = 0;
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other.
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	virtual uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) = 0;
+
+	/** Returns the level of activity on the device. */
+	virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) = 0;
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	virtual void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) = 0;
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. This function is deprecated in favor of the new IVRInput system. */
+	virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) = 0;
+
+	/** Returns the controller type associated with a device index. This function is deprecated in favor of the new IVRInput system. */
+	virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class.
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an
+	* actual tracked device. */
+	virtual ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	/** Returns true if there is a device connected in this slot. */
+	virtual bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	virtual bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	virtual float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	virtual int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	virtual uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
+	* this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
+	* greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties. */
+	virtual uint32_t GetArrayTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) = 0;
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct.
+	* This pose will always be older than the call to this function and should not be used to render the device.
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+	/** returns the name of an EVREvent enum value */
+	virtual const char *GetEventTypeNameFromEnum( EVREventType eType ) = 0;
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view.
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) = 0;
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. This function is deprecated in favor of the new IVRInput system. */
+	virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) = 0;
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. This function is deprecated in favor of the new IVRInput system. */
+	virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. This function is deprecated in favor of the new IVRInput system. */
+	virtual void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) = 0;
+
+	/** returns the name of an EVRButtonId enum value. This function is deprecated in favor of the new IVRInput system.  */
+	virtual const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) = 0;
+
+	/** returns the name of an EVRControllerAxisType enum value. This function is deprecated in favor of the new IVRInput system. */
+	virtual const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) = 0;
+
+	/** Returns true if this application is receiving input from the system. This would return false if
+	* system-related functionality is consuming the input stream. */
+	virtual bool IsInputAvailable() = 0;
+
+	/** Returns true SteamVR is drawing controllers on top of the application. Applications should consider
+	* not drawing anything attached to the user's hands in this case. */
+	virtual bool IsSteamVRDrawingControllers() = 0;
+
+	/** Returns true if the user has put SteamVR into a mode that is distracting them from the application.
+	* For applications where this is appropriate, the application should pause ongoing activity. */
+	virtual bool ShouldApplicationPause() = 0;
+
+	/** Returns true if SteamVR is doing significant rendering work and the game should do what it can to reduce
+	* its own workload. One common way to do this is to reduce the size of the render target provided for each eye. */
+	virtual bool ShouldApplicationReduceRenderingWork() = 0;
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+
+	/** Performs the actual firmware update if applicable.
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	virtual vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	virtual void AcknowledgeQuit_Exiting() = 0;
+
+	// -------------------------------------
+	// App container sandbox methods
+	// -------------------------------------
+
+	/** Retrieves a null-terminated, semicolon-delimited list of UTF8 file paths that an application
+	* must have read access to when running inside of an app container. Returns the number of bytes
+	* needed to hold the list. */
+	virtual uint32_t GetAppContainerFilePaths( VR_OUT_STRING() char *pchBuffer, uint32_t unBufferSize ) = 0;
+
+	// -------------------------------------
+	// System methods
+	// -------------------------------------
+
+	/** Returns the current version of the SteamVR runtime. The returned string will remain valid until VR_Shutdown is called.
+	*
+	* NOTE: Is it not appropriate to use this version to test for the presence of any SteamVR feature. Only use this version
+	* number for logging or showing to a user, and not to try to detect anything at runtime. When appropriate, feature-specific
+	* presence information is provided by other APIs. */
+	virtual const char *GetRuntimeVersion() = 0;
+
+};
+
+static const char * const IVRSystem_Version = "IVRSystem_022";
+
+}
+
+
+// ivrapplications.h
+
+namespace vr
+{
+
+	/** Used for all errors reported by the IVRApplications interface */
+	enum EVRApplicationError
+	{
+		VRApplicationError_None = 0,
+
+		VRApplicationError_AppKeyAlreadyExists = 100,	// Only one application can use any given key
+		VRApplicationError_NoManifest = 101,			// the running application does not have a manifest
+		VRApplicationError_NoApplication = 102,			// No application is running
+		VRApplicationError_InvalidIndex = 103,
+		VRApplicationError_UnknownApplication = 104,	// the application could not be found
+		VRApplicationError_IPCFailed = 105,				// An IPC failure caused the request to fail
+		VRApplicationError_ApplicationAlreadyRunning = 106,
+		VRApplicationError_InvalidManifest = 107,
+		VRApplicationError_InvalidApplication = 108,
+		VRApplicationError_LaunchFailed = 109,			// the process didn't start
+		VRApplicationError_ApplicationAlreadyStarting = 110, // the system was already starting the same application
+		VRApplicationError_LaunchInProgress = 111,		// The system was already starting a different application
+		VRApplicationError_OldApplicationQuitting = 112,
+		VRApplicationError_TransitionAborted = 113,
+		VRApplicationError_IsTemplate = 114, // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+		VRApplicationError_SteamVRIsExiting = 115,
+
+		VRApplicationError_BufferTooSmall = 200,		// The provided buffer was too small to fit the requested data
+		VRApplicationError_PropertyNotSet = 201,		// The requested property was not set
+		VRApplicationError_UnknownProperty = 202,
+		VRApplicationError_InvalidParameter = 203,
+
+		VRApplicationError_NotImplemented = 300,  // Fcn is not implemented in current interface
+	};
+
+	/** The maximum length of an application key */
+	static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+	/** these are the properties available on applications. */
+	enum EVRApplicationProperty
+	{
+		VRApplicationProperty_Name_String				= 0,
+
+		VRApplicationProperty_LaunchType_String			= 11,
+		VRApplicationProperty_WorkingDirectory_String	= 12,
+		VRApplicationProperty_BinaryPath_String			= 13,
+		VRApplicationProperty_Arguments_String			= 14,
+		VRApplicationProperty_URL_String				= 15,
+
+		VRApplicationProperty_Description_String		= 50,
+		VRApplicationProperty_NewsURL_String			= 51,
+		VRApplicationProperty_ImagePath_String			= 52,
+		VRApplicationProperty_Source_String				= 53,
+		VRApplicationProperty_ActionManifestURL_String	= 54,
+
+		VRApplicationProperty_IsDashboardOverlay_Bool	= 60,
+		VRApplicationProperty_IsTemplate_Bool			= 61,
+		VRApplicationProperty_IsInstanced_Bool			= 62,
+		VRApplicationProperty_IsInternal_Bool			= 63,
+		VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+		VRApplicationProperty_IsHidden_Bool				= 65,
+
+		VRApplicationProperty_LastLaunchTime_Uint64		= 70,
+	};
+
+	enum EVRSceneApplicationState
+	{
+		EVRSceneApplicationState_None						      = 0, // Scene Application is not running
+		EVRSceneApplicationState_Starting					      = 1, // Scene Application is starting
+		EVRSceneApplicationState_Quitting					      = 2, // Scene Application is quitting
+		EVRSceneApplicationState_Running						  = 3, // Scene Application is running, and submitting frames, a custom skybox, or a visible overlay
+		EVRSceneApplicationState_Waiting						  = 4, // Scene Application is running, but not drawing anything
+	};
+
+	struct AppOverrideKeys_t
+	{
+		const char *pchKey;
+		const char *pchValue;
+	};
+
+	/** Currently recognized mime types */
+	static const char * const k_pch_MimeType_HomeApp		= "vr/home";
+	static const char * const k_pch_MimeType_GameTheater	= "vr/game_theater";
+
+	class IVRApplications
+	{
+	public:
+
+		// ---------------  Application management  --------------- //
+
+		/** Adds an application manifest to the list to load when building the list of installed applications.
+		* Temporary manifests are not automatically loaded */
+		virtual EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) = 0;
+
+		/** Removes an application manifest from the list to load when building the list of installed applications. */
+		virtual EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) = 0;
+
+		/** Returns true if an application is installed */
+		virtual bool IsApplicationInstalled( const char *pchAppKey ) = 0;
+
+		/** Returns the number of applications available in the list */
+		virtual uint32_t GetApplicationCount() = 0;
+
+		/** Returns the key of the specified application. The index is at least 0 and is less than the return
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to
+		* fit the key. */
+		virtual EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Returns the key of the application for the specified Process Id. The buffer should be at least
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+		virtual EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+		virtual EVRApplicationError LaunchApplication( const char *pchAppKey ) = 0;
+
+		/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+		virtual EVRApplicationError LaunchTemplateApplication( const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT( unKeys ) const AppOverrideKeys_t *pKeys, uint32_t unKeys ) = 0;
+
+		/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+		virtual vr::EVRApplicationError LaunchApplicationFromMimeType( const char *pchMimeType, const char *pchArgs ) = 0;
+
+		/** Launches the dashboard overlay application if it is not already running. This call is only valid for
+		* dashboard overlay applications. */
+		virtual EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) = 0;
+
+		/** Cancel a pending launch for an application */
+		virtual bool CancelApplicationLaunch( const char *pchAppKey ) = 0;
+
+		/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key
+		* for the now running application. Passing a process ID of 0 identifies the calling process.
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+		virtual EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) = 0;
+
+		/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+		virtual uint32_t GetApplicationProcessId( const char *pchAppKey ) = 0;
+
+		/** Returns a string for an applications error */
+		virtual const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) = 0;
+
+		// ---------------  Application properties  --------------- //
+
+		/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+		virtual uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Returns a bool value for an application property. Returns false in all error cases. */
+		virtual bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+		virtual uint64_t GetApplicationPropertyUint64( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		virtual EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) = 0;
+
+		/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		virtual bool GetApplicationAutoLaunch( const char *pchAppKey ) = 0;
+
+		/** Adds this mime-type to the list of supported mime types for this application*/
+		virtual EVRApplicationError SetDefaultApplicationForMimeType( const char *pchAppKey, const char *pchMimeType ) = 0;
+
+		/** return the app key that will open this mime type */
+		virtual bool GetDefaultApplicationForMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Get the list of supported mime types for this application, comma-delimited */
+		virtual bool GetApplicationSupportedMimeTypes( const char *pchAppKey, VR_OUT_STRING() char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer ) = 0;
+
+		/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+		virtual uint32_t GetApplicationsThatSupportMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer ) = 0;
+
+		/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+		virtual uint32_t GetApplicationLaunchArguments( uint32_t unHandle, VR_OUT_STRING() char *pchArgs, uint32_t unArgs ) = 0;
+
+		// ---------------  Transition methods --------------- //
+
+		/** Returns the app key for the application that is starting up */
+		virtual EVRApplicationError GetStartingApplication( VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Returns the application transition state */
+		virtual EVRSceneApplicationState GetSceneApplicationState() = 0;
+
+		/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+		virtual EVRApplicationError PerformApplicationPrelaunchCheck( const char *pchAppKey ) = 0;
+
+		/** Returns a string for an application transition state */
+		virtual const char *GetSceneApplicationStateNameFromEnum( EVRSceneApplicationState state ) = 0;
+
+		/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable
+		* as part of the same application. On success the calling process should exit immediately.
+		* If working directory is NULL or "" the directory portion of the binary path will be
+		* the working directory. */
+		virtual EVRApplicationError LaunchInternalProcess( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory ) = 0;
+
+		/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+		virtual uint32_t GetCurrentSceneProcessId() = 0;
+	};
+
+	static const char * const IVRApplications_Version = "IVRApplications_007";
+
+} // namespace vr
+
+// ivrsettings.h
+
+#include <string>
+
+namespace vr
+{
+	enum EVRSettingsError
+	{
+		VRSettingsError_None = 0,
+		VRSettingsError_IPCFailed = 1,
+		VRSettingsError_WriteFailed = 2,
+		VRSettingsError_ReadFailed = 3,
+		VRSettingsError_JsonParseFailed = 4,
+		VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
+	};
+
+	// The maximum length of a settings key
+	static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+	class IVRSettings
+	{
+	public:
+		virtual const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) = 0;
+
+		virtual void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) = 0;
+
+		// Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+		// of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+		virtual bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) = 0;
+
+		virtual void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) = 0;
+		virtual void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+	};
+
+	//-----------------------------------------------------------------------------
+	static const char * const IVRSettings_Version = "IVRSettings_003";
+
+	class CVRSettingHelper
+	{
+		IVRSettings *m_pSettings;
+	public:
+		CVRSettingHelper( IVRSettings *pSettings )
+		{
+			m_pSettings = pSettings;
+		}
+
+		const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError )
+		{
+			return m_pSettings->GetSettingsErrorNameFromEnum( eError );
+		}
+
+		void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetBool( pchSection, pchSettingsKey, bValue, peError );
+		}
+
+		void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetInt32( pchSection, pchSettingsKey, nValue, peError );
+		}
+		void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetFloat( pchSection, pchSettingsKey, flValue, peError );
+		}
+		void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( pchSection, pchSettingsKey, pchValue, peError );
+		}
+		void SetString( const std::string & sSection, const std::string &  sSettingsKey, const std::string & sValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( sSection.c_str(), sSettingsKey.c_str(), sValue.c_str(), peError );
+		}
+
+		bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetBool( pchSection, pchSettingsKey, peError );
+		}
+		int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetInt32( pchSection, pchSettingsKey, peError );
+		}
+		float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetFloat( pchSection, pchSettingsKey, peError );
+		}
+		void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->GetString( pchSection, pchSettingsKey, pchValue, unValueLen, peError );
+		}
+		std::string GetString( const std::string & sSection, const std::string & sSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			char buf[4096];
+			vr::EVRSettingsError eError;
+			m_pSettings->GetString( sSection.c_str(), sSettingsKey.c_str(), buf, sizeof( buf ), &eError );
+			if ( peError )
+				*peError = eError;
+			if ( eError == vr::VRSettingsError_None )
+				return buf;
+			else
+				return "";
+		}
+
+		void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveSection( pchSection, peError );
+		}
+		void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveKeyInSection( pchSection, pchSettingsKey, peError );
+		}
+	};
+
+
+	//-----------------------------------------------------------------------------
+	// steamvr keys
+	static const char * const k_pch_SteamVR_Section = "steamvr";
+	static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+	static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+	static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+	static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+	static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+	static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+	static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+	static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
+	static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+	static const char * const k_pch_SteamVR_IPD_Float = "ipd";
+	static const char * const k_pch_SteamVR_Background_String = "background";
+	static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+	static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+	static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+	static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
+	static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+	static const char * const k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+	static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
+	static const char * const k_pch_SteamVR_DrawTrackingReferences_Bool = "drawTrackingReferences";
+	static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+	static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+	static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+	static const char * const k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+	static const char * const k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+	static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+	static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+	static const char * const k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+	static const char * const k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+	static const char * const k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+	static const char * const k_pch_SteamVR_FramesToThrottle_Int32 = "framesToThrottle";
+	static const char * const k_pch_SteamVR_AdditionalFramesToPredict_Int32 = "additionalFramesToPredict";
+	static const char * const k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+	static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+	static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+	static const char * const k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+	static const char * const k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+	static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+	static const char * const k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+	static const char * const k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph";
+	static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+	static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+	static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+	static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+	static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+	static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+	static const char * const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+	static const char * const k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride";
+	static const char * const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+	static const char * const k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
+	static const char * const k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
+	static const char * const k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
+	static const char * const k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
+	static const char * const k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
+	static const char * const k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
+	static const char * const k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
+	static const char * const k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
+	static const char * const k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
+	static const char * const k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
+	static const char * const k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
+	static const char * const k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
+	static const char * const k_pch_SteamVR_CustomIconStyle_String = "customIconStyle";
+	static const char * const k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle";
+	static const char * const k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
+	static const char * const k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
+	static const char * const k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+	static const char * const k_pch_SteamVR_BlockOculusSDKOnOpenVRLaunchOption_Bool = "blockOculusSDKOnOpenVRLaunchOption";
+	static const char * const k_pch_SteamVR_BlockOculusSDKOnAllLaunches_Bool = "blockOculusSDKOnAllLaunches";
+	static const char * const k_pch_SteamVR_HDCPLegacyCompatibility_Bool = "hdcp14legacyCompatibility";
+	static const char * const k_pch_SteamVR_UsePrism_Bool = "usePrism";
+
+	//-----------------------------------------------------------------------------
+	// direct mode keys
+	static const char * const k_pch_DirectMode_Section = "direct_mode";
+	static const char * const k_pch_DirectMode_Enable_Bool = "enable";
+	static const char * const k_pch_DirectMode_Count_Int32 = "count";
+	static const char * const k_pch_DirectMode_EdidVid_Int32 = "edidVid";
+	static const char * const k_pch_DirectMode_EdidPid_Int32 = "edidPid";
+
+	//-----------------------------------------------------------------------------
+	// lighthouse keys
+	static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
+	static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+	static const char * const k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
+	static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+	static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+	static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+	static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+	static const char * const k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations";
+	static const char * const k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2";
+	static const char * const k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations";
+	static const char * const k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback";
+
+	//-----------------------------------------------------------------------------
+	// null keys
+	static const char * const k_pch_Null_Section = "driver_null";
+	static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
+	static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
+	static const char * const k_pch_Null_WindowX_Int32 = "windowX";
+	static const char * const k_pch_Null_WindowY_Int32 = "windowY";
+	static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+	static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+	static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+	static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+	static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+	static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+	//-----------------------------------------------------------------------------
+	// Windows MR keys
+	static const char * const k_pch_WindowsMR_Section = "driver_holographic";
+
+	//-----------------------------------------------------------------------------
+	// user interface keys
+	static const char * const k_pch_UserInterface_Section = "userinterface";
+	static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+	static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+	static const char * const k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized";
+	static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+	static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+	//-----------------------------------------------------------------------------
+	// notification keys
+	static const char * const k_pch_Notifications_Section = "notifications";
+	static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+	//-----------------------------------------------------------------------------
+	// keyboard keys
+	static const char * const k_pch_Keyboard_Section = "keyboard";
+	static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+	static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
+	static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
+	static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+	static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+	static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
+	static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
+
+	//-----------------------------------------------------------------------------
+	// perf keys
+	static const char * const k_pch_Perf_Section = "perfcheck";
+	static const char * const k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD";
+	static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+	static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+	static const char * const k_pch_Perf_TestData_Float = "perfTestData";
+	static const char * const k_pch_Perf_GPUProfiling_Bool = "GPUProfiling";
+
+	//-----------------------------------------------------------------------------
+	// collision bounds keys
+	static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
+	static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+	static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+	static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+	static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+	static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+	static const char * const k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight";
+	static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+	static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+	static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+	static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+	static const char * const k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+
+	//-----------------------------------------------------------------------------
+	// camera keys
+	static const char * const k_pch_Camera_Section = "camera";
+	static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+	static const char * const k_pch_Camera_ShowOnController_Bool = "showOnController";
+	static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+	static const char * const k_pch_Camera_RoomView_Int32 = "roomView";
+	static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+	static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+	static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+	static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+	static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+	static const char * const k_pch_Camera_RoomViewStyle_Int32 = "roomViewStyle";
+
+	//-----------------------------------------------------------------------------
+	// audio keys
+	static const char * const k_pch_audio_Section = "audio";
+	static const char * const k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+	static const char * const k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+	static const char * const k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+	static const char * const k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+	static const char * const k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+	static const char * const k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+	static const char * const k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+	static const char * const k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+	static const char * const k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice";
+	static const char * const k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume";
+	static const char * const k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+	static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+	static const char * const k_pch_audio_DualSpeakerAndJackOutput_Bool = "dualSpeakerAndJackOutput";
+	static const char * const k_pch_audio_MuteMicMonitor_Bool = "muteMicMonitor";
+
+	//-----------------------------------------------------------------------------
+	// power management keys
+	static const char * const k_pch_Power_Section = "power";
+	static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+	static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+	static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+	static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+	static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+	static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+	//-----------------------------------------------------------------------------
+	// dashboard keys
+	static const char * const k_pch_Dashboard_Section = "dashboard";
+	static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+	static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+	static const char * const k_pch_Dashboard_Position = "position";
+	static const char * const k_pch_Dashboard_DesktopScale = "desktopScale";
+	static const char * const k_pch_Dashboard_DashboardScale = "dashboardScale";
+	static const char * const k_pch_Dashboard_UseStandaloneSystemLayer = "standaloneSystemLayer";
+
+	//-----------------------------------------------------------------------------
+	// model skin keys
+	static const char * const k_pch_modelskin_Section = "modelskins";
+
+	//-----------------------------------------------------------------------------
+	// driver keys - These could be checked in any driver_<name> section
+	static const char * const k_pch_Driver_Enable_Bool = "enable";
+	static const char * const k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode";
+	static const char * const k_pch_Driver_LoadPriority_Int32 = "loadPriority";
+
+	//-----------------------------------------------------------------------------
+	// web interface keys
+	static const char* const k_pch_WebInterface_Section = "WebInterface";
+
+	//-----------------------------------------------------------------------------
+	// vrwebhelper keys
+	static const char* const k_pch_VRWebHelper_Section = "VRWebHelper";
+	static const char* const k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled";
+	static const char* const k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort";
+
+	//-----------------------------------------------------------------------------
+	// tracking overrides - keys are device paths, values are the device paths their
+	//  tracking/pose information overrides
+	static const char* const k_pch_TrackingOverride_Section = "TrackingOverrides";
+
+	//-----------------------------------------------------------------------------
+	// per-app keys - the section name for these is the app key itself. Some of these are prefixed by the controller type
+	static const char* const k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL";
+	static const char* const k_pch_App_BindingLegacyAPISuffix_String = "_legacy";
+	static const char* const k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput";
+	static const char* const k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
+	static const char* const k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
+	static const char* const k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+	static const char* const k_pch_App_DominantHand_Int32 = "DominantHand";
+	static const char* const k_pch_App_BlockOculusSDK_Bool = "blockOculusSDK";
+
+	//-----------------------------------------------------------------------------
+	// configuration for trackers
+	static const char * const k_pch_Trackers_Section = "trackers";
+
+	//-----------------------------------------------------------------------------
+	// configuration for desktop UI windows
+	static const char * const k_pch_DesktopUI_Section = "DesktopUI";
+
+	//-----------------------------------------------------------------------------
+	// Last known keys for righting recovery
+	static const char * const k_pch_LastKnown_Section = "LastKnown";
+	static const char* const k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer";
+	static const char* const k_pch_LastKnown_HMDModel_String = "HMDModel";
+
+	//-----------------------------------------------------------------------------
+	// Dismissed warnings
+	static const char * const k_pch_DismissedWarnings_Section = "DismissedWarnings";
+
+	//-----------------------------------------------------------------------------
+	// Input Settings
+	static const char * const k_pch_Input_Section = "input";
+	static const char* const k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
+	static const char* const k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
+	static const char* const k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
+
+	//-----------------------------------------------------------------------------
+	// Log of GPU performance
+	static const char * const k_pch_GpuSpeed_Section = "GpuSpeed";
+
+} // namespace vr
+
+// ivrchaperone.h
+
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,									// Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,	// A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,			// There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,		// Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,								// The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,		// Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,			// Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,				// Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,		// Collision Bounds haven't been calibrated for the current tracking center
+};
+
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z.
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	virtual bool GetPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	virtual void ReloadInfo( void ) = 0;
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	virtual void SetSceneColor( HmdColor_t color ) = 0;
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	virtual void GetBoundsColor( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor ) = 0;
+
+	/** Determine whether the bounds are showing right now **/
+	virtual bool AreBoundsVisible() = 0;
+
+	/** Force the bounds to show, mostly for utilities **/
+	virtual void ForceBoundsVisible( bool bForce ) = 0;
+
+	/** Sets the zero pose for the given tracker coordinate system to the current position and yaw of the HMD. After
+	* ResetZeroPose all GetDeviceToAbsoluteTrackingPose calls as the origin will be relative to this new zero pose.
+	* The new zero coordinate system will not change the fact that the Y axis is up in the real world, so the next
+	* pose returned from GetDeviceToAbsoluteTrackingPose after a call to ResetZeroPose may not be exactly an
+	* identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved zero pose and should only be called as the result of a user action.
+	* Users are also able to set their zero pose via the OpenVR Dashboard.
+	**/
+	virtual void ResetZeroPose( ETrackingUniverseOrigin eTrackingUniverseOrigin ) = 0;
+};
+
+static const char * const IVRChaperone_Version = "IVRChaperone_004";
+
+#pragma pack( pop )
+
+}
+
+// ivrchaperonesetup.h
+
+namespace vr
+{
+
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,		// The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,		// The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the
+* live copy. Any changes made with this interface will stay in the working copy until
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+
+	/** Saves the current working copy to disk */
+	virtual bool CommitWorkingCopy( EChaperoneConfigFile configFile ) = 0;
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	virtual void RevertWorkingCopy() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	virtual bool GetWorkingPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetWorkingPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads
+	* into the buffer up to the max specified from the working copy. */
+	virtual bool GetWorkingCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads
+	* into the buffer up to the max specified. */
+	virtual bool GetLiveCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+	/** Returns the preferred seated position from the working copy. */
+	virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	/** Returns the standing origin from the working copy. */
+	virtual bool GetWorkingStandingZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose ) = 0;
+
+	/** Sets the Play Area in the working copy. */
+	virtual void SetWorkingPlayAreaSize( float sizeX, float sizeZ ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. Note: ceiling height is ignored. */
+	virtual void SetWorkingCollisionBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. */
+	virtual void SetWorkingPerimeter( VR_ARRAY_COUNT( unPointCount ) HmdVector2_t *pPointBuffer, uint32_t unPointCount ) = 0;
+
+	/** Sets the preferred seated position in the working copy. */
+	virtual void SetWorkingSeatedZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	/** Sets the preferred standing position in the working copy. */
+	virtual void SetWorkingStandingZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose ) = 0;
+
+	/** Tear everything down and reload it from the file on disk */
+	virtual void ReloadFromDisk( EChaperoneConfigFile configFile ) = 0;
+
+	/** Returns the preferred seated position. */
+	virtual bool GetLiveSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	virtual bool ExportLiveToBuffer( VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength ) = 0;
+	virtual bool ImportFromBufferToWorking( const char *pBuffer, uint32_t nImportFlags ) = 0;
+
+	/** Shows the chaperone data in the working set to preview in the compositor.*/
+	virtual void ShowWorkingSetPreview() = 0;
+
+	/** Hides the chaperone data in the working set to preview in the compositor (if it was visible).*/
+	virtual void HideWorkingSetPreview() = 0;
+
+	/** Fire an event that the tracking system can use to know room setup is about to begin. This lets the tracking
+	 * system make any last minute adjustments that should be incorporated into the new setup.  If the user is adjusting
+	 * live in HMD using a tweak tool, keep in mind that calling this might cause the user to see the room jump. */
+	virtual void RoomSetupStarting() = 0;
+};
+
+static const char * const IVRChaperoneSetup_Version = "IVRChaperoneSetup_006";
+
+
+}
+
+// ivrcompositor.h
+
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+	VRCompositorError_None						= 0,
+	VRCompositorError_RequestFailed				= 1,
+	VRCompositorError_IncompatibleVersion		= 100,
+	VRCompositorError_DoNotHaveFocus			= 101,
+	VRCompositorError_InvalidTexture			= 102,
+	VRCompositorError_IsNotSceneApplication		= 103,
+	VRCompositorError_TextureIsOnWrongDevice	= 104,
+	VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	VRCompositorError_SharedTexturesNotSupported = 106,
+	VRCompositorError_IndexOutOfRange			= 107,
+	VRCompositorError_AlreadySubmitted			= 108,
+	VRCompositorError_InvalidBounds				= 109,
+	VRCompositorError_AlreadySet				= 110,
+};
+
+/** Timing mode passed to SetExplicitTimingMode(); see that function for documentation */
+enum EVRCompositorTimingMode
+{
+	VRCompositorTimingMode_Implicit											= 0,
+	VRCompositorTimingMode_Explicit_RuntimePerformsPostPresentHandoff		= 1,
+	VRCompositorTimingMode_Explicit_ApplicationPerformsPostPresentHandoff	= 2,
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid; // Process id associated with these stats (may no longer be running).
+	uint32_t m_nNumFramePresents; // total number of times we called present (includes reprojected frames)
+	uint32_t m_nNumDroppedFrames; // total number of times an old frame was re-scanned out (without reprojection)
+	uint32_t m_nNumReprojectedFrames; // total number of times a frame was scanned out a second time (with reprojection)
+
+	/** Values recorded at startup before application has fully faded in the first time. */
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+
+	/** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+	* system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+
+	/** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+	* fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+	* Does not include values recorded during start up or loading. */
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+struct Compositor_StageRenderSettings
+{
+	/** Primary color is applied as a tint to (i.e. multiplied with) the model's texture */
+	HmdColor_t m_PrimaryColor;
+	HmdColor_t m_SecondaryColor;
+
+	/** Vignette radius is in meters and is used to fade to the specified secondary solid color over
+	* that 3D distance from the origin of the playspace. */
+	float m_flVignetteInnerRadius;
+	float m_flVignetteOuterRadius;
+
+	/** Fades to the secondary color based on view incidence.  This variable controls the linearity
+	* of the effect.  It is mutually exclusive with vignette.  Additionally, it treats the mesh as faceted. */
+	float m_flFresnelStrength;
+
+	/** Controls backface culling. */
+	bool m_bBackfaceCulling;
+
+	/** Converts the render model's texture to luma and applies to rgb equally.  This is useful to
+	* combat compression artifacts that can occur on desaturated source material. */
+	bool m_bGreyscale;
+
+	/** Renders mesh as a wireframe. */
+	bool m_bWireframe;
+};
+
+static inline Compositor_StageRenderSettings DefaultStageRenderSettings()
+{
+	Compositor_StageRenderSettings settings;
+	settings.m_PrimaryColor.r = 1.0f;
+	settings.m_PrimaryColor.g = 1.0f;
+	settings.m_PrimaryColor.b = 1.0f;
+	settings.m_PrimaryColor.a = 1.0f;
+	settings.m_SecondaryColor.r = 1.0f;
+	settings.m_SecondaryColor.g = 1.0f;
+	settings.m_SecondaryColor.b = 1.0f;
+	settings.m_SecondaryColor.a = 1.0f;
+	settings.m_flVignetteInnerRadius = 0.0f;
+	settings.m_flVignetteOuterRadius = 0.0f;
+	settings.m_flFresnelStrength = 0.0f;
+	settings.m_bBackfaceCulling = false;
+	settings.m_bGreyscale = false;
+	settings.m_bWireframe = false;
+	return settings;
+}
+
+#pragma pack( pop )
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	virtual void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) = 0;
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	virtual EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	virtual EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) = 0;
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	virtual EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) = 0;
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the
+	* compositor to show the grid until Submit is called again. */
+	virtual void ClearLastSubmittedFrame() = 0;
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	virtual void PostPresentHandoff() = 0;
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings( VR_ARRAY_COUNT( nFrames ) Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0;
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	virtual float GetFrameTimeRemaining() = 0;
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	virtual void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) = 0;
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) = 0;
+
+	/** Get current fade color value. */
+	virtual HmdColor_t GetCurrentFadeColor( bool bBackground = false ) = 0;
+
+	/** Fading the Grid in or out in fSeconds */
+	virtual void FadeGrid( float fSeconds, bool bFadeGridIn ) = 0;
+
+	/** Get current alpha value of grid. */
+	virtual float GetCurrentGridAlpha() = 0;
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	virtual EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) = 0;
+
+	/** Resets compositor skybox back to defaults. */
+	virtual void ClearSkyboxOverride() = 0;
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	virtual void CompositorBringToFront() = 0;
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	virtual void CompositorGoToBack() = 0;
+
+	/** DEPRECATED: Tells the compositor process to clean up and exit. You do not need to call this function at shutdown.
+	* Under normal circumstances the compositor will manage its own life cycle based on what applications are running. */
+	virtual void CompositorQuit() = 0;
+
+	/** Return whether the compositor is fullscreen */
+	virtual bool IsFullscreen() = 0;
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	virtual uint32_t GetLastFrameRenderer() = 0;
+
+	/** Returns true if the current process has the scene focus */
+	virtual bool CanRenderScene() = 0;
+
+	/** DEPRECATED: Opens the headset view (as either a window or docked widget depending on user's preferences) that displays what the user
+	* sees in the headset. */
+	virtual void ShowMirrorWindow() = 0;
+
+	/** DEPRECATED: Closes the headset view, either as a window or docked widget. */
+	virtual void HideMirrorWindow() = 0;
+
+	/** DEPRECATED: Returns true if the headset view (either as a window or docked widget) is shown. */
+	virtual bool IsMirrorWindowVisible() = 0;
+
+	/** Writes back buffer and stereo left/right pair from the application to a 'screenshots' folder in the SteamVR runtime root. */
+	virtual void CompositorDumpImages() = 0;
+
+	/** Let an app know it should be rendering with low resources. */
+	virtual bool ShouldAppRenderWithLowResources() = 0;
+
+	/** Override interleaved reprojection logic to force on. */
+	virtual void ForceInterleavedReprojectionOn( bool bOverride ) = 0;
+
+	/** Force reconnecting to the compositor process. */
+	virtual void ForceReconnectProcess() = 0;
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	virtual void SuspendRendering( bool bSuspend ) = 0;
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	virtual vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) = 0;
+	virtual void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) = 0;
+
+	/** Access to mirror textures from OpenGL. */
+	virtual vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) = 0;
+	virtual bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+	virtual void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+	virtual void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	virtual uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	virtual uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11,
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application should set the timing mode to Explicit_ApplicationPerformsPostPresentHandoff and *MUST* call PostPresentHandoff
+	* itself. If these conditions are met, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	virtual void SetExplicitTimingMode( EVRCompositorTimingMode eTimingMode ) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+
+	/** Indicates whether or not motion smoothing is enabled by the user settings.
+	* If you want to know if motion smoothing actually triggered due to a late frame, check Compositor_FrameTiming
+	* m_nReprojectionFlags & VRCompositor_ReprojectionMotion instead. */
+	virtual bool IsMotionSmoothingEnabled() = 0;
+
+	/** Indicates whether or not motion smoothing is supported by the current hardware. */
+	virtual bool IsMotionSmoothingSupported() = 0;
+
+	/** Indicates whether or not the current scene focus app is currently loading.  This is inferred from its use of FadeGrid to
+	* explicitly fade to the compositor to cover up the fact that it cannot render at a sustained full framerate during this time. */
+	virtual bool IsCurrentSceneFocusAppLoading() = 0;
+
+	/** Override the stage model used in the compositor to replace the grid.  RenderModelPath is a full path the an OBJ file to load.
+	* This file will be loaded asynchronously from disk and uploaded to the gpu by the runtime.  Once ready for rendering, the
+	* VREvent StageOverrideReady will be sent.  Use FadeToGrid to reveal.  Call ClearStageOverride to free the associated resources when finished. */
+	virtual EVRCompositorError SetStageOverride_Async( const char *pchRenderModelPath, const HmdMatrix34_t *pTransform = 0,
+		const Compositor_StageRenderSettings *pRenderSettings = 0, uint32_t nSizeOfRenderSettings = 0 ) = 0;
+
+	/** Resets the stage to its default user specified setting. */
+	virtual void ClearStageOverride() = 0;
+
+	/** Returns true if pBenchmarkResults is filled it.  Sets pBenchmarkResults with the result of the compositor benchmark.
+	* nSizeOfBenchmarkResults should be set to sizeof(Compositor_BenchmarkResults) */
+	virtual bool GetCompositorBenchmarkResults( Compositor_BenchmarkResults *pBenchmarkResults, uint32_t nSizeOfBenchmarkResults ) = 0;
+
+	/** Returns the frame id associated with the poses last returned by WaitGetPoses.  Deltas between IDs correspond to number of headset vsync intervals. */
+	virtual EVRCompositorError GetLastPosePredictionIDs( uint32_t *pRenderPosePredictionID, uint32_t *pGamePosePredictionID ) = 0;
+
+	/** Get the most up-to-date predicted (or recorded - up to 100ms old) set of poses for a given frame id. */
+	virtual EVRCompositorError GetPosesForFrame( uint32_t unPosePredictionID, VR_ARRAY_COUNT( unPoseArrayCount ) TrackedDevicePose_t* pPoseArray, uint32_t unPoseArrayCount ) = 0;
+};
+
+static const char * const IVRCompositor_Version = "IVRCompositor_027";
+
+} // namespace vr
+
+
+
+// ivrheadsetview.h
+
+namespace vr
+{
+	enum HeadsetViewMode_t
+	{
+		HeadsetViewMode_Left = 0,
+		HeadsetViewMode_Right,
+		HeadsetViewMode_Both
+	};
+
+	class IVRHeadsetView
+	{
+	public:
+		/** Sets the resolution in pixels to render the headset view. These values are clamped to k_unHeadsetViewMaxWidth
+		* and k_unHeadsetViewMaxHeight respectively. For cropped views, the rendered output will be fit to aspect ratio
+		* defined by the the specified dimensions. For uncropped views, the caller should use GetHeadsetViewAspectRation
+		* to adjust the requested render size to avoid squashing or stretching, and then apply letterboxing to compensate
+		* when displaying the results. */
+		virtual void SetHeadsetViewSize( uint32_t nWidth, uint32_t nHeight ) = 0;
+
+		/** Gets the current resolution used to render the headset view. */
+		virtual void GetHeadsetViewSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** Set the mode used to render the headset view. */
+		virtual void SetHeadsetViewMode( HeadsetViewMode_t eHeadsetViewMode ) = 0;
+
+		/** Get the current mode used to render the headset view. */
+		virtual HeadsetViewMode_t GetHeadsetViewMode() = 0;
+
+		/** Set whether or not the headset view should be rendered cropped to hide the hidden area mesh or not. */
+		virtual void SetHeadsetViewCropped( bool bCropped ) = 0;
+
+		/** Get the current cropping status of the headset view. */
+		virtual bool GetHeadsetViewCropped() = 0;
+
+		/** Get the aspect ratio (width:height) of the uncropped headset view (accounting for the current set mode). */
+		virtual float GetHeadsetViewAspectRatio() = 0;
+
+		/** Set the range [0..1] that the headset view blends across the stereo overlapped area in cropped both mode. */
+		virtual void SetHeadsetViewBlendRange( float flStartPct, float flEndPct ) = 0;
+
+		/** Get the current range [0..1] that the headset view blends across the stereo overlapped area in cropped both mode. */
+		virtual void GetHeadsetViewBlendRange( float *pStartPct, float *pEndPct ) = 0;
+	};
+
+	static const uint32_t k_unHeadsetViewMaxWidth = 3840;
+	static const uint32_t k_unHeadsetViewMaxHeight = 2160;
+	static const char * const k_pchHeadsetViewOverlayKey = "system.HeadsetView";
+
+	static const char * const IVRHeadsetView_Version = "IVRHeadsetView_001";
+
+	/** Returns the current IVRHeadsetView pointer or NULL the interface could not be found. */
+	VR_INTERFACE vr::IVRHeadsetView *VR_CALLTYPE VRHeadsetView();
+
+} // namespace vr
+
+
+// ivrnotifications.h
+
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+	NotificationBitmap_t()
+		: m_pImageData( nullptr )
+		, m_nWidth( 0 )
+		, m_nHeight( 0 )
+		, m_nBytesPerPixel( 0 )
+	{
+	}
+
+	void *m_pImageData;
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+};
+
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+	/** Transient notifications are automatically hidden after a period of time set by the user.
+	* They are used for things like information and chat messages that do not require user interaction. */
+	EVRNotificationType_Transient = 0,
+
+	/** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+	* They are used for things like phone calls and alarms that require user interaction. */
+	EVRNotificationType_Persistent = 1,
+
+	/** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+	 * If there is already a system notification in the queue with that ID it is not accepted into the queue
+	 * to prevent spamming with system notification */
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+	/** Creates a notification with minimal external styling. */
+	EVRNotificationStyle_None = 0,
+
+	/** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+	EVRNotificationStyle_Application = 100,
+
+	/** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+	EVRNotificationStyle_Contact_Disabled = 200,
+
+	/** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+	EVRNotificationStyle_Contact_Enabled = 201,
+
+	/** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+	EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+
+
+#pragma pack( pop )
+
+/** Allows notification sources to interact with the VR system
+	This current interface is not yet implemented. Do not use yet. */
+class IVRNotifications
+{
+public:
+	/** Create a notification and enqueue it to be shown to the user.
+	* An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+	* To create a two-line notification, use a line break ('\n') to split the text into two lines.
+	* The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+	virtual EVRNotificationError CreateNotification( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId ) = 0;
+
+	/** Destroy a notification, hiding it first if it currently shown to the user. */
+	virtual EVRNotificationError RemoveNotification( VRNotificationId notificationId ) = 0;
+
+};
+
+static const char * const IVRNotifications_Version = "IVRNotifications_002";
+
+} // namespace vr
+
+
+
+// ivroverlay.h
+
+namespace vr
+{
+
+	/** The maximum length of an overlay key in bytes, counting the terminating null character. */
+	static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+	/** The maximum length of an overlay name in bytes, counting the terminating null character. */
+	static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+	/** The maximum number of overlays that can exist in the system at one time. */
+	static const uint32_t k_unMaxOverlayCount = 128;
+
+	/** The maximum number of overlay intersection mask primitives per overlay */
+	static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+	/** Types of input supported by VR Overlays */
+	enum VROverlayInputMethod
+	{
+		VROverlayInputMethod_None		= 0, // No input events will be generated automatically for this overlay
+		VROverlayInputMethod_Mouse		= 1, // Tracked controllers will get mouse events automatically
+		// VROverlayInputMethod_DualAnalog = 2, // No longer supported
+	};
+
+	/** Allows the caller to figure out which overlay transform getter to call. */
+	enum VROverlayTransformType
+	{
+		VROverlayTransform_Invalid					= -1,
+		VROverlayTransform_Absolute					= 0,
+		VROverlayTransform_TrackedDeviceRelative	= 1,
+		VROverlayTransform_SystemOverlay			= 2,
+		VROverlayTransform_TrackedComponent 		= 3,
+		VROverlayTransform_Cursor					= 4,
+		VROverlayTransform_DashboardTab				= 5,
+		VROverlayTransform_DashboardThumb			= 6,
+		VROverlayTransform_Mountable				= 7,
+		VROverlayTransform_Projection				= 8,
+	};
+
+	/** Overlay control settings */
+	enum VROverlayFlags
+	{
+		// Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+		VROverlayFlags_NoDashboardTab = 1 << 3,
+
+		// When this is set the overlay will receive VREvent_ScrollDiscrete events like a mouse wheel.
+		// Requires mouse input mode.
+		VROverlayFlags_SendVRDiscreteScrollEvents = 1 << 6,
+
+		// Indicates that the overlay would like to receive
+		VROverlayFlags_SendVRTouchpadEvents = 1 << 7,
+
+		// If set this will render a vertical scroll wheel on the primary controller,
+		//  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+		VROverlayFlags_ShowTouchPadScrollWheel = 1 << 8,
+
+		// If this is set ownership and render access to the overlay are transferred
+		// to the new scene process on a call to IVRApplications::LaunchInternalProcess
+		VROverlayFlags_TransferOwnershipToInternalProcess = 1 << 9,
+
+		// If set, renders 50% of the texture in each eye, side by side
+		VROverlayFlags_SideBySide_Parallel = 1 << 10, // Texture is left/right
+		VROverlayFlags_SideBySide_Crossed = 1 << 11, // Texture is crossed and right/left
+
+		VROverlayFlags_Panorama = 1 << 12, // Texture is a panorama
+		VROverlayFlags_StereoPanorama = 1 << 13, // Texture is a stereo panorama
+
+		// If this is set on an overlay owned by the scene application that overlay
+		// will be sorted with the "Other" overlays on top of all other scene overlays
+		VROverlayFlags_SortWithNonSceneOverlays = 1 << 14,
+
+		// If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+		VROverlayFlags_VisibleInDashboard = 1 << 15,
+
+		// If this is set and the overlay's input method is not none, the system-wide laser mouse
+		// mode will be activated whenever this overlay is visible.
+		VROverlayFlags_MakeOverlaysInteractiveIfVisible = 1 << 16,
+
+		// If this is set the overlay will receive smooth VREvent_ScrollSmooth that emulate trackpad scrolling.
+		// Requires mouse input mode.
+		VROverlayFlags_SendVRSmoothScrollEvents = 1 << 17,
+
+		// If this is set, the overlay texture will be protected content, preventing unauthorized reads.
+		VROverlayFlags_ProtectedContent = 1 << 18,
+
+		// If this is set, the laser mouse splat will not be drawn over this overlay. The overlay will
+		// be responsible for drawing its own "cursor".
+		VROverlayFlags_HideLaserIntersection = 1 << 19,
+
+		// If this is set, clicking away from the overlay will cause it to receive a VREvent_Modal_Cancel event.
+		// This is ignored for dashboard overlays.
+		VROverlayFlags_WantsModalBehavior = 1 << 20,
+
+		// If this is set, alpha composition assumes the texture is pre-multiplied
+		VROverlayFlags_IsPremultiplied = 1 << 21,
+	};
+
+	enum VRMessageOverlayResponse
+	{
+		VRMessageOverlayResponse_ButtonPress_0 = 0,
+		VRMessageOverlayResponse_ButtonPress_1 = 1,
+		VRMessageOverlayResponse_ButtonPress_2 = 2,
+		VRMessageOverlayResponse_ButtonPress_3 = 3,
+		VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+		VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay= 5,
+		VRMessageOverlayResponse_ApplicationQuit = 6
+	};
+
+	struct VROverlayIntersectionParams_t
+	{
+		HmdVector3_t vSource;
+		HmdVector3_t vDirection;
+		ETrackingUniverseOrigin eOrigin;
+	};
+
+	struct VROverlayIntersectionResults_t
+	{
+		HmdVector3_t vPoint;
+		HmdVector3_t vNormal;
+		HmdVector2_t vUVs;
+		float fDistance;
+	};
+
+	// Input modes for the Big Picture gamepad text entry
+	enum EGamepadTextInputMode
+	{
+		k_EGamepadTextInputModeNormal = 0,
+		k_EGamepadTextInputModePassword = 1,
+		k_EGamepadTextInputModeSubmit = 2,
+	};
+
+	// Controls number of allowed lines for the Big Picture gamepad text entry
+	enum EGamepadTextInputLineMode
+	{
+		k_EGamepadTextInputLineModeSingleLine = 0,
+		k_EGamepadTextInputLineModeMultipleLines = 1
+	};
+
+	enum EVROverlayIntersectionMaskPrimitiveType
+	{
+		OverlayIntersectionPrimitiveType_Rectangle,
+		OverlayIntersectionPrimitiveType_Circle,
+	};
+
+	struct IntersectionMaskRectangle_t
+	{
+		float m_flTopLeftX;
+		float m_flTopLeftY;
+		float m_flWidth;
+		float m_flHeight;
+	};
+
+	struct IntersectionMaskCircle_t
+	{
+		float m_flCenterX;
+		float m_flCenterY;
+		float m_flRadius;
+	};
+
+	/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+	typedef union
+	{
+		IntersectionMaskRectangle_t m_Rectangle;
+		IntersectionMaskCircle_t m_Circle;
+	} VROverlayIntersectionMaskPrimitive_Data_t;
+
+	struct VROverlayIntersectionMaskPrimitive_t
+	{
+		EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+		VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+	};
+
+	enum EKeyboardFlags
+	{
+		KeyboardFlag_Minimal		= 1 << 0, // makes the keyboard send key events immediately instead of accumulating a buffer
+		KeyboardFlag_Modal			= 2 << 0, // makes the keyboard take all focus and dismiss when clicking off the panel
+	};
+
+	/** Defines the project used in an overlay that is using SetOverlayTransformProjection */
+	struct VROverlayProjection_t
+	{
+		/** Tangent of the sides of the frustum */
+		float fLeft;
+		float fRight;
+		float fTop;
+		float fBottom;
+	};
+
+	class IVROverlay
+	{
+	public:
+
+		// ---------------------------------------------
+		// Overlay management methods
+		// ---------------------------------------------
+
+		/** Finds an existing overlay with the specified key. */
+		virtual EVROverlayError FindOverlay( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle ) = 0;
+
+		/** Creates a new named overlay. All overlays start hidden and with default settings. */
+		virtual EVROverlayError CreateOverlay( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle ) = 0;
+
+		/** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+		* automatically destroyed. */
+		virtual EVROverlayError DestroyOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+		virtual uint32_t GetOverlayKey( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
+
+		/** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+		* the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+		virtual uint32_t GetOverlayName( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
+
+		/** set the name to use for this overlay */
+		virtual EVROverlayError SetOverlayName( VROverlayHandle_t ulOverlayHandle, const char *pchName ) = 0;
+
+		/** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height
+		* will be set and VROverlayError_ArrayTooSmall is returned. */
+		virtual EVROverlayError GetOverlayImageData( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight ) = 0;
+
+		/** returns a string that corresponds with the specified overlay error. The string will be the name
+		* of the error enum value for all valid error codes */
+		virtual const char *GetOverlayErrorNameFromEnum( EVROverlayError error ) = 0;
+
+		// ---------------------------------------------
+		// Overlay rendering methods
+		// ---------------------------------------------
+
+		/** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+		*	by default this is the pid of the process that made the overlay */
+		virtual EVROverlayError SetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle, uint32_t unPID ) = 0;
+
+		/** Gets the pid that is allowed to render to this overlay */
+		virtual uint32_t GetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Specify flag setting for a given overlay */
+		virtual EVROverlayError SetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled ) = 0;
+
+		/** Sets flag setting for a given overlay */
+		virtual EVROverlayError GetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled ) = 0;
+
+		/** Gets all the flags for a given overlay */
+		virtual EVROverlayError GetOverlayFlags( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags ) = 0;
+
+		/** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+		virtual EVROverlayError SetOverlayColor( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue ) = 0;
+
+		/** Gets the color tint of the overlay quad. */
+		virtual EVROverlayError GetOverlayColor( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue ) = 0;
+
+		/** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+		virtual EVROverlayError SetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float fAlpha ) = 0;
+
+		/** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+		virtual EVROverlayError GetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float *pfAlpha ) = 0;
+
+		/** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+		* are twice as wide as they are tall. Defaults to 1.0. */
+		virtual EVROverlayError SetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float fTexelAspect ) = 0;
+
+		/** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+		virtual EVROverlayError GetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect ) = 0;
+
+		/** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+		*      Overlays owned by the scene application
+		*      Overlays owned by some other application
+		*
+		*	Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same
+		*	sort order are rendered back to front base on distance from the HMD.
+		*
+		*	Sort order defaults to 0. */
+		virtual EVROverlayError SetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder ) = 0;
+
+		/** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+		virtual EVROverlayError GetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder ) = 0;
+
+		/** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+		virtual EVROverlayError SetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters ) = 0;
+
+		/** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+		virtual EVROverlayError GetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters ) = 0;
+
+		/** Use to draw overlay as a curved surface. Curvature is a percentage from (0..1] where 1 is a fully closed cylinder.
+		* For a specific radius, curvature can be computed as: overlay.width / (2 PI r). */
+		virtual EVROverlayError SetOverlayCurvature( VROverlayHandle_t ulOverlayHandle, float fCurvature ) = 0;
+
+		/** Returns the curvature of the overlay as a percentage from (0..1] where 1 is a fully closed cylinder. */
+		virtual EVROverlayError GetOverlayCurvature( VROverlayHandle_t ulOverlayHandle, float *pfCurvature ) = 0;
+
+		/** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+		* If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+		virtual EVROverlayError SetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace ) = 0;
+
+		/** Gets the overlay's current colorspace setting. */
+		virtual EVROverlayError GetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace ) = 0;
+
+		/** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+		virtual EVROverlayError SetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds ) = 0;
+
+		/** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+		virtual EVROverlayError GetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds ) = 0;
+
+		/** Returns the transform type of this overlay. */
+		virtual EVROverlayError GetOverlayTransformType( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType ) = 0;
+
+		/** Sets the transform to absolute tracking origin. */
+		virtual EVROverlayError SetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
+
+		/** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+		virtual EVROverlayError GetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
+
+		/** Sets the transform to relative to the transform of the specified tracked device. */
+		virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
+
+		/** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+		virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
+
+		/** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+		* drawing the device. Overlays with this transform type cannot receive mouse events. */
+		virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName ) = 0;
+
+		/** Gets the transform information when the overlay is rendering on a component. */
+		virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, VR_OUT_STRING() char *pchComponentName, uint32_t unComponentNameSize ) = 0;
+
+		/** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+		virtual vr::EVROverlayError GetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
+
+		/** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+		virtual vr::EVROverlayError SetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
+
+		/** Sets the hotspot for the specified overlay when that overlay is used as a cursor. These are in texture space with 0,0 in the upper left corner of
+		* the texture and 1,1 in the lower right corner of the texture. */
+		virtual EVROverlayError SetOverlayTransformCursor( VROverlayHandle_t ulCursorOverlayHandle, const HmdVector2_t *pvHotspot ) = 0;
+
+		/** Gets cursor hotspot/transform for the specified overlay */
+		virtual vr::EVROverlayError GetOverlayTransformCursor( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvHotspot ) = 0;
+
+		/** Sets the overlay as a projection overlay */
+		virtual vr::EVROverlayError SetOverlayTransformProjection( VROverlayHandle_t ulOverlayHandle,
+			ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t* pmatTrackingOriginToOverlayTransform,
+			const VROverlayProjection_t *pProjection, vr::EVREye eEye ) = 0;
+
+		/** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+		virtual EVROverlayError ShowOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+		virtual EVROverlayError HideOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Returns true if the overlay is visible. */
+		virtual bool IsOverlayVisible( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+		virtual EVROverlayError GetTransformForOverlayCoordinates( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform ) = 0;
+
+		// ---------------------------------------------
+		// Overlay input methods
+		// ---------------------------------------------
+
+		/** Returns true and fills the event with the next event on the overlay's event queue, if there is one.
+		* If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+		virtual bool PollNextOverlayEvent( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+		/** Returns the current input settings for the specified overlay. */
+		virtual EVROverlayError GetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod ) = 0;
+
+		/** Sets the input settings for the specified overlay. */
+		virtual EVROverlayError SetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod ) = 0;
+
+		/** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels. */
+		virtual EVROverlayError GetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale ) = 0;
+
+		/** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+		* typically the size of the underlying UI in pixels (not in world space). */
+		virtual EVROverlayError SetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale ) = 0;
+
+		/** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+		* specified settings. Returns false if there is no intersection. */
+		virtual bool ComputeOverlayIntersection( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults ) = 0;
+
+		/** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over"
+		* by the virtual mouse pointer */
+		virtual bool IsHoverTargetOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Sets a list of primitives to be used for controller ray intersection
+		* typically the size of the underlying UI in pixels (not in world space). */
+		virtual EVROverlayError SetOverlayIntersectionMask( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof( VROverlayIntersectionMaskPrimitive_t ) ) = 0;
+
+		/** Triggers a haptic event on the laser mouse controller for the specified overlay */
+		virtual EVROverlayError TriggerLaserMouseHapticVibration( VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude ) = 0;
+
+		/** Sets the cursor to use for the specified overlay. This will be drawn instead of the generic blob when the laser mouse is pointed at the specified overlay */
+		virtual EVROverlayError SetOverlayCursor( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle ) = 0;
+
+		/** Sets the override cursor position to use for this overlay in overlay mouse coordinates. This position will be used to draw the cursor
+		* instead of whatever the laser mouse cursor position is. */
+		virtual EVROverlayError SetOverlayCursorPositionOverride( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvCursor ) = 0;
+
+		/** Clears the override cursor position for this overlay */
+		virtual EVROverlayError ClearOverlayCursorPositionOverride( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		// ---------------------------------------------
+		// Overlay texture methods
+		// ---------------------------------------------
+
+		/** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+		*
+		* OpenGL dirty state:
+		*	glBindTexture
+		*/
+		virtual EVROverlayError SetOverlayTexture( VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture ) = 0;
+
+		/** Use this to tell the overlay system to release the texture set for this overlay. */
+		virtual EVROverlayError ClearOverlayTexture( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data
+		* that can be sent. This function can only be called by the overlay's renderer process. */
+		virtual EVROverlayError SetOverlayRaw( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel ) = 0;
+
+		/** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+		* This function can only be called by the overlay's renderer process */
+		virtual EVROverlayError SetOverlayFromFile( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath ) = 0;
+
+		/** Get the native texture handle/device for an overlay you have created.
+		* On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+		*
+		* The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+		*
+		* You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+		*
+		* pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+		* pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+		*/
+		virtual EVROverlayError GetOverlayTexture( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds ) = 0;
+
+		/** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+		* so only do it once you stop rendering this texture.
+		*/
+		virtual EVROverlayError ReleaseNativeOverlayHandle( VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle ) = 0;
+
+		/** Get the size of the overlay texture */
+		virtual EVROverlayError GetOverlayTextureSize( VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight ) = 0;
+
+		// ----------------------------------------------
+		// Dashboard Overlay Methods
+		// ----------------------------------------------
+
+		/** Creates a dashboard overlay and returns its handle */
+		virtual EVROverlayError CreateDashboardOverlay( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle ) = 0;
+
+		/** Returns true if the dashboard is visible */
+		virtual bool IsDashboardVisible() = 0;
+
+		/** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+		virtual bool IsActiveDashboardOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+		/** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+		virtual EVROverlayError SetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId ) = 0;
+
+		/** Gets the process ID that this dashboard overlay requires to have scene focus */
+		virtual EVROverlayError GetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId ) = 0;
+
+		/** Shows the dashboard. */
+		virtual void ShowDashboard( const char *pchOverlayToShow ) = 0;
+
+		/** Returns the tracked device that has the laser pointer in the dashboard */
+		virtual vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() = 0;
+
+		// ---------------------------------------------
+		// Keyboard methods
+		// ---------------------------------------------
+
+		/** Show the virtual keyboard to accept input. In most cases, you should pass KeyboardFlag_Modal to enable modal overlay
+		* behavior on the keyboard itself. See EKeyboardFlags for more. */
+		virtual EVROverlayError ShowKeyboard( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags,
+			const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, uint64_t uUserValue ) = 0;
+
+		/** Show the virtual keyboard to accept input for an overlay. In most cases, you should pass KeyboardFlag_Modal to enable modal
+		* overlay behavior on the keyboard itself. See EKeyboardFlags for more. */
+		virtual EVROverlayError ShowKeyboardForOverlay( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode,
+			EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char *pchDescription, uint32_t unCharMax,
+			const char *pchExistingText, uint64_t uUserValue ) = 0;
+
+		/** Get the text that was entered into the text input **/
+		virtual uint32_t GetKeyboardText( VR_OUT_STRING() char *pchText, uint32_t cchText ) = 0;
+
+		/** Hide the virtual keyboard **/
+		virtual void HideKeyboard() = 0;
+
+		/** Set the position of the keyboard in world space **/
+		virtual void SetKeyboardTransformAbsolute( ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform ) = 0;
+
+		/** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+		virtual void SetKeyboardPositionForOverlay( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect ) = 0;
+
+		// ---------------------------------------------
+		// Message box methods
+		// ---------------------------------------------
+
+		/** Show the message overlay. This will block and return you a result. **/
+		virtual VRMessageOverlayResponse ShowMessageOverlay( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text = nullptr, const char* pchButton2Text = nullptr, const char* pchButton3Text = nullptr ) = 0;
+
+		/** If the calling process owns the overlay and it's open, this will close it. **/
+		virtual void CloseMessageOverlay() = 0;
+	};
+
+	static const char * const IVROverlay_Version = "IVROverlay_025";
+
+} // namespace vr
+
+// ivroverlayview.h
+
+namespace vr
+{
+	struct VROverlayView_t
+	{
+		VROverlayHandle_t overlayHandle;
+		Texture_t texture;
+		VRTextureBounds_t textureBounds;
+	};
+
+	enum EDeviceType
+	{
+		DeviceType_Invalid           = -1, // Invalid handle
+		DeviceType_DirectX11         = 0, // Handle is an ID3D11Device
+		DeviceType_Vulkan            = 1, // Handle is a pointer to a VRVulkanDevice_t structure
+	};
+
+	struct VRVulkanDevice_t
+	{
+		VkInstance_T *m_pInstance;
+		VkDevice_T *m_pDevice;
+		VkPhysicalDevice_T *m_pPhysicalDevice;
+		VkQueue_T *m_pQueue;
+		uint32_t m_uQueueFamilyIndex;
+	};
+
+	struct VRNativeDevice_t
+	{
+		void *handle; // See EDeviceType definition above
+		EDeviceType eType;
+	};
+
+	class IVROverlayView
+	{
+	public:
+		/** Acquire an OverlayView_t from an overlay handle
+		*
+		* The overlay view can be used to sample the contents directly by a native API. The
+		* contents of the OverlayView_t will remain unchanged through the lifetime of the
+		* OverlayView_t.
+		*
+		* The caller acquires read privileges over the OverlayView_t, but should not
+		* write to it.
+		*
+		* AcquireOverlayView() may be called on the same ulOverlayHandle multiple times to
+		* refresh the image contents. In this case the caller is strongly encouraged to re-use
+		* the same pOverlayView for all re-acquisition calls.
+		*
+		* If the producer has not yet queued an image, AcquireOverlayView will return success,
+		* and the Texture_t will have the expected ETextureType. However, the Texture_t->handle
+		* will be nullptr. Once the producer generates the first overlay frame, Texture_t->handle
+		* will become a valid handle.
+		*/
+		virtual EVROverlayError AcquireOverlayView(VROverlayHandle_t ulOverlayHandle, VRNativeDevice_t *pNativeDevice, VROverlayView_t *pOverlayView, uint32_t unOverlayViewSize ) = 0;
+
+		/** Release an acquired OverlayView_t
+		*
+		* Denotes that pOverlayView will no longer require access to the resources it acquired in
+		* all previous calls to AcquireOverlayView().
+		*
+		* All OverlayView_t*'s provided to AcquireOverlayView() as pOverlayViews must be
+		* passed into ReleaseOverlayView() in order for the underlying GPU resources to be freed.
+		*/
+		virtual EVROverlayError ReleaseOverlayView(VROverlayView_t *pOverlayView) = 0;
+
+		/** Posts an overlay event */
+		virtual void PostOverlayEvent(VROverlayHandle_t ulOverlayHandle, const VREvent_t *pvrEvent) = 0;
+
+		/** Determines whether this process is permitted to view an overlay's content. */
+		virtual bool IsViewingPermitted( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+	};
+
+	static const char * const IVROverlayView_Version = "IVROverlayView_003";
+
+}
+
+// ivrrendermodels.h
+
+namespace vr
+{
+
+static const char * const k_pch_Controller_Component_GDC2015 = "gdc2015";   // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char * const k_pch_Controller_Component_Base = "base";         // For controllers with an unambiguous 'base'.
+static const char * const k_pch_Controller_Component_Tip = "tip";           // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char * const k_pch_Controller_Component_HandGrip = "handgrip"; // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char * const k_pch_Controller_Component_Status = "status";		// 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+	VRRenderModelError_None = 0,
+	VRRenderModelError_Loading = 100,
+	VRRenderModelError_NotSupported = 200,
+	VRRenderModelError_InvalidArg = 300,
+	VRRenderModelError_InvalidModel = 301,
+	VRRenderModelError_NoShapes = 302,
+	VRRenderModelError_MultipleShapes = 303,
+	VRRenderModelError_TooManyVertices = 304,
+	VRRenderModelError_MultipleTextures = 305,
+	VRRenderModelError_BufferTooSmall = 306,
+	VRRenderModelError_NotEnoughNormals = 307,
+	VRRenderModelError_NotEnoughTexCoords = 308,
+
+	VRRenderModelError_InvalidTexture = 400,
+};
+
+enum EVRRenderModelTextureFormat
+{
+	VRRenderModelTextureFormat_RGBA8_SRGB = 0, // RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+	VRRenderModelTextureFormat_BC2,
+	VRRenderModelTextureFormat_BC4,
+	VRRenderModelTextureFormat_BC7,
+	VRRenderModelTextureFormat_BC7_SRGB
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+	HmdVector3_t vPosition;		// position in meters in device space
+	HmdVector3_t vNormal;
+	float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth, unHeight; // width and height of the texture map in pixels
+	const uint8_t *rubTextureMapData;	// Map texture data.
+	EVRRenderModelTextureFormat format; // Refer to EVRRenderModelTextureFormat
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( pop )
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__)
+// This structure was originally defined mis-packed on Linux, preserved for
+// compatibility.
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_t
+{
+	const RenderModel_Vertex_t *rVertexData;	// Vertex data for the mesh
+	uint32_t unVertexCount;						// Number of vertices in the vertex data
+	const uint16_t *rIndexData;					// Indices into the vertex data for each triangle
+	uint32_t unTriangleCount;					// Number of triangles in the mesh. Index count is 3 * TriangleCount
+	TextureID_t diffuseTextureId;				// Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( pop )
+#endif
+
+
+struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible; // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack( pop )
+
+class IVRRenderModels
+{
+public:
+
+	/** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+	* from the Prop_RenderModelName_String property or an absolute path name to a render model on disk.
+	*
+	* The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the
+	* application is finished with the render model it should call FreeRenderModel() to free the memory associated
+	* with the model.
+	*
+	* The method returns VRRenderModelError_Loading while the render model is still being loaded.
+	* The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+	virtual EVRRenderModelError LoadRenderModel_Async( const char *pchRenderModelName, RenderModel_t **ppRenderModel ) = 0;
+
+	/** Frees a previously returned render model
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeRenderModel( RenderModel_t *pRenderModel ) = 0;
+
+	/** Loads and returns a texture for use in the application. */
+	virtual EVRRenderModelError LoadTexture_Async( TextureID_t textureId, RenderModel_TextureMap_t **ppTexture ) = 0;
+
+	/** Frees a previously returned texture
+	*   It is safe to call this on a null ptr. */
+	virtual void FreeTexture( RenderModel_TextureMap_t *pTexture ) = 0;
+
+	/** Creates a D3D11 texture and loads data into it. */
+	virtual EVRRenderModelError LoadTextureD3D11_Async( TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D ) = 0;
+
+	/** Helper function to copy the bits into an existing texture. */
+	virtual EVRRenderModelError LoadIntoTextureD3D11_Async( TextureID_t textureId, void *pDstTexture ) = 0;
+
+	/** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+	virtual void FreeTextureD3D11( void *pD3D11Texture2D ) = 0;
+
+	/** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetRenderModelName( uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen ) = 0;
+
+	/** Returns the number of available render models. */
+	virtual uint32_t GetRenderModelCount() = 0;
+
+
+	/** Returns the number of components of the specified render model.
+	*  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+	*  Examples controller components:
+	*   renderable things such as triggers, buttons
+	*   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+	*   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+	*   Returns 0 if components not supported, >0 otherwise */
+	virtual uint32_t GetComponentCount( const char *pchRenderModelName ) = 0;
+
+	/** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+	* is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentName( const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING( ) char *pchComponentName, uint32_t unComponentNameLen ) = 0;
+
+	/** Get the button mask for all buttons associated with this component
+	*   If no buttons (or axes) are associated with this component, return 0
+	*   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+	*   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+	virtual uint64_t GetComponentButtonMask( const char *pchRenderModelName, const char *pchComponentName ) = 0;
+
+	/** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+	* If the component name is out of range, this function will return 0.
+	* Otherwise, it will return the size of the buffer required for the name. */
+	virtual uint32_t GetComponentRenderModelName( const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING( ) char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen ) = 0;
+
+	/** Use this to query information about the component, as a function of the controller state.
+	*
+	* For dynamic controller components (ex: trigger) values will reflect component motions
+	* For static components this will return a consistent value independent of the VRControllerState_t
+	*
+	* If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+	* Otherwise, return true
+	* Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+	virtual bool GetComponentStateForDevicePath( const char *pchRenderModelName, const char *pchComponentName, vr::VRInputValueHandle_t devicePath, const vr::RenderModel_ControllerMode_State_t *pState, vr::RenderModel_ComponentState_t *pComponentState ) = 0;
+
+	/** This version of GetComponentState takes a controller state block instead of an action origin. This function is deprecated. You should use the new input system and GetComponentStateForDevicePath instead. */
+	virtual bool GetComponentState( const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState ) = 0;
+
+	/** Returns true if the render model has a component with the specified name */
+	virtual bool RenderModelHasComponent( const char *pchRenderModelName, const char *pchComponentName ) = 0;
+
+	/** Returns the URL of the thumbnail image for this rendermodel */
+	virtual uint32_t GetRenderModelThumbnailURL( const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError ) = 0;
+
+	/** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+	* hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+	* model. */
+	virtual uint32_t GetRenderModelOriginalPath( const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError ) = 0;
+
+	/** Returns a string for a render model error */
+	virtual const char *GetRenderModelErrorNameFromEnum( vr::EVRRenderModelError error ) = 0;
+};
+
+static const char * const IVRRenderModels_Version = "IVRRenderModels_006";
+
+}
+
+
+// ivrextendeddisplay.h
+
+namespace vr
+{
+
+	/** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+	* direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+	class IVRExtendedDisplay
+	{
+	public:
+
+		/** Size and position that the window needs to be on the VR display. */
+		virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** Gets the viewport in the frame buffer to draw the output of the distortion into */
+		virtual void GetEyeOutputViewport( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+		/** [D3D10/11 Only]
+		* Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+		* to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+		*/
+		virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) = 0;
+
+	};
+
+	static const char * const IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+
+}
+
+
+// ivrtrackedcamera.h
+
+namespace vr
+{
+
+class IVRTrackedCamera
+{
+public:
+	/** Returns a string for an error */
+	virtual const char *GetCameraErrorNameFromEnum( vr::EVRTrackedCameraError eCameraError ) = 0;
+
+	/** For convenience, same as tracked property request Prop_HasCamera_Bool */
+	virtual vr::EVRTrackedCameraError HasCamera( vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera ) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetCameraFrameSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize ) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraIntrinsics( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter ) = 0;
+
+	virtual vr::EVRTrackedCameraError GetCameraProjection( vr::TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) = 0;
+
+	/** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+	* If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+	* The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+	* The camera may go inactive due to lack of active consumers or headset idleness. */
+	virtual vr::EVRTrackedCameraError AcquireVideoStreamingService( vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle ) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamingService( vr::TrackedCameraHandle_t hTrackedCamera ) = 0;
+
+	/** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+	* A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+	* the caller to determine if the frame as advanced per the frame header sequence.
+	* If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+	* Ideally a caller should be polling at ~16ms intervals */
+	virtual vr::EVRTrackedCameraError GetVideoStreamFrameBuffer( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+
+	/** Gets size of the image frame. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+	/** Access a shared D3D11 texture for the specified tracked camera stream.
+	* The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+	* Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+	* VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+	* by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted
+	* guarantees a rectangle where all pixels are valid. */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+
+	/** Access a shared GL texture for the specified tracked camera stream */
+	virtual vr::EVRTrackedCameraError GetVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+	virtual vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId ) = 0;
+	virtual void SetCameraTrackingSpace( vr::ETrackingUniverseOrigin eUniverse ) = 0;
+	virtual vr::ETrackingUniverseOrigin GetCameraTrackingSpace( ) = 0;
+};
+
+static const char * const IVRTrackedCamera_Version = "IVRTrackedCamera_006";
+
+} // namespace vr
+
+
+// ivrscreenshots.h
+
+namespace vr
+{
+
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+	VRScreenshotError_None							= 0,
+	VRScreenshotError_RequestFailed					= 1,
+	VRScreenshotError_IncompatibleVersion			= 100,
+	VRScreenshotError_NotFound						= 101,
+	VRScreenshotError_BufferTooSmall				= 102,
+	VRScreenshotError_ScreenshotAlreadyInProgress	= 108,
+};
+
+/** Allows the application to generate screenshots */
+class IVRScreenshots
+{
+public:
+	/** Request a screenshot of the requested type.
+	 *  A request of the VRScreenshotType_Stereo type will always
+	 *  work. Other types will depend on the underlying application
+	 *  support.
+	 *  The first file name is for the preview image and should be a
+	 *  regular screenshot (ideally from the left eye). The second
+	 *  is the VR screenshot in the correct format. They should be
+	 *  in the same aspect ratio.  Formats per type:
+	 *  VRScreenshotType_Mono: the VR filename is ignored (can be
+	 *  nullptr), this is a normal flat single shot.
+	 *  VRScreenshotType_Stereo:  The VR image should be a
+	 *  side-by-side with the left eye image on the left.
+	 *  VRScreenshotType_Cubemap: The VR image should be six square
+	 *  images composited horizontally.
+	 *  VRScreenshotType_StereoPanorama: above/below with left eye
+	 *  panorama being the above image.  Image is typically square
+	 *  with the panorama being 2x horizontal.
+	 *
+	 *  Note that the VR dashboard will call this function when
+	 *  the user presses the screenshot binding (currently System
+	 *  Button + Trigger).  If Steam is running, the destination
+	 *  file names will be in %TEMP% and will be copied into
+	 *  Steam's screenshot library for the running application
+	 *  once SubmitScreenshot() is called.
+	 *  If Steam is not running, the paths will be in the user's
+	 *  documents folder under Documents\SteamVR\Screenshots.
+	 *  Other VR applications can call this to initiate a
+	 *  screenshot outside of user control.
+	 *  The destination file names do not need an extension,
+	 *  will be replaced with the correct one for the format
+	 *  which is currently .png. */
+	virtual vr::EVRScreenshotError RequestScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename ) = 0;
+
+	/** Called by the running VR application to indicate that it
+	 *  wishes to be in charge of screenshots.  If the
+	 *  application does not call this, the Compositor will only
+	 *  support VRScreenshotType_Stereo screenshots that will be
+	 *  captured without notification to the running app.
+	 *  Once hooked your application will receive a
+	 *  VREvent_RequestScreenshot event when the user presses the
+	 *  buttons to take a screenshot. */
+	virtual vr::EVRScreenshotError HookScreenshot( VR_ARRAY_COUNT( numTypes ) const vr::EVRScreenshotType *pSupportedTypes, int numTypes ) = 0;
+
+	/** When your application receives a
+	 *  VREvent_RequestScreenshot event, call these functions to get
+	 *  the details of the screenshot request. */
+	virtual vr::EVRScreenshotType GetScreenshotPropertyType( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError ) = 0;
+
+	/** Get the filename for the preview or vr image (see
+	 *  vr::EScreenshotPropertyFilenames).  The return value is
+	 *  the size of the string.   */
+ 	virtual uint32_t GetScreenshotPropertyFilename( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError ) = 0;
+
+	/** Call this if the application is taking the screen shot
+	 *  will take more than a few ms processing. This will result
+	 *  in an overlay being presented that shows a completion
+	 *  bar. */
+	virtual vr::EVRScreenshotError UpdateScreenshotProgress( vr::ScreenshotHandle_t screenshotHandle, float flProgress ) = 0;
+
+	/** Tells the compositor to take an internal screenshot of
+	 *  type VRScreenshotType_Stereo. It will take the current
+	 *  submitted scene textures of the running application and
+	 *  write them into the preview image and a side-by-side file
+	 *  for the VR image.
+	 *  This is similar to request screenshot, but doesn't ever
+	 *  talk to the application, just takes the shot and submits. */
+	virtual vr::EVRScreenshotError TakeStereoScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename ) = 0;
+
+	/** Submit the completed screenshot.  If Steam is running
+	 *  this will call into the Steam client and upload the
+	 *  screenshot to the screenshots section of the library for
+	 *  the running application.  If Steam is not running, this
+	 *  function will display a notification to the user that the
+	 *  screenshot was taken. The paths should be full paths with
+	 *  extensions.
+	 *  File paths should be absolute including extensions.
+	 *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+	 *  was a new shot taking by the app to be saved and not
+	 *  initiated by a user (achievement earned or something) */
+	virtual vr::EVRScreenshotError SubmitScreenshot( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename ) = 0;
+};
+
+static const char * const IVRScreenshots_Version = "IVRScreenshots_001";
+
+} // namespace vr
+
+
+
+// ivrresources.h
+
+namespace vr
+{
+
+class IVRResources
+{
+public:
+
+	// ------------------------------------
+	// Shared Resource Methods
+	// ------------------------------------
+
+	/** Loads the specified resource into the provided buffer if large enough.
+	* Returns the size in bytes of the buffer required to hold the specified resource. */
+	virtual uint32_t LoadSharedResource( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen ) = 0;
+
+	/** Provides the full path to the specified resource. Resource names can include named directories for
+	* drivers and other things, and this resolves all of those and returns the actual physical path.
+	* pchResourceTypeDirectory is the subdirectory of resources to look in. */
+	virtual uint32_t GetResourceFullPath( const char *pchResourceName, const char *pchResourceTypeDirectory, VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferLen ) = 0;
+};
+
+static const char * const IVRResources_Version = "IVRResources_001";
+
+
+}
+
+// ivrdrivermanager.h
+
+namespace vr
+{
+
+class IVRDriverManager
+{
+public:
+	virtual uint32_t GetDriverCount() const = 0;
+
+	/** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+	virtual uint32_t GetDriverName( vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	virtual DriverHandle_t GetDriverHandle( const char *pchDriverName ) = 0;
+
+	virtual bool IsEnabled( vr::DriverId_t nDriver ) const = 0;
+};
+
+static const char * const IVRDriverManager_Version = "IVRDriverManager_001";
+
+} // namespace vr
+
+
+
+// ivrinput.h
+
+namespace vr
+{
+	// Maximum number of characters in an action name, including the trailing null
+	static const uint32_t k_unMaxActionNameLength = 64;
+
+	// Maximum number of characters in an action set name, including the trailing null
+	static const uint32_t k_unMaxActionSetNameLength = 64;
+
+	// Maximum number of origins for an action
+	static const uint32_t k_unMaxActionOriginCount = 16;
+
+	// Maximum number of characters in a bone name, including the trailing null
+	static const uint32_t k_unMaxBoneNameLength = 32;
+
+	enum EVRSkeletalTransformSpace
+	{
+		VRSkeletalTransformSpace_Model = 0,
+		VRSkeletalTransformSpace_Parent = 1
+	};
+
+	enum EVRSkeletalReferencePose
+	{
+		VRSkeletalReferencePose_BindPose = 0,
+		VRSkeletalReferencePose_OpenHand,
+		VRSkeletalReferencePose_Fist,
+		VRSkeletalReferencePose_GripLimit
+	};
+
+	enum EVRFinger
+	{
+		VRFinger_Thumb = 0,
+		VRFinger_Index,
+		VRFinger_Middle,
+		VRFinger_Ring,
+		VRFinger_Pinky,
+		VRFinger_Count
+	};
+
+	enum EVRFingerSplay
+	{
+		VRFingerSplay_Thumb_Index = 0,
+		VRFingerSplay_Index_Middle,
+		VRFingerSplay_Middle_Ring,
+		VRFingerSplay_Ring_Pinky,
+		VRFingerSplay_Count
+	};
+
+	enum EVRSummaryType
+	{
+		// The skeletal summary data will match the animated bone transforms for the action.
+		VRSummaryType_FromAnimation = 0,
+
+		// The skeletal summary data will include unprocessed data directly from the device when available.
+		// This data is generally less latent than the data that is computed from the animations.
+		VRSummaryType_FromDevice = 1,
+	};
+
+	enum EVRInputFilterCancelType
+	{
+		VRInputFilterCancel_Timers = 0,
+		VRInputFilterCancel_Momentum = 1,
+	};
+
+	enum EVRInputStringBits
+	{
+		VRInputString_Hand = 0x01,
+		VRInputString_ControllerType = 0x02,
+		VRInputString_InputSource = 0x04,
+
+		VRInputString_All = 0xFFFFFFFF
+	};
+
+	struct InputAnalogActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action; will be delta updates for mouse actions */
+		float x, y, z;
+
+		/** Deltas since the previous call to UpdateActionState() */
+		float deltaX, deltaY, deltaZ;
+
+		/** Time relative to now when this event happened. Will be negative to indicate a past time. */
+		float fUpdateTime;
+	};
+
+	struct InputDigitalActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action; will be true if currently pressed */
+		bool bState;
+
+		/** This is true if the state has changed since the last frame */
+		bool bChanged;
+
+		/** Time relative to now when this event happened. Will be negative to indicate a past time. */
+		float fUpdateTime;
+	};
+
+	struct InputPoseActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+
+		/** The current state of this action */
+		TrackedDevicePose_t pose;
+	};
+
+	struct InputSkeletalActionData_t
+	{
+		/** Whether or not this action is currently available to be bound in the active action set */
+		bool bActive;
+
+		/** The origin that caused this action's current state */
+		VRInputValueHandle_t activeOrigin;
+	};
+
+	struct InputOriginInfo_t
+	{
+		VRInputValueHandle_t devicePath;
+		TrackedDeviceIndex_t trackedDeviceIndex;
+		char rchRenderModelComponentName[128];
+	};
+
+	struct InputBindingInfo_t
+	{
+		char rchDevicePathName[128];
+		char rchInputPathName[128];
+		char rchModeName[128];
+		char rchSlotName[128];
+		char rchInputSourceType[ 32 ];
+	};
+
+	// * Experimental global action set priority *
+	// These constants are part of the experimental support in SteamVR for overlay
+	// apps selectively overriding input in the base scene application. This may be
+	// useful for overlay applications that need to use part or all of a controller
+	// without taking away all input to the game. This system must be enabled by the
+	// "Experimental overlay input overrides" setting in the developer section of
+	// SteamVR settings.
+	//
+	// To use this system, set the nPriority field of an action set to any number in
+	// this range.
+	static const int32_t k_nActionSetOverlayGlobalPriorityMin	= 0x01000000;
+	static const int32_t k_nActionSetOverlayGlobalPriorityMax	= 0x01FFFFFF;
+
+	static const int32_t k_nActionSetPriorityReservedMin		= 0x02000000;
+
+	struct VRActiveActionSet_t
+	{
+		/** This is the handle of the action set to activate for this frame. */
+		VRActionSetHandle_t ulActionSet;
+
+		/** This is the handle of a device path that this action set should be active for. To
+		* activate for all devices, set this to k_ulInvalidInputValueHandle. */
+		VRInputValueHandle_t ulRestrictedToDevice;
+
+		/** The action set to activate for all devices other than ulRestrictedDevice. If
+		* ulRestrictedToDevice is set to k_ulInvalidInputValueHandle, this parameter is
+		* ignored. */
+		VRActionSetHandle_t ulSecondaryActionSet;
+
+		// This field is ignored
+		uint32_t unPadding;
+
+		/** The priority of this action set relative to other action sets. Any inputs
+		* bound to a source (e.g. trackpad, joystick, trigger) will disable bindings in
+		* other active action sets with a smaller priority.
+		*
+		* Overlay applications (i.e. ApplicationType_Overlay) may set their action set priority
+		* to a value between k_nActionSetOverlayGlobalPriorityMin and k_nActionSetOverlayGlobalPriorityMax
+		* to cause any inputs bound to a source used by that action set to be disabled in scene applications.
+		*
+		* No action set priority may value may be larger than k_nActionSetPriorityReservedMin
+		*/
+		int32_t nPriority;
+	};
+
+	/** Contains summary information about the current skeletal pose */
+	struct VRSkeletalSummaryData_t
+	{
+		/** The amount that each finger is 'curled' inwards towards the palm.  In the case of the thumb,
+		* this represents how much the thumb is wrapped around the fist.
+		* 0 means straight, 1 means fully curled */
+		float	flFingerCurl[ VRFinger_Count ];
+
+		/** The amount that each pair of adjacent fingers are separated.
+		* 0 means the digits are touching, 1 means they are fully separated.
+		*/
+		float	flFingerSplay[ VRFingerSplay_Count ];
+	};
+
+
+	class IVRInput
+	{
+	public:
+
+		// ---------------  Handle management   --------------- //
+
+		/** Sets the path to the action manifest JSON file that is used by this application. If this information
+		* was set on the Steam partner site, calls to this function are ignored. If the Steam partner site
+		* setting and the path provided by this call are different, VRInputError_MismatchedActionManifest is returned.
+		* This call must be made before the first call to UpdateActionState or IVRSystem::PollNextEvent. */
+		virtual EVRInputError SetActionManifestPath( const char *pchActionManifestPath ) = 0;
+
+		/** Returns a handle for an action set. This handle is used for all performance-sensitive calls. */
+		virtual EVRInputError GetActionSetHandle( const char *pchActionSetName, VRActionSetHandle_t *pHandle ) = 0;
+
+		/** Returns a handle for an action. This handle is used for all performance-sensitive calls. */
+		virtual EVRInputError GetActionHandle( const char *pchActionName, VRActionHandle_t *pHandle ) = 0;
+
+		/** Returns a handle for any path in the input system. E.g. /user/hand/right */
+		virtual EVRInputError GetInputSourceHandle( const char *pchInputSourcePath, VRInputValueHandle_t *pHandle ) = 0;
+
+
+
+		// --------------- Reading action state ------------------- //
+
+		/** Reads the current state into all actions. After this call, the results of Get*Action calls
+		* will be the same until the next call to UpdateActionState. */
+		virtual EVRInputError UpdateActionState( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount ) = 0;
+
+		/** Reads the state of a digital action given its handle. This will return VRInputError_WrongType if the type of
+		* action is something other than digital */
+		virtual EVRInputError GetDigitalActionData( VRActionHandle_t action, InputDigitalActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of an analog action given its handle. This will return VRInputError_WrongType if the type of
+		* action is something other than analog */
+		virtual EVRInputError GetAnalogActionData( VRActionHandle_t action, InputAnalogActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a pose action given its handle for the number of seconds relative to now. This
+		* will generally be called with negative times from the fUpdateTime fields in other actions. */
+		virtual EVRInputError GetPoseActionDataRelativeToNow( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a pose action given its handle. The returned values will match the values returned
+		* by the last call to IVRCompositor::WaitGetPoses(). */
+		virtual EVRInputError GetPoseActionDataForNextFrame( VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, InputPoseActionData_t *pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		/** Reads the state of a skeletal action given its handle. */
+		virtual EVRInputError GetSkeletalActionData( VRActionHandle_t action, InputSkeletalActionData_t *pActionData, uint32_t unActionDataSize ) = 0;
+
+		/** Returns the current dominant hand for the user for this application. This function will only return success for applications
+		* which include "supports_dominant_hand_setting": true in their action manifests. The dominant hand will only change after
+		* a call to UpdateActionState, and the action data returned after that point will use the new dominant hand. */
+		virtual EVRInputError GetDominantHand( ETrackedControllerRole *peDominantHand ) = 0;
+
+		/** Sets the dominant hand for the user for this application. */
+		virtual EVRInputError SetDominantHand( ETrackedControllerRole eDominantHand ) = 0;
+
+		// ---------------  Static Skeletal Data ------------------- //
+
+		/** Reads the number of bones in skeleton associated with the given action */
+		virtual EVRInputError GetBoneCount( VRActionHandle_t action, uint32_t* pBoneCount ) = 0;
+
+		/** Fills the given array with the index of each bone's parent in the skeleton associated with the given action */
+		virtual EVRInputError GetBoneHierarchy( VRActionHandle_t action, VR_ARRAY_COUNT( unIndexArayCount ) BoneIndex_t* pParentIndices, uint32_t unIndexArayCount ) = 0;
+
+		/** Fills the given buffer with the name of the bone at the given index in the skeleton associated with the given action */
+		virtual EVRInputError GetBoneName( VRActionHandle_t action, BoneIndex_t nBoneIndex, VR_OUT_STRING() char* pchBoneName, uint32_t unNameBufferSize ) = 0;
+
+		/** Fills the given buffer with the transforms for a specific static skeletal reference pose */
+		virtual EVRInputError GetSkeletalReferenceTransforms( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		/** Reads the level of accuracy to which the controller is able to track the user to recreate a skeletal pose */
+		virtual EVRInputError GetSkeletalTrackingLevel( VRActionHandle_t action, EVRSkeletalTrackingLevel* pSkeletalTrackingLevel ) = 0;
+
+		// ---------------  Dynamic Skeletal Data ------------------- //
+
+		/** Reads the state of the skeletal bone data associated with this action and copies it into the given buffer. */
+		virtual EVRInputError GetSkeletalBoneData( VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		/** Reads summary information about the current pose of the skeleton associated with the given action.   */
+		virtual EVRInputError GetSkeletalSummaryData( VRActionHandle_t action, EVRSummaryType eSummaryType, VRSkeletalSummaryData_t * pSkeletalSummaryData ) = 0;
+
+		/** Reads the state of the skeletal bone data in a compressed form that is suitable for
+		* sending over the network. The required buffer size will never exceed ( sizeof(VR_BoneTransform_t)*boneCount + 2).
+		* Usually the size will be much smaller. */
+		virtual EVRInputError GetSkeletalBoneDataCompressed( VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, VR_OUT_BUFFER_COUNT( unCompressedSize ) void *pvCompressedData, uint32_t unCompressedSize, uint32_t *punRequiredCompressedSize ) = 0;
+
+		/** Turns a compressed buffer from GetSkeletalBoneDataCompressed and turns it back into a bone transform array. */
+		virtual EVRInputError DecompressSkeletalBoneData( const void *pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VR_ARRAY_COUNT( unTransformArrayCount ) VRBoneTransform_t *pTransformArray, uint32_t unTransformArrayCount ) = 0;
+
+		// --------------- Haptics ------------------- //
+
+		/** Triggers a haptic event as described by the specified action */
+		virtual EVRInputError TriggerHapticVibrationAction( VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice ) = 0;
+
+		// --------------- Action Origins ---------------- //
+
+		/** Retrieve origin handles for an action */
+		virtual EVRInputError GetActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VR_ARRAY_COUNT( originOutCount ) VRInputValueHandle_t *originsOut, uint32_t originOutCount ) = 0;
+
+		/** Retrieves the name of the origin in the current language. unStringSectionsToInclude is a bitfield of values in EVRInputStringBits that allows the
+			application to specify which parts of the origin's information it wants a string for. */
+		virtual EVRInputError GetOriginLocalizedName( VRInputValueHandle_t origin, VR_OUT_STRING() char *pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude ) = 0;
+
+		/** Retrieves useful information for the origin of this action */
+		virtual EVRInputError GetOriginTrackedDeviceInfo( VRInputValueHandle_t origin, InputOriginInfo_t *pOriginInfo, uint32_t unOriginInfoSize ) = 0;
+
+		/** Retrieves useful information about the bindings for an action */
+		virtual EVRInputError GetActionBindingInfo( VRActionHandle_t action, InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t *punReturnedBindingInfoCount ) = 0;
+
+		/** Shows the current binding for the action in-headset */
+		virtual EVRInputError ShowActionOrigins( VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle ) = 0;
+
+		/** Shows the current binding all the actions in the specified action sets */
+		virtual EVRInputError ShowBindingsForActionSet( VR_ARRAY_COUNT( unSetCount ) VRActiveActionSet_t *pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight ) = 0;
+
+		/** Use this to query what action on the component returned by GetOriginTrackedDeviceInfo would trigger this binding. */
+		virtual EVRInputError GetComponentStateForBinding( const char *pchRenderModelName, const char *pchComponentName,
+			const InputBindingInfo_t *pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount,
+			vr::RenderModel_ComponentState_t *pComponentState ) = 0;
+
+
+		// --------------- Legacy Input ------------------- //
+		virtual bool IsUsingLegacyInput() = 0;
+
+
+		// --------------- Utilities ------------------- //
+
+		/** Opens the binding user interface. If no app key is provided it will use the key from the calling process.
+		* If no set is provided it will open to the root of the app binding page. */
+		virtual EVRInputError OpenBindingUI( const char* pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop ) = 0;
+
+		/** Returns the variant set in the current bindings. If the binding doesn't include a variant setting, this function
+		* will return an empty string */
+		virtual EVRInputError GetBindingVariant( vr::VRInputValueHandle_t ulDevicePath,
+			VR_OUT_STRING() char *pchVariantArray, uint32_t unVariantArraySize ) = 0;
+
+	};
+
+	static const char * const IVRInput_Version = "IVRInput_010";
+
+} // namespace vr
+
+// ivriobuffer.h
+
+namespace vr
+{
+
+typedef uint64_t IOBufferHandle_t;
+static const uint64_t k_ulInvalidIOBufferHandle = 0;
+
+	enum EIOBufferError
+	{
+		IOBuffer_Success                  = 0,
+		IOBuffer_OperationFailed          = 100,
+		IOBuffer_InvalidHandle            = 101,
+		IOBuffer_InvalidArgument          = 102,
+		IOBuffer_PathExists               = 103,
+		IOBuffer_PathDoesNotExist         = 104,
+		IOBuffer_Permission               = 105,
+	};
+
+	enum EIOBufferMode
+	{
+		IOBufferMode_Read                 = 0x0001,
+		IOBufferMode_Write                = 0x0002,
+		IOBufferMode_Create               = 0x0200,
+	};
+
+	// ----------------------------------------------------------------------------------------------
+	// Purpose:
+	// ----------------------------------------------------------------------------------------------
+	class IVRIOBuffer
+	{
+	public:
+		/** opens an existing or creates a new IOBuffer of unSize bytes */
+		virtual vr::EIOBufferError Open( const char *pchPath, vr::EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, vr::IOBufferHandle_t *pulBuffer ) = 0;
+
+		/** closes a previously opened or created buffer */
+		virtual vr::EIOBufferError Close( vr::IOBufferHandle_t ulBuffer ) = 0;
+
+		/** reads up to unBytes from buffer into *pDst, returning number of bytes read in *punRead */
+		virtual vr::EIOBufferError Read( vr::IOBufferHandle_t ulBuffer, void *pDst, uint32_t unBytes, uint32_t *punRead ) = 0;
+
+		/** writes unBytes of data from *pSrc into a buffer. */
+		virtual vr::EIOBufferError Write( vr::IOBufferHandle_t ulBuffer, void *pSrc, uint32_t unBytes ) = 0;
+
+		/** retrieves the property container of an buffer. */
+		virtual vr::PropertyContainerHandle_t PropertyContainer( vr::IOBufferHandle_t ulBuffer ) = 0;
+
+		/** inexpensively checks for readers to allow writers to fast-fail potentially expensive copies and writes. */
+		virtual bool HasReaders( vr::IOBufferHandle_t ulBuffer ) = 0;
+	};
+
+	static const char *IVRIOBuffer_Version = "IVRIOBuffer_002";
+}
+
+// ivrspatialanchors.h
+
+namespace vr
+{
+	static const SpatialAnchorHandle_t k_ulInvalidSpatialAnchorHandle = 0;
+
+	struct SpatialAnchorPose_t
+	{
+		HmdMatrix34_t mAnchorToAbsoluteTracking;
+	};
+
+	class IVRSpatialAnchors
+	{
+	public:
+
+		/** Returns a handle for an spatial anchor described by "descriptor".  On success, pHandle
+		* will contain a handle valid for this session.  Caller can wait for an event or occasionally
+		* poll GetSpatialAnchorPose() to find the virtual coordinate associated with this anchor. */
+		virtual EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor( const char *pchDescriptor, SpatialAnchorHandle_t *pHandleOut ) = 0;
+
+		/** Returns a handle for an new spatial anchor at pPose.  On success, pHandle
+		* will contain a handle valid for this session.  Caller can wait for an event or occasionally
+		* poll GetSpatialAnchorDescriptor() to find the permanent descriptor for this pose.
+		* The result of GetSpatialAnchorPose() may evolve from this initial position if the driver chooses
+		* to update it.
+		* The anchor will be associated with the driver that provides unDeviceIndex, and the driver may use that specific
+		* device as a hint for how to best create the anchor.
+		* The eOrigin must match whatever tracking origin you are working in (seated/standing/raw).
+		* This should be called when the user is close to (and ideally looking at/interacting with) the target physical
+		* location.  At that moment, the driver will have the most information about how to recover that physical point
+		* in the future, and the quality of the anchor (when the descriptor is re-used) will be highest.
+		* The caller may decide to apply offsets from this initial pose, but is advised to stay relatively close to the
+		* original pose location for highest fidelity. */
+		virtual EVRSpatialAnchorError CreateSpatialAnchorFromPose( TrackedDeviceIndex_t unDeviceIndex, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPose, SpatialAnchorHandle_t *pHandleOut ) = 0;
+
+		/** Get the pose for a given handle.  This is intended to be cheap enough to call every frame (or fairly often)
+		* so that the driver can refine this position when it has more information available. */
+		virtual EVRSpatialAnchorError GetSpatialAnchorPose( SpatialAnchorHandle_t unHandle, ETrackingUniverseOrigin eOrigin, SpatialAnchorPose_t *pPoseOut ) = 0;
+
+		/** Get the descriptor for a given handle.  This will be empty for handles where the driver has not
+		* yet built a descriptor.  It will be the application-supplied descriptor for previously saved anchors
+		* that the application is requesting poses for.  If the driver has called UpdateSpatialAnchorDescriptor()
+		* already in this session, it will be the descriptor provided by the driver.
+		* Returns true if the descriptor fits into the buffer, else false.  Buffer size should be at least
+		* k_unMaxSpatialAnchorDescriptorSize. */
+		virtual EVRSpatialAnchorError GetSpatialAnchorDescriptor( SpatialAnchorHandle_t unHandle, VR_OUT_STRING() char *pchDescriptorOut, uint32_t *punDescriptorBufferLenInOut ) = 0;
+
+	};
+
+	static const char * const IVRSpatialAnchors_Version = "IVRSpatialAnchors_001";
+
+} // namespace vr
+
+// ivrdebug.h
+
+namespace vr
+{
+	enum EVRDebugError
+	{
+		VRDebugError_Success = 0,
+		VRDebugError_BadParameter
+	};
+
+	/** Handle for vr profiler events */
+	typedef uint64_t VrProfilerEventHandle_t;
+
+	class IVRDebug
+	{
+	public:
+
+		/** Create a vr profiler discrete event (point)
+		* The event will be associated with the message provided in pchMessage, and the current
+		* time will be used as the event timestamp. */
+		virtual EVRDebugError EmitVrProfilerEvent( const char *pchMessage ) = 0;
+
+		/** Create an vr profiler duration event (line)
+		* The current time will be used as the timestamp for the start of the line.
+		* On success, pHandleOut will contain a handle valid for terminating this event. */
+		virtual EVRDebugError BeginVrProfilerEvent( VrProfilerEventHandle_t *pHandleOut ) = 0;
+
+		/** Terminate a vr profiler event
+		* The event associated with hHandle will be considered completed when this method is called.
+		* The current time will be used assocaited to the termination time of the event, and
+		* pchMessage will be used as the event title. */
+		virtual EVRDebugError FinishVrProfilerEvent( VrProfilerEventHandle_t hHandle, const char *pchMessage ) = 0;
+
+		/** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+		* but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated.
+		* The size of the response including its terminating null is returned. */
+		virtual uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, VR_OUT_STRING() char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0;
+
+	};
+
+	static const char * const IVRDebug_Version = "IVRDebug_001";
+
+} // namespace vr
+// End
+
+#endif // _OPENVR_API
+
+
+
+namespace vr
+{
+#if !defined( OPENVR_INTERFACE_INTERNAL )
+
+	/** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+	* or relative to the current working directory. These are the local install versions of the equivalent
+	* functions in steamvr.h and will work without a local Steam install.
+	*
+	* This path is to the "root" of the VR API install. That's the directory with
+	* the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+	*
+	* pStartupInfo is reserved for future use.
+	*/
+	inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr );
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	inline void VR_Shutdown();
+
+	/** Returns true if there is an HMD attached. This check is as lightweight as possible and
+	* can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+	* to know if initializing VR is a possibility but isn't ready to take that step yet.
+	*/
+	VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+	/** Returns true if the OpenVR runtime is installed. */
+	VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+	/** Returns where the OpenVR runtime is installed. */
+	VR_INTERFACE bool VR_GetRuntimePath( VR_OUT_STRING() char *pchPathBuffer, uint32_t unBufferSize, uint32_t *punRequiredBufferSize );
+	
+	/** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+	VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol( EVRInitError error );
+
+	/** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+	* use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+	VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+
+	/** Returns the interface of the specified version. This method must be called after VR_Init. The
+	* pointer returned is valid until VR_Shutdown is called.
+	*/
+	VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+
+	/** Returns whether the interface of the specified version exists.
+	*/
+	VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid( const char *pchInterfaceVersion );
+
+	/** Returns a token that represents whether the VR interface handles need to be reloaded */
+	VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+	// These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+	// They will go away in the future.
+	typedef EVRInitError HmdError;
+	typedef EVREye Hmd_Eye;
+	typedef EColorSpace ColorSpace;
+	typedef ETrackingResult HmdTrackingResult;
+	typedef ETrackedDeviceClass TrackedDeviceClass;
+	typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+	typedef ETrackedDeviceProperty TrackedDeviceProperty;
+	typedef ETrackedPropertyError TrackedPropertyError;
+	typedef EVRSubmitFlags VRSubmitFlags_t;
+	typedef EVRState VRState_t;
+	typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+	typedef EVROverlayError VROverlayError;
+	typedef EVRFirmwareError VRFirmwareError;
+	typedef EVRCompositorError VRCompositorError;
+	typedef EVRScreenshotError VRScreenshotsError;
+
+	inline uint32_t &VRToken()
+	{
+		static uint32_t token;
+		return token;
+	}
+
+	class COpenVRContext
+	{
+	public:
+		COpenVRContext() { Clear(); }
+		void Clear();
+
+		inline void CheckClear()
+		{
+			if ( VRToken() != VR_GetInitToken() )
+			{
+				Clear();
+				VRToken() = VR_GetInitToken();
+			}
+		}
+
+		IVRSystem *VRSystem()
+		{
+			CheckClear();
+			if ( m_pVRSystem == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSystem = ( IVRSystem * )VR_GetGenericInterface( IVRSystem_Version, &eError );
+			}
+			return m_pVRSystem;
+		}
+		IVRChaperone *VRChaperone()
+		{
+			CheckClear();
+			if ( m_pVRChaperone == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRChaperone = ( IVRChaperone * )VR_GetGenericInterface( IVRChaperone_Version, &eError );
+			}
+			return m_pVRChaperone;
+		}
+
+		IVRChaperoneSetup *VRChaperoneSetup()
+		{
+			CheckClear();
+			if ( m_pVRChaperoneSetup == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRChaperoneSetup = ( IVRChaperoneSetup * )VR_GetGenericInterface( IVRChaperoneSetup_Version, &eError );
+			}
+			return m_pVRChaperoneSetup;
+		}
+
+		IVRCompositor *VRCompositor()
+		{
+			CheckClear();
+			if ( m_pVRCompositor == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRCompositor = ( IVRCompositor * )VR_GetGenericInterface( IVRCompositor_Version, &eError );
+			}
+			return m_pVRCompositor;
+		}
+
+		IVROverlay *VROverlay()
+		{
+			CheckClear();
+			if ( m_pVROverlay == nullptr )
+			{
+				EVRInitError eError;
+				m_pVROverlay = ( IVROverlay * )VR_GetGenericInterface( IVROverlay_Version, &eError );
+			}
+			return m_pVROverlay;
+		}
+
+		IVROverlayView *VROverlayView()
+		{
+			CheckClear();
+			if ( m_pVROverlayView == nullptr )
+			{
+				EVRInitError eError;
+				m_pVROverlayView = ( IVROverlayView * ) VR_GetGenericInterface( IVROverlayView_Version, &eError );
+			}
+			return m_pVROverlayView;
+		}
+
+		IVRHeadsetView *VRHeadsetView()
+		{
+			CheckClear();
+			if ( m_pVRHeadsetView == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRHeadsetView = ( IVRHeadsetView * ) VR_GetGenericInterface( IVRHeadsetView_Version, &eError );
+			}
+			return m_pVRHeadsetView;
+		}
+
+		IVRResources *VRResources()
+		{
+			CheckClear();
+			if ( m_pVRResources == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRResources = (IVRResources *)VR_GetGenericInterface( IVRResources_Version, &eError );
+			}
+			return m_pVRResources;
+		}
+
+		IVRScreenshots *VRScreenshots()
+		{
+			CheckClear();
+			if ( m_pVRScreenshots == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRScreenshots = ( IVRScreenshots * )VR_GetGenericInterface( IVRScreenshots_Version, &eError );
+			}
+			return m_pVRScreenshots;
+		}
+
+		IVRRenderModels *VRRenderModels()
+		{
+			CheckClear();
+			if ( m_pVRRenderModels == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRRenderModels = ( IVRRenderModels * )VR_GetGenericInterface( IVRRenderModels_Version, &eError );
+			}
+			return m_pVRRenderModels;
+		}
+
+		IVRExtendedDisplay *VRExtendedDisplay()
+		{
+			CheckClear();
+			if ( m_pVRExtendedDisplay == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRExtendedDisplay = ( IVRExtendedDisplay * )VR_GetGenericInterface( IVRExtendedDisplay_Version, &eError );
+			}
+			return m_pVRExtendedDisplay;
+		}
+
+		IVRSettings *VRSettings()
+		{
+			CheckClear();
+			if ( m_pVRSettings == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRSettings = ( IVRSettings * )VR_GetGenericInterface( IVRSettings_Version, &eError );
+			}
+			return m_pVRSettings;
+		}
+
+		IVRApplications *VRApplications()
+		{
+			CheckClear();
+			if ( m_pVRApplications == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRApplications = ( IVRApplications * )VR_GetGenericInterface( IVRApplications_Version, &eError );
+			}
+			return m_pVRApplications;
+		}
+
+		IVRTrackedCamera *VRTrackedCamera()
+		{
+			CheckClear();
+			if ( m_pVRTrackedCamera == nullptr )
+			{
+				EVRInitError eError;
+				m_pVRTrackedCamera = ( IVRTrackedCamera * )VR_GetGenericInterface( IVRTrackedCamera_Version, &eError );
+			}
+			return m_pVRTrackedCamera;
+		}
+
+		IVRDriverManager *VRDriverManager()
+		{
+			CheckClear();
+			if ( !m_pVRDriverManager )
+			{
+				EVRInitError eError;
+				m_pVRDriverManager = ( IVRDriverManager * )VR_GetGenericInterface( IVRDriverManager_Version, &eError );
+			}
+			return m_pVRDriverManager;
+		}
+
+		IVRInput *VRInput()
+		{
+			CheckClear();
+			if ( !m_pVRInput )
+			{
+				EVRInitError eError;
+				m_pVRInput = (IVRInput *)VR_GetGenericInterface( IVRInput_Version, &eError );
+			}
+			return m_pVRInput;
+		}
+
+		IVRIOBuffer *VRIOBuffer()
+		{
+			if ( !m_pVRIOBuffer )
+			{
+				EVRInitError eError;
+				m_pVRIOBuffer = ( IVRIOBuffer * )VR_GetGenericInterface( IVRIOBuffer_Version, &eError );
+			}
+			return m_pVRIOBuffer;
+		}
+
+		IVRSpatialAnchors *VRSpatialAnchors()
+		{
+			CheckClear();
+			if ( !m_pVRSpatialAnchors )
+			{
+				EVRInitError eError;
+				m_pVRSpatialAnchors = (IVRSpatialAnchors *)VR_GetGenericInterface( IVRSpatialAnchors_Version, &eError );
+			}
+			return m_pVRSpatialAnchors;
+		}
+
+		IVRDebug *VRDebug()
+		{
+			CheckClear();
+			if ( !m_pVRDebug )
+			{
+				EVRInitError eError;
+				m_pVRDebug = (IVRDebug *)VR_GetGenericInterface( IVRDebug_Version, &eError );
+			}
+			return m_pVRDebug;
+		}
+
+		IVRNotifications *VRNotifications()
+		{
+			CheckClear();
+			if ( !m_pVRNotifications )
+			{
+				EVRInitError eError;
+				m_pVRNotifications = ( IVRNotifications * )VR_GetGenericInterface( IVRNotifications_Version, &eError );
+			}
+			return m_pVRNotifications;
+		}
+		
+	private:
+		IVRSystem			*m_pVRSystem;
+		IVRChaperone		*m_pVRChaperone;
+		IVRChaperoneSetup	*m_pVRChaperoneSetup;
+		IVRCompositor		*m_pVRCompositor;
+		IVRHeadsetView		*m_pVRHeadsetView;
+		IVROverlay			*m_pVROverlay;
+		IVROverlayView		*m_pVROverlayView;
+		IVRResources		*m_pVRResources;
+		IVRRenderModels		*m_pVRRenderModels;
+		IVRExtendedDisplay	*m_pVRExtendedDisplay;
+		IVRSettings			*m_pVRSettings;
+		IVRApplications		*m_pVRApplications;
+		IVRTrackedCamera	*m_pVRTrackedCamera;
+		IVRScreenshots		*m_pVRScreenshots;
+		IVRDriverManager	*m_pVRDriverManager;
+		IVRInput			*m_pVRInput;
+		IVRIOBuffer			*m_pVRIOBuffer;
+		IVRSpatialAnchors   *m_pVRSpatialAnchors;
+		IVRDebug			*m_pVRDebug;
+		IVRNotifications	*m_pVRNotifications;
+	};
+
+	inline COpenVRContext &OpenVRInternal_ModuleContext()
+	{
+		static void *ctx[ sizeof( COpenVRContext ) / sizeof( void * ) ];
+		return *( COpenVRContext * )ctx; // bypass zero-init constructor
+	}
+
+	inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+	inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+	inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+	inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+	inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+	inline IVROverlayView *VR_CALLTYPE VROverlayView() { return OpenVRInternal_ModuleContext().VROverlayView(); }
+	inline IVRHeadsetView *VR_CALLTYPE VRHeadsetView() { return OpenVRInternal_ModuleContext().VRHeadsetView(); }
+	inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+	inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+	inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+	inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+	inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+	inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+	inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+	inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+	inline IVRInput *VR_CALLTYPE VRInput() { return OpenVRInternal_ModuleContext().VRInput(); }
+	inline IVRIOBuffer *VR_CALLTYPE VRIOBuffer() { return OpenVRInternal_ModuleContext().VRIOBuffer(); }
+	inline IVRSpatialAnchors *VR_CALLTYPE VRSpatialAnchors() { return OpenVRInternal_ModuleContext().VRSpatialAnchors(); }
+	inline IVRNotifications *VR_CALLTYPE VRNotifications() { return OpenVRInternal_ModuleContext().VRNotifications(); }
+	inline IVRDebug *VR_CALLTYPE VRDebug() { return OpenVRInternal_ModuleContext().VRDebug(); }
+
+	inline void COpenVRContext::Clear()
+	{
+		m_pVRSystem = nullptr;
+		m_pVRChaperone = nullptr;
+		m_pVRChaperoneSetup = nullptr;
+		m_pVRCompositor = nullptr;
+		m_pVROverlay = nullptr;
+		m_pVROverlayView = nullptr;
+		m_pVRHeadsetView = nullptr;
+		m_pVRRenderModels = nullptr;
+		m_pVRExtendedDisplay = nullptr;
+		m_pVRSettings = nullptr;
+		m_pVRApplications = nullptr;
+		m_pVRTrackedCamera = nullptr;
+		m_pVRResources = nullptr;
+		m_pVRScreenshots = nullptr;
+		m_pVRDriverManager = nullptr;
+		m_pVRInput = nullptr;
+		m_pVRIOBuffer = nullptr;
+		m_pVRSpatialAnchors = nullptr;
+		m_pVRNotifications = nullptr;
+		m_pVRDebug = nullptr;
+	}
+	
+	VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo );
+	VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+	/** Finds the active installation of vrclient.dll and initializes it */
+	inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo )
+	{
+		IVRSystem *pVRSystem = nullptr;
+
+		EVRInitError eError;
+		VRToken() = VR_InitInternal2( &eError, eApplicationType, pStartupInfo );
+		COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+		ctx.Clear();
+
+		if ( eError == VRInitError_None )
+		{
+			if ( VR_IsInterfaceVersionValid( IVRSystem_Version ) )
+			{
+				pVRSystem = VRSystem();
+			}
+			else
+			{
+				VR_ShutdownInternal();
+				eError = VRInitError_Init_InterfaceNotFound;
+			}
+		}
+
+		if ( peError )
+			*peError = eError;
+		return pVRSystem;
+	}
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	inline void VR_Shutdown()
+	{
+		VR_ShutdownInternal();
+	}
+
+#endif // OPENVR_INTERFACE_INTERNAL
+}
diff --git a/vrclient_x64/tests/capi_thunks_autogen.c b/vrclient_x64/tests/capi_thunks_autogen.c
index ecde7464..aab5ebc3 100644
--- a/vrclient_x64/tests/capi_thunks_autogen.c
+++ b/vrclient_x64/tests/capi_thunks_autogen.c
@@ -891,19 +891,19 @@ void __thiscall IVRChaperoneSetup_006_RoomSetupStarting(void *_this)
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVRCompositor_026_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+void __thiscall IVRCompositor_027_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eOrigin);
 }
 
-ETrackingUniverseOrigin __thiscall IVRCompositor_026_GetTrackingSpace(void *_this)
+ETrackingUniverseOrigin __thiscall IVRCompositor_027_GetTrackingSpace(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+EVRCompositorError __thiscall IVRCompositor_027_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pRenderPoseArray);
@@ -913,7 +913,7 @@ EVRCompositorError __thiscall IVRCompositor_026_WaitGetPoses(void *_this, Tracke
     return 0;
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+EVRCompositorError __thiscall IVRCompositor_027_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pRenderPoseArray);
@@ -923,7 +923,7 @@ EVRCompositorError __thiscall IVRCompositor_026_GetLastPoses(void *_this, Tracke
     return 0;
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+EVRCompositorError __thiscall IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
@@ -932,7 +932,7 @@ EVRCompositorError __thiscall IVRCompositor_026_GetLastPoseForTrackedDeviceIndex
     return 0;
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+EVRCompositorError __thiscall IVRCompositor_027_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eEye);
@@ -942,17 +942,17 @@ EVRCompositorError __thiscall IVRCompositor_026_Submit(void *_this, EVREye eEye,
     return 0;
 }
 
-void __thiscall IVRCompositor_026_ClearLastSubmittedFrame(void *_this)
+void __thiscall IVRCompositor_027_ClearLastSubmittedFrame(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVRCompositor_026_PostPresentHandoff(void *_this)
+void __thiscall IVRCompositor_027_PostPresentHandoff(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-bool __thiscall IVRCompositor_026_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+bool __thiscall IVRCompositor_027_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pTiming);
@@ -960,7 +960,7 @@ bool __thiscall IVRCompositor_026_GetFrameTiming(void *_this, Compositor_FrameTi
     return 0;
 }
 
-uint32_t __thiscall IVRCompositor_026_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+uint32_t __thiscall IVRCompositor_027_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pTiming);
@@ -968,20 +968,20 @@ uint32_t __thiscall IVRCompositor_026_GetFrameTimings(void *_this, Compositor_Fr
     return 0;
 }
 
-float __thiscall IVRCompositor_026_GetFrameTimeRemaining(void *_this)
+float __thiscall IVRCompositor_027_GetFrameTimeRemaining(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-void __thiscall IVRCompositor_026_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+void __thiscall IVRCompositor_027_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pStats);
     push_uint32_parameter(nStatsSizeInBytes);
 }
 
-void __thiscall IVRCompositor_026_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+void __thiscall IVRCompositor_027_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
 {
     push_ptr_parameter(_this);
     push_float_parameter(fSeconds);
@@ -992,7 +992,7 @@ void __thiscall IVRCompositor_026_FadeToColor(void *_this, float fSeconds, float
     push_bool_parameter(bBackground);
 }
 
-HmdColor_t *__thiscall IVRCompositor_026_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground)
+HmdColor_t *__thiscall IVRCompositor_027_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(_r);
@@ -1000,20 +1000,20 @@ HmdColor_t *__thiscall IVRCompositor_026_GetCurrentFadeColor(void *_this, HmdCol
     return 0;
 }
 
-void __thiscall IVRCompositor_026_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+void __thiscall IVRCompositor_027_FadeGrid(void *_this, float fSeconds, bool bFadeGridIn)
 {
     push_ptr_parameter(_this);
     push_float_parameter(fSeconds);
-    push_bool_parameter(bFadeIn);
+    push_bool_parameter(bFadeGridIn);
 }
 
-float __thiscall IVRCompositor_026_GetCurrentGridAlpha(void *_this)
+float __thiscall IVRCompositor_027_GetCurrentGridAlpha(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+EVRCompositorError __thiscall IVRCompositor_027_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pTextures);
@@ -1021,95 +1021,95 @@ EVRCompositorError __thiscall IVRCompositor_026_SetSkyboxOverride(void *_this, T
     return 0;
 }
 
-void __thiscall IVRCompositor_026_ClearSkyboxOverride(void *_this)
+void __thiscall IVRCompositor_027_ClearSkyboxOverride(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVRCompositor_026_CompositorBringToFront(void *_this)
+void __thiscall IVRCompositor_027_CompositorBringToFront(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVRCompositor_026_CompositorGoToBack(void *_this)
+void __thiscall IVRCompositor_027_CompositorGoToBack(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVRCompositor_026_CompositorQuit(void *_this)
+void __thiscall IVRCompositor_027_CompositorQuit(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-bool __thiscall IVRCompositor_026_IsFullscreen(void *_this)
+bool __thiscall IVRCompositor_027_IsFullscreen(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-uint32_t __thiscall IVRCompositor_026_GetCurrentSceneFocusProcess(void *_this)
+uint32_t __thiscall IVRCompositor_027_GetCurrentSceneFocusProcess(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-uint32_t __thiscall IVRCompositor_026_GetLastFrameRenderer(void *_this)
+uint32_t __thiscall IVRCompositor_027_GetLastFrameRenderer(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVRCompositor_026_CanRenderScene(void *_this)
+bool __thiscall IVRCompositor_027_CanRenderScene(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-void __thiscall IVRCompositor_026_ShowMirrorWindow(void *_this)
+void __thiscall IVRCompositor_027_ShowMirrorWindow(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVRCompositor_026_HideMirrorWindow(void *_this)
+void __thiscall IVRCompositor_027_HideMirrorWindow(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-bool __thiscall IVRCompositor_026_IsMirrorWindowVisible(void *_this)
+bool __thiscall IVRCompositor_027_IsMirrorWindowVisible(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-void __thiscall IVRCompositor_026_CompositorDumpImages(void *_this)
+void __thiscall IVRCompositor_027_CompositorDumpImages(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-bool __thiscall IVRCompositor_026_ShouldAppRenderWithLowResources(void *_this)
+bool __thiscall IVRCompositor_027_ShouldAppRenderWithLowResources(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-void __thiscall IVRCompositor_026_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+void __thiscall IVRCompositor_027_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
 {
     push_ptr_parameter(_this);
     push_bool_parameter(bOverride);
 }
 
-void __thiscall IVRCompositor_026_ForceReconnectProcess(void *_this)
+void __thiscall IVRCompositor_027_ForceReconnectProcess(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVRCompositor_026_SuspendRendering(void *_this, bool bSuspend)
+void __thiscall IVRCompositor_027_SuspendRendering(void *_this, bool bSuspend)
 {
     push_ptr_parameter(_this);
     push_bool_parameter(bSuspend);
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+EVRCompositorError __thiscall IVRCompositor_027_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eEye);
@@ -1118,13 +1118,13 @@ EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureD3D11(void *_thi
     return 0;
 }
 
-void __thiscall IVRCompositor_026_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView)
+void __thiscall IVRCompositor_027_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pD3D11ShaderResourceView);
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+EVRCompositorError __thiscall IVRCompositor_027_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eEye);
@@ -1133,7 +1133,7 @@ EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureGL(void *_this,
     return 0;
 }
 
-bool __thiscall IVRCompositor_026_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+bool __thiscall IVRCompositor_027_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(glTextureId);
@@ -1141,19 +1141,19 @@ bool __thiscall IVRCompositor_026_ReleaseSharedGLTexture(void *_this, glUInt_t g
     return 0;
 }
 
-void __thiscall IVRCompositor_026_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+void __thiscall IVRCompositor_027_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(glSharedTextureHandle);
 }
 
-void __thiscall IVRCompositor_026_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+void __thiscall IVRCompositor_027_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(glSharedTextureHandle);
 }
 
-uint32_t __thiscall IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize)
+uint32_t __thiscall IVRCompositor_027_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchValue);
@@ -1161,7 +1161,7 @@ uint32_t __thiscall IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *
     return 0;
 }
 
-uint32_t __thiscall IVRCompositor_026_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+uint32_t __thiscall IVRCompositor_027_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pPhysicalDevice);
@@ -1170,37 +1170,37 @@ uint32_t __thiscall IVRCompositor_026_GetVulkanDeviceExtensionsRequired(void *_t
     return 0;
 }
 
-void __thiscall IVRCompositor_026_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode)
+void __thiscall IVRCompositor_027_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eTimingMode);
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_SubmitExplicitTimingData(void *_this)
+EVRCompositorError __thiscall IVRCompositor_027_SubmitExplicitTimingData(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVRCompositor_026_IsMotionSmoothingEnabled(void *_this)
+bool __thiscall IVRCompositor_027_IsMotionSmoothingEnabled(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVRCompositor_026_IsMotionSmoothingSupported(void *_this)
+bool __thiscall IVRCompositor_027_IsMotionSmoothingSupported(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVRCompositor_026_IsCurrentSceneFocusAppLoading(void *_this)
+bool __thiscall IVRCompositor_027_IsCurrentSceneFocusAppLoading(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings)
+EVRCompositorError __thiscall IVRCompositor_027_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchRenderModelPath);
@@ -1210,12 +1210,12 @@ EVRCompositorError __thiscall IVRCompositor_026_SetStageOverride_Async(void *_th
     return 0;
 }
 
-void __thiscall IVRCompositor_026_ClearStageOverride(void *_this)
+void __thiscall IVRCompositor_027_ClearStageOverride(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-bool __thiscall IVRCompositor_026_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults)
+bool __thiscall IVRCompositor_027_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pBenchmarkResults);
@@ -1223,7 +1223,7 @@ bool __thiscall IVRCompositor_026_GetCompositorBenchmarkResults(void *_this, Com
     return 0;
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID)
+EVRCompositorError __thiscall IVRCompositor_027_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pRenderPosePredictionID);
@@ -1231,7 +1231,7 @@ EVRCompositorError __thiscall IVRCompositor_026_GetLastPosePredictionIDs(void *_
     return 0;
 }
 
-EVRCompositorError __thiscall IVRCompositor_026_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
+EVRCompositorError __thiscall IVRCompositor_027_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unPosePredictionID);
@@ -1318,7 +1318,7 @@ EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_t
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+EVROverlayError __thiscall IVROverlay_025_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchOverlayKey);
@@ -1326,7 +1326,7 @@ EVROverlayError __thiscall IVROverlay_024_FindOverlay(void *_this, const char *
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+EVROverlayError __thiscall IVROverlay_025_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchOverlayKey);
@@ -1335,14 +1335,14 @@ EVROverlayError __thiscall IVROverlay_024_CreateOverlay(void *_this, const char
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_025_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_024_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+uint32_t __thiscall IVROverlay_025_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1352,7 +1352,7 @@ uint32_t __thiscall IVROverlay_024_GetOverlayKey(void *_this, VROverlayHandle_t
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_024_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+uint32_t __thiscall IVROverlay_025_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1362,7 +1362,7 @@ uint32_t __thiscall IVROverlay_024_GetOverlayName(void *_this, VROverlayHandle_t
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1370,7 +1370,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayName(void *_this, VROverlayH
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1381,14 +1381,14 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayImageData(void *_this, VROve
     return 0;
 }
 
-const char * __thiscall IVROverlay_024_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+const char * __thiscall IVROverlay_025_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(error);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1396,14 +1396,14 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayRenderingPid(void *_this, VR
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_024_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+uint32_t __thiscall IVROverlay_025_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1412,7 +1412,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayFlag(void *_this, VROverlayH
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1421,7 +1421,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayFlag(void *_this, VROverlayH
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1429,7 +1429,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayFlags(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1439,7 +1439,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayColor(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1449,7 +1449,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayColor(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1457,7 +1457,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayAlpha(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1465,7 +1465,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayAlpha(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1473,7 +1473,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTexelAspect(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1481,7 +1481,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTexelAspect(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+EVROverlayError __thiscall IVROverlay_025_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1489,7 +1489,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlaySortOrder(void *_this, VROve
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+EVROverlayError __thiscall IVROverlay_025_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1497,7 +1497,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlaySortOrder(void *_this, VROve
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1505,7 +1505,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayWidthInMeters(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1513,7 +1513,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayWidthInMeters(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1521,7 +1521,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayCurvature(void *_this, VROve
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1529,7 +1529,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayCurvature(void *_this, VROve
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1537,7 +1537,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureColorSpace(void *_thi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1545,7 +1545,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureColorSpace(void *_thi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1553,7 +1553,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureBounds(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1561,7 +1561,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureBounds(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1569,7 +1569,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformType(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1578,7 +1578,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformAbsolute(void *_thi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1587,7 +1587,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformAbsolute(void *_thi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1596,7 +1596,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceRelati
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1605,7 +1605,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceRelati
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1614,7 +1614,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceCompon
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1624,7 +1624,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceCompon
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1633,7 +1633,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformOverlayRelative(voi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1642,7 +1642,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformOverlayRelative(voi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulCursorOverlayHandle);
@@ -1650,7 +1650,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformCursor(void *_this,
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1658,28 +1658,39 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformCursor(void *_this,
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    push_ptr_parameter(pProjection);
+    push_uint32_parameter(eEye);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_025_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-bool __thiscall IVROverlay_024_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_025_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+bool __thiscall IVROverlay_025_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_025_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1689,7 +1700,7 @@ EVROverlayError __thiscall IVROverlay_024_GetTransformForOverlayCoordinates(void
     return 0;
 }
 
-bool __thiscall IVROverlay_024_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+bool __thiscall IVROverlay_025_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1698,7 +1709,7 @@ bool __thiscall IVROverlay_024_PollNextOverlayEvent(void *_this, VROverlayHandle
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1706,7 +1717,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayInputMethod(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1714,7 +1725,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayInputMethod(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1722,7 +1733,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayMouseScale(void *_this, VROv
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1730,7 +1741,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayMouseScale(void *_this, VROv
     return 0;
 }
 
-bool __thiscall IVROverlay_024_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+bool __thiscall IVROverlay_025_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1739,14 +1750,14 @@ bool __thiscall IVROverlay_024_ComputeOverlayIntersection(void *_this, VROverlay
     return 0;
 }
 
-bool __thiscall IVROverlay_024_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+bool __thiscall IVROverlay_025_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1756,7 +1767,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayIntersectionMask(void *_this
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
+EVROverlayError __thiscall IVROverlay_025_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1766,7 +1777,7 @@ EVROverlayError __thiscall IVROverlay_024_TriggerLaserMouseHapticVibration(void
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1774,7 +1785,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayCursor(void *_this, VROverla
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1782,14 +1793,14 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayCursorPositionOverride(void
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_025_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1797,14 +1808,14 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayTexture(void *_this, VROverl
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_025_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1815,7 +1826,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayRaw(void *_this, VROverlayHa
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+EVROverlayError __thiscall IVROverlay_025_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1823,7 +1834,7 @@ EVROverlayError __thiscall IVROverlay_024_SetOverlayFromFile(void *_this, VROver
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_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_025_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)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1838,7 +1849,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTexture(void *_this, VROverl
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+EVROverlayError __thiscall IVROverlay_025_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1846,7 +1857,7 @@ EVROverlayError __thiscall IVROverlay_024_ReleaseNativeOverlayHandle(void *_this
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1855,7 +1866,7 @@ EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureSize(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+EVROverlayError __thiscall IVROverlay_025_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchOverlayKey);
@@ -1865,20 +1876,20 @@ EVROverlayError __thiscall IVROverlay_024_CreateDashboardOverlay(void *_this, co
     return 0;
 }
 
-bool __thiscall IVROverlay_024_IsDashboardVisible(void *_this)
+bool __thiscall IVROverlay_025_IsDashboardVisible(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVROverlay_024_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+bool __thiscall IVROverlay_025_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+EVROverlayError __thiscall IVROverlay_025_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1886,7 +1897,7 @@ EVROverlayError __thiscall IVROverlay_024_SetDashboardOverlaySceneProcess(void *
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+EVROverlayError __thiscall IVROverlay_025_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1894,19 +1905,19 @@ EVROverlayError __thiscall IVROverlay_024_GetDashboardOverlaySceneProcess(void *
     return 0;
 }
 
-void __thiscall IVROverlay_024_ShowDashboard(void *_this, const char * pchOverlayToShow)
+void __thiscall IVROverlay_025_ShowDashboard(void *_this, const char * pchOverlayToShow)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchOverlayToShow);
 }
 
-TrackedDeviceIndex_t __thiscall IVROverlay_024_GetPrimaryDashboardDevice(void *_this)
+TrackedDeviceIndex_t __thiscall IVROverlay_025_GetPrimaryDashboardDevice(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_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_025_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eInputMode);
@@ -1919,7 +1930,7 @@ EVROverlayError __thiscall IVROverlay_024_ShowKeyboard(void *_this, EGamepadText
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_024_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_025_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)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1933,7 +1944,7 @@ EVROverlayError __thiscall IVROverlay_024_ShowKeyboardForOverlay(void *_this, VR
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_024_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+uint32_t __thiscall IVROverlay_025_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchText);
@@ -1941,26 +1952,26 @@ uint32_t __thiscall IVROverlay_024_GetKeyboardText(void *_this, char * pchText,
     return 0;
 }
 
-void __thiscall IVROverlay_024_HideKeyboard(void *_this)
+void __thiscall IVROverlay_025_HideKeyboard(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVROverlay_024_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+void __thiscall IVROverlay_025_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eTrackingOrigin);
     push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
 }
 
-void __thiscall IVROverlay_024_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+void __thiscall IVROverlay_025_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     push_HmdRect2_parameter(avoidRect);
 }
 
-VRMessageOverlayResponse __thiscall IVROverlay_024_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+VRMessageOverlayResponse __thiscall IVROverlay_025_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchText);
@@ -1972,7 +1983,7 @@ VRMessageOverlayResponse __thiscall IVROverlay_024_ShowMessageOverlay(void *_thi
     return 0;
 }
 
-void __thiscall IVROverlay_024_CloseMessageOverlay(void *_this)
+void __thiscall IVROverlay_025_CloseMessageOverlay(void *_this)
 {
     push_ptr_parameter(_this);
 }
@@ -2834,6 +2845,1014 @@ const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRIn
     return 0;
 }
 
+void __thiscall IVRCompositor_026_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+}
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_026_GetTrackingSpace(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPoseArray);
+    push_uint32_parameter(unRenderPoseArrayCount);
+    push_ptr_parameter(pGamePoseArray);
+    push_uint32_parameter(unGamePoseArrayCount);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pOutputGamePose);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pTexture);
+    push_ptr_parameter(pBounds);
+    push_uint32_parameter(nSubmitFlags);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_ClearLastSubmittedFrame(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_026_PostPresentHandoff(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_026_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(unFramesAgo);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_026_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTiming);
+    push_uint32_parameter(nFrames);
+    return 0;
+}
+
+float __thiscall IVRCompositor_026_GetFrameTimeRemaining(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pStats);
+    push_uint32_parameter(nStatsSizeInBytes);
+}
+
+void __thiscall IVRCompositor_026_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    push_float_parameter(fAlpha);
+    push_bool_parameter(bBackground);
+}
+
+HmdColor_t *__thiscall IVRCompositor_026_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_bool_parameter(bBackground);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_FadeGrid(void *_this, float fSeconds, bool bFadeIn)
+{
+    push_ptr_parameter(_this);
+    push_float_parameter(fSeconds);
+    push_bool_parameter(bFadeIn);
+}
+
+float __thiscall IVRCompositor_026_GetCurrentGridAlpha(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pTextures);
+    push_uint32_parameter(unTextureCount);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_ClearSkyboxOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_026_CompositorBringToFront(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_026_CompositorGoToBack(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_026_CompositorQuit(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_026_IsFullscreen(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_026_GetCurrentSceneFocusProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_026_GetLastFrameRenderer(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_026_CanRenderScene(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_ShowMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_026_HideMirrorWindow(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_026_IsMirrorWindowVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_CompositorDumpImages(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_026_ShouldAppRenderWithLowResources(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_ForceInterleavedReprojectionOn(void *_this, bool bOverride)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bOverride);
+}
+
+void __thiscall IVRCompositor_026_ForceReconnectProcess(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRCompositor_026_SuspendRendering(void *_this, bool bSuspend)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bSuspend);
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pD3D11DeviceOrResource);
+    push_ptr_parameter(ppD3D11ShaderResourceView);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pD3D11ShaderResourceView);
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pglTextureId);
+    push_ptr_parameter(pglSharedTextureHandle);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_026_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(glTextureId);
+    push_ptr_parameter(glSharedTextureHandle);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+void __thiscall IVRCompositor_026_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(glSharedTextureHandle);
+}
+
+uint32_t __thiscall IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+uint32_t __thiscall IVRCompositor_026_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pPhysicalDevice);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTimingMode);
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_SubmitExplicitTimingData(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_026_IsMotionSmoothingEnabled(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_026_IsMotionSmoothingSupported(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRCompositor_026_IsCurrentSceneFocusAppLoading(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchRenderModelPath);
+    push_ptr_parameter(pTransform);
+    push_ptr_parameter(pRenderSettings);
+    push_uint32_parameter(nSizeOfRenderSettings);
+    return 0;
+}
+
+void __thiscall IVRCompositor_026_ClearStageOverride(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+bool __thiscall IVRCompositor_026_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pBenchmarkResults);
+    push_uint32_parameter(nSizeOfBenchmarkResults);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pRenderPosePredictionID);
+    push_ptr_parameter(pGamePosePredictionID);
+    return 0;
+}
+
+EVRCompositorError __thiscall IVRCompositor_026_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unPosePredictionID);
+    push_ptr_parameter(pPoseArray);
+    push_uint32_parameter(unPoseArrayCount);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayName);
+    push_ptr_parameter(pOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_024_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_024_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(punWidth);
+    push_ptr_parameter(punHeight);
+    return 0;
+}
+
+const char * __thiscall IVROverlay_024_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unPID);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_024_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_bool_parameter(bEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eOverlayFlag);
+    push_ptr_parameter(pbEnabled);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pFlags);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fRed);
+    push_float_parameter(fGreen);
+    push_float_parameter(fBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfRed);
+    push_ptr_parameter(pfGreen);
+    push_ptr_parameter(pfBlue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfAlpha);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfTexelAspect);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punSortOrder);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfWidthInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fCurvature);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfCurvature);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTextureColorSpace);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTransformType);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punTrackedDevice);
+    push_ptr_parameter(pmatTrackedDeviceToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punDeviceIndex);
+    push_ptr_parameter(pchComponentName);
+    push_uint32_parameter(unComponentNameSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(ulOverlayHandleParent);
+    push_ptr_parameter(pmatParentOverlayToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint64_parameter(ulOverlayHandleParent);
+    push_ptr_parameter(pmatParentOverlayToOverlayTransform);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulCursorOverlayHandle);
+    push_ptr_parameter(pvHotspot);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvHotspot);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_024_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eTrackingOrigin);
+    push_HmdVector2_parameter(coordinatesInOverlay);
+    push_ptr_parameter(pmatTransform);
+    return 0;
+}
+
+bool __thiscall IVROverlay_024_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(peInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMethod);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvecMouseScale);
+    return 0;
+}
+
+bool __thiscall IVROverlay_024_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pParams);
+    push_ptr_parameter(pResults);
+    return 0;
+}
+
+bool __thiscall IVROverlay_024_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pMaskPrimitives);
+    push_uint32_parameter(unNumMaskPrimitives);
+    push_uint32_parameter(unPrimitiveSize);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fDurationSeconds);
+    push_float_parameter(fFrequency);
+    push_float_parameter(fAmplitude);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint64_parameter(ulCursorHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvCursor);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pTexture);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unBytesPerPixel);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchFilePath);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_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)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    push_ptr_parameter(pNativeTextureRef);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    push_ptr_parameter(pNativeFormat);
+    push_ptr_parameter(pAPIType);
+    push_ptr_parameter(pColorSpace);
+    push_ptr_parameter(pTextureBounds);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pNativeTextureHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pWidth);
+    push_ptr_parameter(pHeight);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayKey);
+    push_ptr_parameter(pchOverlayFriendlyName);
+    push_ptr_parameter(pMainHandle);
+    push_ptr_parameter(pThumbnailHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_024_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_024_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(unProcessId);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(punProcessId);
+    return 0;
+}
+
+void __thiscall IVROverlay_024_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_024_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_uint32_parameter(unFlags);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_024_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)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_uint32_parameter(unFlags);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_024_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_uint32_parameter(cchText);
+    return 0;
+}
+
+void __thiscall IVROverlay_024_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_024_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_024_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+VRMessageOverlayResponse __thiscall IVROverlay_024_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchText);
+    push_ptr_parameter(pchCaption);
+    push_ptr_parameter(pchButton0Text);
+    push_ptr_parameter(pchButton1Text);
+    push_ptr_parameter(pchButton2Text);
+    push_ptr_parameter(pchButton3Text);
+    return 0;
+}
+
+void __thiscall IVROverlay_024_CloseMessageOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
 void __thiscall IVRSystem_021_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
 {
     push_ptr_parameter(_this);
diff --git a/vrclient_x64/tests/capi_thunks_autogen.h b/vrclient_x64/tests/capi_thunks_autogen.h
index 683ac660..d96fd9a3 100644
--- a/vrclient_x64/tests/capi_thunks_autogen.h
+++ b/vrclient_x64/tests/capi_thunks_autogen.h
@@ -253,109 +253,109 @@ void __thiscall IVRChaperoneSetup_006_HideWorkingSetPreview(void *_this);
 
 void __thiscall IVRChaperoneSetup_006_RoomSetupStarting(void *_this);
 
-void test_capi_thunks_IVRCompositor_026(void);
+void test_capi_thunks_IVRCompositor_027(void);
 
-void __thiscall IVRCompositor_026_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+void __thiscall IVRCompositor_027_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
 
-ETrackingUniverseOrigin __thiscall IVRCompositor_026_GetTrackingSpace(void *_this);
+ETrackingUniverseOrigin __thiscall IVRCompositor_027_GetTrackingSpace(void *_this);
 
-EVRCompositorError __thiscall IVRCompositor_026_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+EVRCompositorError __thiscall IVRCompositor_027_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
 
-EVRCompositorError __thiscall IVRCompositor_026_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+EVRCompositorError __thiscall IVRCompositor_027_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
 
-EVRCompositorError __thiscall IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+EVRCompositorError __thiscall IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
 
-EVRCompositorError __thiscall IVRCompositor_026_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+EVRCompositorError __thiscall IVRCompositor_027_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
 
-void __thiscall IVRCompositor_026_ClearLastSubmittedFrame(void *_this);
+void __thiscall IVRCompositor_027_ClearLastSubmittedFrame(void *_this);
 
-void __thiscall IVRCompositor_026_PostPresentHandoff(void *_this);
+void __thiscall IVRCompositor_027_PostPresentHandoff(void *_this);
 
-bool __thiscall IVRCompositor_026_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+bool __thiscall IVRCompositor_027_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
 
-uint32_t __thiscall IVRCompositor_026_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
+uint32_t __thiscall IVRCompositor_027_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
 
-float __thiscall IVRCompositor_026_GetFrameTimeRemaining(void *_this);
+float __thiscall IVRCompositor_027_GetFrameTimeRemaining(void *_this);
 
-void __thiscall IVRCompositor_026_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+void __thiscall IVRCompositor_027_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
 
-void __thiscall IVRCompositor_026_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+void __thiscall IVRCompositor_027_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
 
-HmdColor_t *__thiscall IVRCompositor_026_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
+HmdColor_t *__thiscall IVRCompositor_027_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
 
-void __thiscall IVRCompositor_026_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+void __thiscall IVRCompositor_027_FadeGrid(void *_this, float fSeconds, bool bFadeGridIn);
 
-float __thiscall IVRCompositor_026_GetCurrentGridAlpha(void *_this);
+float __thiscall IVRCompositor_027_GetCurrentGridAlpha(void *_this);
 
-EVRCompositorError __thiscall IVRCompositor_026_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+EVRCompositorError __thiscall IVRCompositor_027_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
 
-void __thiscall IVRCompositor_026_ClearSkyboxOverride(void *_this);
+void __thiscall IVRCompositor_027_ClearSkyboxOverride(void *_this);
 
-void __thiscall IVRCompositor_026_CompositorBringToFront(void *_this);
+void __thiscall IVRCompositor_027_CompositorBringToFront(void *_this);
 
-void __thiscall IVRCompositor_026_CompositorGoToBack(void *_this);
+void __thiscall IVRCompositor_027_CompositorGoToBack(void *_this);
 
-void __thiscall IVRCompositor_026_CompositorQuit(void *_this);
+void __thiscall IVRCompositor_027_CompositorQuit(void *_this);
 
-bool __thiscall IVRCompositor_026_IsFullscreen(void *_this);
+bool __thiscall IVRCompositor_027_IsFullscreen(void *_this);
 
-uint32_t __thiscall IVRCompositor_026_GetCurrentSceneFocusProcess(void *_this);
+uint32_t __thiscall IVRCompositor_027_GetCurrentSceneFocusProcess(void *_this);
 
-uint32_t __thiscall IVRCompositor_026_GetLastFrameRenderer(void *_this);
+uint32_t __thiscall IVRCompositor_027_GetLastFrameRenderer(void *_this);
 
-bool __thiscall IVRCompositor_026_CanRenderScene(void *_this);
+bool __thiscall IVRCompositor_027_CanRenderScene(void *_this);
 
-void __thiscall IVRCompositor_026_ShowMirrorWindow(void *_this);
+void __thiscall IVRCompositor_027_ShowMirrorWindow(void *_this);
 
-void __thiscall IVRCompositor_026_HideMirrorWindow(void *_this);
+void __thiscall IVRCompositor_027_HideMirrorWindow(void *_this);
 
-bool __thiscall IVRCompositor_026_IsMirrorWindowVisible(void *_this);
+bool __thiscall IVRCompositor_027_IsMirrorWindowVisible(void *_this);
 
-void __thiscall IVRCompositor_026_CompositorDumpImages(void *_this);
+void __thiscall IVRCompositor_027_CompositorDumpImages(void *_this);
 
-bool __thiscall IVRCompositor_026_ShouldAppRenderWithLowResources(void *_this);
+bool __thiscall IVRCompositor_027_ShouldAppRenderWithLowResources(void *_this);
 
-void __thiscall IVRCompositor_026_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+void __thiscall IVRCompositor_027_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
 
-void __thiscall IVRCompositor_026_ForceReconnectProcess(void *_this);
+void __thiscall IVRCompositor_027_ForceReconnectProcess(void *_this);
 
-void __thiscall IVRCompositor_026_SuspendRendering(void *_this, bool bSuspend);
+void __thiscall IVRCompositor_027_SuspendRendering(void *_this, bool bSuspend);
 
-EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+EVRCompositorError __thiscall IVRCompositor_027_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
 
-void __thiscall IVRCompositor_026_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
+void __thiscall IVRCompositor_027_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
 
-EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+EVRCompositorError __thiscall IVRCompositor_027_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
 
-bool __thiscall IVRCompositor_026_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+bool __thiscall IVRCompositor_027_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
 
-void __thiscall IVRCompositor_026_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+void __thiscall IVRCompositor_027_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
 
-void __thiscall IVRCompositor_026_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+void __thiscall IVRCompositor_027_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
 
-uint32_t __thiscall IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
+uint32_t __thiscall IVRCompositor_027_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
 
-uint32_t __thiscall IVRCompositor_026_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
+uint32_t __thiscall IVRCompositor_027_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
 
-void __thiscall IVRCompositor_026_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode);
+void __thiscall IVRCompositor_027_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode);
 
-EVRCompositorError __thiscall IVRCompositor_026_SubmitExplicitTimingData(void *_this);
+EVRCompositorError __thiscall IVRCompositor_027_SubmitExplicitTimingData(void *_this);
 
-bool __thiscall IVRCompositor_026_IsMotionSmoothingEnabled(void *_this);
+bool __thiscall IVRCompositor_027_IsMotionSmoothingEnabled(void *_this);
 
-bool __thiscall IVRCompositor_026_IsMotionSmoothingSupported(void *_this);
+bool __thiscall IVRCompositor_027_IsMotionSmoothingSupported(void *_this);
 
-bool __thiscall IVRCompositor_026_IsCurrentSceneFocusAppLoading(void *_this);
+bool __thiscall IVRCompositor_027_IsCurrentSceneFocusAppLoading(void *_this);
 
-EVRCompositorError __thiscall IVRCompositor_026_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings);
+EVRCompositorError __thiscall IVRCompositor_027_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings);
 
-void __thiscall IVRCompositor_026_ClearStageOverride(void *_this);
+void __thiscall IVRCompositor_027_ClearStageOverride(void *_this);
 
-bool __thiscall IVRCompositor_026_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults);
+bool __thiscall IVRCompositor_027_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults);
 
-EVRCompositorError __thiscall IVRCompositor_026_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID);
+EVRCompositorError __thiscall IVRCompositor_027_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID);
 
-EVRCompositorError __thiscall IVRCompositor_026_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
+EVRCompositorError __thiscall IVRCompositor_027_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
 
 void test_capi_thunks_IVRHeadsetView_001(void);
 
@@ -383,163 +383,165 @@ EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_t
 
 EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
 
-void test_capi_thunks_IVROverlay_024(void);
+void test_capi_thunks_IVROverlay_025(void);
 
-EVROverlayError __thiscall IVROverlay_024_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+EVROverlayError __thiscall IVROverlay_025_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_024_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+EVROverlayError __thiscall IVROverlay_025_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_024_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_025_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-uint32_t __thiscall IVROverlay_024_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+uint32_t __thiscall IVROverlay_025_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
 
-uint32_t __thiscall IVROverlay_024_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+uint32_t __thiscall IVROverlay_025_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
 
-const char * __thiscall IVROverlay_024_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+const char * __thiscall IVROverlay_025_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
 
-uint32_t __thiscall IVROverlay_024_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+uint32_t __thiscall IVROverlay_025_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+EVROverlayError __thiscall IVROverlay_025_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+EVROverlayError __thiscall IVROverlay_025_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
 
-EVROverlayError __thiscall IVROverlay_024_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTransformProjection(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye);
 
-EVROverlayError __thiscall IVROverlay_024_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_025_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-bool __thiscall IVROverlay_024_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_025_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_024_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+bool __thiscall IVROverlay_025_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-bool __thiscall IVROverlay_024_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+EVROverlayError __thiscall IVROverlay_025_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+bool __thiscall IVROverlay_025_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
 
-EVROverlayError __thiscall IVROverlay_024_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
 
-bool __thiscall IVROverlay_024_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
 
-bool __thiscall IVROverlay_024_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+bool __thiscall IVROverlay_025_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+bool __thiscall IVROverlay_025_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_024_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
+EVROverlayError __thiscall IVROverlay_025_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
 
-EVROverlayError __thiscall IVROverlay_024_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+EVROverlayError __thiscall IVROverlay_025_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_024_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
+EVROverlayError __thiscall IVROverlay_025_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_024_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+EVROverlayError __thiscall IVROverlay_025_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
 
-EVROverlayError __thiscall IVROverlay_024_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_025_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
 
-EVROverlayError __thiscall IVROverlay_024_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+EVROverlayError __thiscall IVROverlay_025_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_024_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+EVROverlayError __thiscall IVROverlay_025_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
 
-EVROverlayError __thiscall IVROverlay_024_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+EVROverlayError __thiscall IVROverlay_025_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
 
-bool __thiscall IVROverlay_024_IsDashboardVisible(void *_this);
+EVROverlayError __thiscall IVROverlay_025_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
 
-bool __thiscall IVROverlay_024_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+bool __thiscall IVROverlay_025_IsDashboardVisible(void *_this);
 
-EVROverlayError __thiscall IVROverlay_024_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+bool __thiscall IVROverlay_025_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_024_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+EVROverlayError __thiscall IVROverlay_025_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
 
-void __thiscall IVROverlay_024_ShowDashboard(void *_this, const char * pchOverlayToShow);
+EVROverlayError __thiscall IVROverlay_025_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
 
-TrackedDeviceIndex_t __thiscall IVROverlay_024_GetPrimaryDashboardDevice(void *_this);
+void __thiscall IVROverlay_025_ShowDashboard(void *_this, const char * pchOverlayToShow);
 
-EVROverlayError __thiscall IVROverlay_024_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_025_GetPrimaryDashboardDevice(void *_this);
 
-EVROverlayError __thiscall IVROverlay_024_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_025_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_024_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+EVROverlayError __thiscall IVROverlay_025_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_024_HideKeyboard(void *_this);
+uint32_t __thiscall IVROverlay_025_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
 
-void __thiscall IVROverlay_024_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+void __thiscall IVROverlay_025_HideKeyboard(void *_this);
 
-void __thiscall IVROverlay_024_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+void __thiscall IVROverlay_025_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
 
-VRMessageOverlayResponse __thiscall IVROverlay_024_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+void __thiscall IVROverlay_025_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
 
-void __thiscall IVROverlay_024_CloseMessageOverlay(void *_this);
+VRMessageOverlayResponse __thiscall IVROverlay_025_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+
+void __thiscall IVROverlay_025_CloseMessageOverlay(void *_this);
 
 void test_capi_thunks_IVROverlayView_003(void);
 
@@ -757,6 +759,268 @@ const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_thi
 
 const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
 
+void test_capi_thunks_IVRCompositor_026(void);
+
+void __thiscall IVRCompositor_026_SetTrackingSpace(void *_this, ETrackingUniverseOrigin eOrigin);
+
+ETrackingUniverseOrigin __thiscall IVRCompositor_026_GetTrackingSpace(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_026_WaitGetPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_026_GetLastPoses(void *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+
+EVRCompositorError __thiscall IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose);
+
+EVRCompositorError __thiscall IVRCompositor_026_Submit(void *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+
+void __thiscall IVRCompositor_026_ClearLastSubmittedFrame(void *_this);
+
+void __thiscall IVRCompositor_026_PostPresentHandoff(void *_this);
+
+bool __thiscall IVRCompositor_026_GetFrameTiming(void *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+
+uint32_t __thiscall IVRCompositor_026_GetFrameTimings(void *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames);
+
+float __thiscall IVRCompositor_026_GetFrameTimeRemaining(void *_this);
+
+void __thiscall IVRCompositor_026_GetCumulativeStats(void *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+
+void __thiscall IVRCompositor_026_FadeToColor(void *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+
+HmdColor_t *__thiscall IVRCompositor_026_GetCurrentFadeColor(void *_this, HmdColor_t *_r, bool bBackground);
+
+void __thiscall IVRCompositor_026_FadeGrid(void *_this, float fSeconds, bool bFadeIn);
+
+float __thiscall IVRCompositor_026_GetCurrentGridAlpha(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_026_SetSkyboxOverride(void *_this, Texture_t * pTextures, uint32_t unTextureCount);
+
+void __thiscall IVRCompositor_026_ClearSkyboxOverride(void *_this);
+
+void __thiscall IVRCompositor_026_CompositorBringToFront(void *_this);
+
+void __thiscall IVRCompositor_026_CompositorGoToBack(void *_this);
+
+void __thiscall IVRCompositor_026_CompositorQuit(void *_this);
+
+bool __thiscall IVRCompositor_026_IsFullscreen(void *_this);
+
+uint32_t __thiscall IVRCompositor_026_GetCurrentSceneFocusProcess(void *_this);
+
+uint32_t __thiscall IVRCompositor_026_GetLastFrameRenderer(void *_this);
+
+bool __thiscall IVRCompositor_026_CanRenderScene(void *_this);
+
+void __thiscall IVRCompositor_026_ShowMirrorWindow(void *_this);
+
+void __thiscall IVRCompositor_026_HideMirrorWindow(void *_this);
+
+bool __thiscall IVRCompositor_026_IsMirrorWindowVisible(void *_this);
+
+void __thiscall IVRCompositor_026_CompositorDumpImages(void *_this);
+
+bool __thiscall IVRCompositor_026_ShouldAppRenderWithLowResources(void *_this);
+
+void __thiscall IVRCompositor_026_ForceInterleavedReprojectionOn(void *_this, bool bOverride);
+
+void __thiscall IVRCompositor_026_ForceReconnectProcess(void *_this);
+
+void __thiscall IVRCompositor_026_SuspendRendering(void *_this, bool bSuspend);
+
+EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureD3D11(void *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+
+void __thiscall IVRCompositor_026_ReleaseMirrorTextureD3D11(void *_this, void * pD3D11ShaderResourceView);
+
+EVRCompositorError __thiscall IVRCompositor_026_GetMirrorTextureGL(void *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+
+bool __thiscall IVRCompositor_026_ReleaseSharedGLTexture(void *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_026_LockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+void __thiscall IVRCompositor_026_UnlockGLSharedTextureForAccess(void *_this, glSharedTextureHandle_t glSharedTextureHandle);
+
+uint32_t __thiscall IVRCompositor_026_GetVulkanInstanceExtensionsRequired(void *_this, char * pchValue, uint32_t unBufferSize);
+
+uint32_t __thiscall IVRCompositor_026_GetVulkanDeviceExtensionsRequired(void *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
+
+void __thiscall IVRCompositor_026_SetExplicitTimingMode(void *_this, EVRCompositorTimingMode eTimingMode);
+
+EVRCompositorError __thiscall IVRCompositor_026_SubmitExplicitTimingData(void *_this);
+
+bool __thiscall IVRCompositor_026_IsMotionSmoothingEnabled(void *_this);
+
+bool __thiscall IVRCompositor_026_IsMotionSmoothingSupported(void *_this);
+
+bool __thiscall IVRCompositor_026_IsCurrentSceneFocusAppLoading(void *_this);
+
+EVRCompositorError __thiscall IVRCompositor_026_SetStageOverride_Async(void *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings);
+
+void __thiscall IVRCompositor_026_ClearStageOverride(void *_this);
+
+bool __thiscall IVRCompositor_026_GetCompositorBenchmarkResults(void *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults);
+
+EVRCompositorError __thiscall IVRCompositor_026_GetLastPosePredictionIDs(void *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID);
+
+EVRCompositorError __thiscall IVRCompositor_026_GetPosesForFrame(void *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
+
+void test_capi_thunks_IVROverlay_024(void);
+
+EVROverlayError __thiscall IVROverlay_024_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+uint32_t __thiscall IVROverlay_024_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_024_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_024_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_024_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTransformCursor(void *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTransformCursor(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot);
+
+EVROverlayError __thiscall IVROverlay_024_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_024_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_024_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_024_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_024_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+
+EVROverlayError __thiscall IVROverlay_024_TriggerLaserMouseHapticVibration(void *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayCursor(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor);
+
+EVROverlayError __thiscall IVROverlay_024_ClearOverlayCursorPositionOverride(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_024_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
+
+EVROverlayError __thiscall IVROverlay_024_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_024_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_024_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_024_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_024_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_024_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_024_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_024_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_024_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_024_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_024_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_024_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_024_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_024_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_024_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_024_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_024_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+VRMessageOverlayResponse __thiscall IVROverlay_024_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+
+void __thiscall IVROverlay_024_CloseMessageOverlay(void *_this);
+
 void test_capi_thunks_IVRSystem_021(void);
 
 void __thiscall IVRSystem_021_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
diff --git a/vrclient_x64/tests/capi_thunks_tests_autogen.c b/vrclient_x64/tests/capi_thunks_tests_autogen.c
index 0c8f287e..b69db0ba 100644
--- a/vrclient_x64/tests/capi_thunks_tests_autogen.c
+++ b/vrclient_x64/tests/capi_thunks_tests_autogen.c
@@ -1067,430 +1067,430 @@ void test_capi_thunks_IVRChaperoneSetup_006(void)
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
-void test_capi_thunks_IVRCompositor_026(void)
+void test_capi_thunks_IVRCompositor_027(void)
 {
     struct thunk *t = alloc_thunks(1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_SetTrackingSpace, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_SetTrackingSpace(1);
-    check_ptr_parameter("IVRCompositor_026_SetTrackingSpace", this_ptr_value);
-    check_uint32_parameter("IVRCompositor_026_SetTrackingSpace", 1);
+    capi_IVRCompositor_027_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_027_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_027_SetTrackingSpace", 1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetTrackingSpace, 0, FALSE, FALSE);
-    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_026_GetTrackingSpace)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_027_GetTrackingSpace)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetTrackingSpace();
-    check_ptr_parameter("IVRCompositor_026_GetTrackingSpace", this_ptr_value);
+    capi_IVRCompositor_027_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_027_GetTrackingSpace", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_WaitGetPoses, 4, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_WaitGetPoses((void *)1, 2, (void *)3, 4);
-    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", (void *)1);
-    check_uint32_parameter("IVRCompositor_026_WaitGetPoses", 2);
-    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", (void *)3);
-    check_uint32_parameter("IVRCompositor_026_WaitGetPoses", 4);
+    capi_IVRCompositor_027_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_027_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_027_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_027_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_027_WaitGetPoses", 4);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPoses, 4, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetLastPoses((void *)1, 2, (void *)3, 4);
-    check_ptr_parameter("IVRCompositor_026_GetLastPoses", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetLastPoses", (void *)1);
-    check_uint32_parameter("IVRCompositor_026_GetLastPoses", 2);
-    check_ptr_parameter("IVRCompositor_026_GetLastPoses", (void *)3);
-    check_uint32_parameter("IVRCompositor_026_GetLastPoses", 4);
+    capi_IVRCompositor_027_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_027_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_027_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_027_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_027_GetLastPoses", 4);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
-    check_uint32_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", 1);
-    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", (void *)2);
-    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", (void *)3);
+    capi_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_027_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_027_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_027_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_027_GetLastPoseForTrackedDeviceIndex", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_Submit, 4, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_Submit(1, (void *)2, (void *)3, 4);
-    check_ptr_parameter("IVRCompositor_026_Submit", this_ptr_value);
-    check_uint32_parameter("IVRCompositor_026_Submit", 1);
-    check_ptr_parameter("IVRCompositor_026_Submit", (void *)2);
-    check_ptr_parameter("IVRCompositor_026_Submit", (void *)3);
-    check_uint32_parameter("IVRCompositor_026_Submit", 4);
+    capi_IVRCompositor_027_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_027_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_027_Submit", 1);
+    check_ptr_parameter("IVRCompositor_027_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_027_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_027_Submit", 4);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearLastSubmittedFrame, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_ClearLastSubmittedFrame)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_ClearLastSubmittedFrame)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ClearLastSubmittedFrame();
-    check_ptr_parameter("IVRCompositor_026_ClearLastSubmittedFrame", this_ptr_value);
+    capi_IVRCompositor_027_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_027_ClearLastSubmittedFrame", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_PostPresentHandoff, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_PostPresentHandoff)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_PostPresentHandoff)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_PostPresentHandoff();
-    check_ptr_parameter("IVRCompositor_026_PostPresentHandoff", this_ptr_value);
+    capi_IVRCompositor_027_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_027_PostPresentHandoff", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTiming, 2, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetFrameTiming((void *)1, 2);
-    check_ptr_parameter("IVRCompositor_026_GetFrameTiming", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetFrameTiming", (void *)1);
-    check_uint32_parameter("IVRCompositor_026_GetFrameTiming", 2);
+    capi_IVRCompositor_027_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_027_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_027_GetFrameTiming", 2);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTimings, 2, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRCompositor_026_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetFrameTimings, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_027_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetFrameTimings((void *)1, 2);
-    check_ptr_parameter("IVRCompositor_026_GetFrameTimings", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetFrameTimings", (void *)1);
-    check_uint32_parameter("IVRCompositor_026_GetFrameTimings", 2);
+    capi_IVRCompositor_027_GetFrameTimings((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_027_GetFrameTimings", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetFrameTimings", (void *)1);
+    check_uint32_parameter("IVRCompositor_027_GetFrameTimings", 2);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTimeRemaining, 0, FALSE, FALSE);
-    float (__stdcall *capi_IVRCompositor_026_GetFrameTimeRemaining)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_027_GetFrameTimeRemaining)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetFrameTimeRemaining();
-    check_ptr_parameter("IVRCompositor_026_GetFrameTimeRemaining", this_ptr_value);
+    capi_IVRCompositor_027_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_027_GetFrameTimeRemaining", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCumulativeStats, 2, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetCumulativeStats((void *)1, 2);
-    check_ptr_parameter("IVRCompositor_026_GetCumulativeStats", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetCumulativeStats", (void *)1);
-    check_uint32_parameter("IVRCompositor_026_GetCumulativeStats", 2);
+    capi_IVRCompositor_027_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_027_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_027_GetCumulativeStats", 2);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_FadeToColor, 6, TRUE, TRUE);
-    void (__stdcall *capi_IVRCompositor_026_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_027_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
-    check_ptr_parameter("IVRCompositor_026_FadeToColor", this_ptr_value);
-    check_float_parameter("IVRCompositor_026_FadeToColor", 1.0f);
-    check_float_parameter("IVRCompositor_026_FadeToColor", 2.0f);
-    check_float_parameter("IVRCompositor_026_FadeToColor", 3.0f);
-    check_float_parameter("IVRCompositor_026_FadeToColor", 4.0f);
-    check_float_parameter("IVRCompositor_026_FadeToColor", 5.0f);
-    check_bool_parameter("IVRCompositor_026_FadeToColor", 1);
+    capi_IVRCompositor_027_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_027_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_027_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_027_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_027_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_027_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_027_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_027_FadeToColor", 1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentFadeColor, 2, FALSE, FALSE);
-    HmdColor_t *(__stdcall *capi_IVRCompositor_026_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCurrentFadeColor, 2, FALSE, FALSE);
+    HmdColor_t *(__stdcall *capi_IVRCompositor_027_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetCurrentFadeColor(data_ptr_value, 1);
-    check_ptr_parameter("IVRCompositor_026_GetCurrentFadeColor", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetCurrentFadeColor", data_ptr_value);
-    check_bool_parameter("IVRCompositor_026_GetCurrentFadeColor", 1);
+    capi_IVRCompositor_027_GetCurrentFadeColor(data_ptr_value, 1);
+    check_ptr_parameter("IVRCompositor_027_GetCurrentFadeColor", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetCurrentFadeColor", data_ptr_value);
+    check_bool_parameter("IVRCompositor_027_GetCurrentFadeColor", 1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_FadeGrid, 2, TRUE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_FadeGrid)(float fSeconds, bool bFadeGridIn) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_FadeGrid(1.0f, 1);
-    check_ptr_parameter("IVRCompositor_026_FadeGrid", this_ptr_value);
-    check_float_parameter("IVRCompositor_026_FadeGrid", 1.0f);
-    check_bool_parameter("IVRCompositor_026_FadeGrid", 1);
+    capi_IVRCompositor_027_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_027_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_027_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_027_FadeGrid", 1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentGridAlpha, 0, FALSE, FALSE);
-    float (__stdcall *capi_IVRCompositor_026_GetCurrentGridAlpha)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_027_GetCurrentGridAlpha)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetCurrentGridAlpha();
-    check_ptr_parameter("IVRCompositor_026_GetCurrentGridAlpha", this_ptr_value);
+    capi_IVRCompositor_027_GetCurrentGridAlpha();
+    check_ptr_parameter("IVRCompositor_027_GetCurrentGridAlpha", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_SetSkyboxOverride, 2, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_SetSkyboxOverride((void *)1, 2);
-    check_ptr_parameter("IVRCompositor_026_SetSkyboxOverride", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_SetSkyboxOverride", (void *)1);
-    check_uint32_parameter("IVRCompositor_026_SetSkyboxOverride", 2);
+    capi_IVRCompositor_027_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_027_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_027_SetSkyboxOverride", 2);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearSkyboxOverride, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_ClearSkyboxOverride)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_ClearSkyboxOverride)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ClearSkyboxOverride();
-    check_ptr_parameter("IVRCompositor_026_ClearSkyboxOverride", this_ptr_value);
+    capi_IVRCompositor_027_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_027_ClearSkyboxOverride", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorBringToFront, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_CompositorBringToFront)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_CompositorBringToFront)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_CompositorBringToFront();
-    check_ptr_parameter("IVRCompositor_026_CompositorBringToFront", this_ptr_value);
+    capi_IVRCompositor_027_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_027_CompositorBringToFront", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorGoToBack, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_CompositorGoToBack)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_CompositorGoToBack)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_CompositorGoToBack();
-    check_ptr_parameter("IVRCompositor_026_CompositorGoToBack", this_ptr_value);
+    capi_IVRCompositor_027_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_027_CompositorGoToBack", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorQuit, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_CompositorQuit)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_CompositorQuit)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_CompositorQuit();
-    check_ptr_parameter("IVRCompositor_026_CompositorQuit", this_ptr_value);
+    capi_IVRCompositor_027_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_027_CompositorQuit", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_IsFullscreen, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_IsFullscreen)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_IsFullscreen)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_IsFullscreen();
-    check_ptr_parameter("IVRCompositor_026_IsFullscreen", this_ptr_value);
+    capi_IVRCompositor_027_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_027_IsFullscreen", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRCompositor_026_GetCurrentSceneFocusProcess)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_027_GetCurrentSceneFocusProcess)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetCurrentSceneFocusProcess();
-    check_ptr_parameter("IVRCompositor_026_GetCurrentSceneFocusProcess", this_ptr_value);
+    capi_IVRCompositor_027_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_027_GetCurrentSceneFocusProcess", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastFrameRenderer, 0, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRCompositor_026_GetLastFrameRenderer)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_027_GetLastFrameRenderer)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetLastFrameRenderer();
-    check_ptr_parameter("IVRCompositor_026_GetLastFrameRenderer", this_ptr_value);
+    capi_IVRCompositor_027_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_027_GetLastFrameRenderer", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_CanRenderScene, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_CanRenderScene)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_CanRenderScene)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_CanRenderScene();
-    check_ptr_parameter("IVRCompositor_026_CanRenderScene", this_ptr_value);
+    capi_IVRCompositor_027_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_027_CanRenderScene", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ShowMirrorWindow, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_ShowMirrorWindow)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_ShowMirrorWindow)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ShowMirrorWindow();
-    check_ptr_parameter("IVRCompositor_026_ShowMirrorWindow", this_ptr_value);
+    capi_IVRCompositor_027_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_027_ShowMirrorWindow", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_HideMirrorWindow, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_HideMirrorWindow)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_HideMirrorWindow)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_HideMirrorWindow();
-    check_ptr_parameter("IVRCompositor_026_HideMirrorWindow", this_ptr_value);
+    capi_IVRCompositor_027_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_027_HideMirrorWindow", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMirrorWindowVisible, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_IsMirrorWindowVisible)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_IsMirrorWindowVisible)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_IsMirrorWindowVisible();
-    check_ptr_parameter("IVRCompositor_026_IsMirrorWindowVisible", this_ptr_value);
+    capi_IVRCompositor_027_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_027_IsMirrorWindowVisible", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorDumpImages, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_CompositorDumpImages)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_CompositorDumpImages)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_CompositorDumpImages();
-    check_ptr_parameter("IVRCompositor_026_CompositorDumpImages", this_ptr_value);
+    capi_IVRCompositor_027_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_027_CompositorDumpImages", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_ShouldAppRenderWithLowResources)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_ShouldAppRenderWithLowResources)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ShouldAppRenderWithLowResources();
-    check_ptr_parameter("IVRCompositor_026_ShouldAppRenderWithLowResources", this_ptr_value);
+    capi_IVRCompositor_027_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_027_ShouldAppRenderWithLowResources", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ForceInterleavedReprojectionOn(1);
-    check_ptr_parameter("IVRCompositor_026_ForceInterleavedReprojectionOn", this_ptr_value);
-    check_bool_parameter("IVRCompositor_026_ForceInterleavedReprojectionOn", 1);
+    capi_IVRCompositor_027_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_027_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_027_ForceInterleavedReprojectionOn", 1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ForceReconnectProcess, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_ForceReconnectProcess)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_ForceReconnectProcess)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ForceReconnectProcess();
-    check_ptr_parameter("IVRCompositor_026_ForceReconnectProcess", this_ptr_value);
+    capi_IVRCompositor_027_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_027_ForceReconnectProcess", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_SuspendRendering, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_SuspendRendering)(bool bSuspend) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_SuspendRendering)(bool bSuspend) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_SuspendRendering(1);
-    check_ptr_parameter("IVRCompositor_026_SuspendRendering", this_ptr_value);
-    check_bool_parameter("IVRCompositor_026_SuspendRendering", 1);
+    capi_IVRCompositor_027_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_027_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_027_SuspendRendering", 1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetMirrorTextureD3D11, 3, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", this_ptr_value);
-    check_uint32_parameter("IVRCompositor_026_GetMirrorTextureD3D11", 1);
-    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", (void *)2);
-    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", (void *)3);
+    capi_IVRCompositor_027_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_027_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureD3D11", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ReleaseMirrorTextureD3D11((void *)1);
-    check_ptr_parameter("IVRCompositor_026_ReleaseMirrorTextureD3D11", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_ReleaseMirrorTextureD3D11", (void *)1);
+    capi_IVRCompositor_027_ReleaseMirrorTextureD3D11((void *)1);
+    check_ptr_parameter("IVRCompositor_027_ReleaseMirrorTextureD3D11", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_ReleaseMirrorTextureD3D11", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetMirrorTextureGL, 3, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetMirrorTextureGL(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", this_ptr_value);
-    check_uint32_parameter("IVRCompositor_026_GetMirrorTextureGL", 1);
-    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", (void *)2);
-    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", (void *)3);
+    capi_IVRCompositor_027_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_027_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_027_GetMirrorTextureGL", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ReleaseSharedGLTexture, 2, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ReleaseSharedGLTexture(1, (void *)2);
-    check_ptr_parameter("IVRCompositor_026_ReleaseSharedGLTexture", this_ptr_value);
-    check_uint32_parameter("IVRCompositor_026_ReleaseSharedGLTexture", 1);
-    check_ptr_parameter("IVRCompositor_026_ReleaseSharedGLTexture", (void *)2);
+    capi_IVRCompositor_027_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_027_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_027_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_027_ReleaseSharedGLTexture", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_LockGLSharedTextureForAccess((void *)1);
-    check_ptr_parameter("IVRCompositor_026_LockGLSharedTextureForAccess", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_LockGLSharedTextureForAccess", (void *)1);
+    capi_IVRCompositor_027_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_027_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_LockGLSharedTextureForAccess", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_UnlockGLSharedTextureForAccess((void *)1);
-    check_ptr_parameter("IVRCompositor_026_UnlockGLSharedTextureForAccess", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_UnlockGLSharedTextureForAccess", (void *)1);
+    capi_IVRCompositor_027_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_027_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_UnlockGLSharedTextureForAccess", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRCompositor_026_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_027_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetVulkanInstanceExtensionsRequired((void *)1, 2);
-    check_ptr_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", (void *)1);
-    check_uint32_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", 2);
+    capi_IVRCompositor_027_GetVulkanInstanceExtensionsRequired((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_027_GetVulkanInstanceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetVulkanInstanceExtensionsRequired", (void *)1);
+    check_uint32_parameter("IVRCompositor_027_GetVulkanInstanceExtensionsRequired", 2);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRCompositor_026_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_027_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
-    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", (void *)1);
-    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", (void *)2);
-    check_uint32_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", 3);
+    capi_IVRCompositor_027_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRCompositor_027_GetVulkanDeviceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetVulkanDeviceExtensionsRequired", (void *)1);
+    check_ptr_parameter("IVRCompositor_027_GetVulkanDeviceExtensionsRequired", (void *)2);
+    check_uint32_parameter("IVRCompositor_027_GetVulkanDeviceExtensionsRequired", 3);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_SetExplicitTimingMode, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_SetExplicitTimingMode, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_SetExplicitTimingMode(1);
-    check_ptr_parameter("IVRCompositor_026_SetExplicitTimingMode", this_ptr_value);
-    check_uint32_parameter("IVRCompositor_026_SetExplicitTimingMode", 1);
+    capi_IVRCompositor_027_SetExplicitTimingMode(1);
+    check_ptr_parameter("IVRCompositor_027_SetExplicitTimingMode", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_027_SetExplicitTimingMode", 1);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_SubmitExplicitTimingData, 0, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SubmitExplicitTimingData)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_SubmitExplicitTimingData, 0, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_SubmitExplicitTimingData)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_SubmitExplicitTimingData();
-    check_ptr_parameter("IVRCompositor_026_SubmitExplicitTimingData", this_ptr_value);
+    capi_IVRCompositor_027_SubmitExplicitTimingData();
+    check_ptr_parameter("IVRCompositor_027_SubmitExplicitTimingData", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_IsMotionSmoothingEnabled)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_IsMotionSmoothingEnabled)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_IsMotionSmoothingEnabled();
-    check_ptr_parameter("IVRCompositor_026_IsMotionSmoothingEnabled", this_ptr_value);
+    capi_IVRCompositor_027_IsMotionSmoothingEnabled();
+    check_ptr_parameter("IVRCompositor_027_IsMotionSmoothingEnabled", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMotionSmoothingSupported, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_IsMotionSmoothingSupported)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_IsMotionSmoothingSupported, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_IsMotionSmoothingSupported)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_IsMotionSmoothingSupported();
-    check_ptr_parameter("IVRCompositor_026_IsMotionSmoothingSupported", this_ptr_value);
+    capi_IVRCompositor_027_IsMotionSmoothingSupported();
+    check_ptr_parameter("IVRCompositor_027_IsMotionSmoothingSupported", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_IsCurrentSceneFocusAppLoading)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_IsCurrentSceneFocusAppLoading)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_IsCurrentSceneFocusAppLoading();
-    check_ptr_parameter("IVRCompositor_026_IsCurrentSceneFocusAppLoading", this_ptr_value);
+    capi_IVRCompositor_027_IsCurrentSceneFocusAppLoading();
+    check_ptr_parameter("IVRCompositor_027_IsCurrentSceneFocusAppLoading", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_SetStageOverride_Async, 4, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SetStageOverride_Async)(const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_SetStageOverride_Async, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_SetStageOverride_Async)(const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_SetStageOverride_Async((void *)1, (void *)2, (void *)3, 4);
-    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)1);
-    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)2);
-    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)3);
-    check_uint32_parameter("IVRCompositor_026_SetStageOverride_Async", 4);
+    capi_IVRCompositor_027_SetStageOverride_Async((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_027_SetStageOverride_Async", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_SetStageOverride_Async", (void *)1);
+    check_ptr_parameter("IVRCompositor_027_SetStageOverride_Async", (void *)2);
+    check_ptr_parameter("IVRCompositor_027_SetStageOverride_Async", (void *)3);
+    check_uint32_parameter("IVRCompositor_027_SetStageOverride_Async", 4);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearStageOverride, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRCompositor_026_ClearStageOverride)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_ClearStageOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_027_ClearStageOverride)() = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_ClearStageOverride();
-    check_ptr_parameter("IVRCompositor_026_ClearStageOverride", this_ptr_value);
+    capi_IVRCompositor_027_ClearStageOverride();
+    check_ptr_parameter("IVRCompositor_027_ClearStageOverride", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCompositorBenchmarkResults, 2, FALSE, FALSE);
-    bool (__stdcall *capi_IVRCompositor_026_GetCompositorBenchmarkResults)(Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetCompositorBenchmarkResults, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_027_GetCompositorBenchmarkResults)(Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetCompositorBenchmarkResults((void *)1, 2);
-    check_ptr_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", (void *)1);
-    check_uint32_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", 2);
+    capi_IVRCompositor_027_GetCompositorBenchmarkResults((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_027_GetCompositorBenchmarkResults", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetCompositorBenchmarkResults", (void *)1);
+    check_uint32_parameter("IVRCompositor_027_GetCompositorBenchmarkResults", 2);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPosePredictionIDs, 2, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPosePredictionIDs)(uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetLastPosePredictionIDs, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetLastPosePredictionIDs)(uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetLastPosePredictionIDs((void *)1, (void *)2);
-    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", this_ptr_value);
-    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", (void *)1);
-    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", (void *)2);
+    capi_IVRCompositor_027_GetLastPosePredictionIDs((void *)1, (void *)2);
+    check_ptr_parameter("IVRCompositor_027_GetLastPosePredictionIDs", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_027_GetLastPosePredictionIDs", (void *)1);
+    check_ptr_parameter("IVRCompositor_027_GetLastPosePredictionIDs", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVRCompositor_026_GetPosesForFrame, 3, FALSE, FALSE);
-    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetPosesForFrame)(uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRCompositor_027_GetPosesForFrame, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_027_GetPosesForFrame)(uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount) = (void *)t;
 
     clear_parameters();
-    capi_IVRCompositor_026_GetPosesForFrame(1, (void *)2, 3);
-    check_ptr_parameter("IVRCompositor_026_GetPosesForFrame", this_ptr_value);
-    check_uint32_parameter("IVRCompositor_026_GetPosesForFrame", 1);
-    check_ptr_parameter("IVRCompositor_026_GetPosesForFrame", (void *)2);
-    check_uint32_parameter("IVRCompositor_026_GetPosesForFrame", 3);
+    capi_IVRCompositor_027_GetPosesForFrame(1, (void *)2, 3);
+    check_ptr_parameter("IVRCompositor_027_GetPosesForFrame", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_027_GetPosesForFrame", 1);
+    check_ptr_parameter("IVRCompositor_027_GetPosesForFrame", (void *)2);
+    check_uint32_parameter("IVRCompositor_027_GetPosesForFrame", 3);
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
@@ -1601,751 +1601,763 @@ void test_capi_thunks_IVRNotifications_002(void)
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
-void test_capi_thunks_IVROverlay_024(void)
+void test_capi_thunks_IVROverlay_025(void)
 {
     struct thunk *t = alloc_thunks(1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_FindOverlay, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_FindOverlay((void *)1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_FindOverlay", this_ptr_value);
-    check_ptr_parameter("IVROverlay_024_FindOverlay", (void *)1);
-    check_ptr_parameter("IVROverlay_024_FindOverlay", (void *)2);
+    capi_IVROverlay_025_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_025_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_025_FindOverlay", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_CreateOverlay, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_CreateOverlay((void *)1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_CreateOverlay", this_ptr_value);
-    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)1);
-    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)2);
-    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)3);
+    capi_IVROverlay_025_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_025_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_025_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_025_CreateOverlay", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_DestroyOverlay, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_DestroyOverlay(1);
-    check_ptr_parameter("IVROverlay_024_DestroyOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_DestroyOverlay", 1);
+    capi_IVROverlay_025_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_025_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_DestroyOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayKey, 4, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_025_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayKey(1, (void *)2, 3, (void *)4);
-    check_ptr_parameter("IVROverlay_024_GetOverlayKey", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayKey", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayKey", (void *)2);
-    check_uint32_parameter("IVROverlay_024_GetOverlayKey", 3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayKey", (void *)4);
+    capi_IVROverlay_025_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_025_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_025_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayKey", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayName, 4, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_025_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayName(1, (void *)2, 3, (void *)4);
-    check_ptr_parameter("IVROverlay_024_GetOverlayName", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayName", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayName", (void *)2);
-    check_uint32_parameter("IVROverlay_024_GetOverlayName", 3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayName", (void *)4);
+    capi_IVROverlay_025_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_025_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_025_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayName", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayName, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayName, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayName(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayName", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayName", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayName", (void *)2);
+    capi_IVROverlay_025_SetOverlayName(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayName", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayImageData, 5, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
-    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayImageData", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)2);
-    check_uint32_parameter("IVROverlay_024_GetOverlayImageData", 3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)4);
-    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)5);
+    capi_IVROverlay_025_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_025_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_025_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_025_GetOverlayImageData", (void *)5);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
-    const char * (__stdcall *capi_IVROverlay_024_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_025_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayErrorNameFromEnum(1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayErrorNameFromEnum", this_ptr_value);
-    check_uint32_parameter("IVROverlay_024_GetOverlayErrorNameFromEnum", 1);
+    capi_IVROverlay_025_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_025_GetOverlayErrorNameFromEnum", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayRenderingPid, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayRenderingPid(1, 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayRenderingPid", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayRenderingPid", 1);
-    check_uint32_parameter("IVROverlay_024_SetOverlayRenderingPid", 2);
+    capi_IVROverlay_025_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlayRenderingPid", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayRenderingPid, 1, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_025_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayRenderingPid(1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayRenderingPid", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayRenderingPid", 1);
+    capi_IVROverlay_025_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayRenderingPid", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayFlag, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayFlag(1, 2, 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayFlag", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayFlag", 1);
-    check_uint32_parameter("IVROverlay_024_SetOverlayFlag", 2);
-    check_bool_parameter("IVROverlay_024_SetOverlayFlag", 1);
+    capi_IVROverlay_025_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_025_SetOverlayFlag", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayFlag, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayFlag(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayFlag", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayFlag", 1);
-    check_uint32_parameter("IVROverlay_024_GetOverlayFlag", 2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayFlag", (void *)3);
+    capi_IVROverlay_025_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_025_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayFlag", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayFlags, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayFlags, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayFlags(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayFlags", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayFlags", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayFlags", (void *)2);
+    capi_IVROverlay_025_GetOverlayFlags(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayFlags", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayFlags", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayFlags", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayColor, 4, TRUE, TRUE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
-    check_ptr_parameter("IVROverlay_024_SetOverlayColor", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayColor", 1);
-    check_float_parameter("IVROverlay_024_SetOverlayColor", 2.0f);
-    check_float_parameter("IVROverlay_024_SetOverlayColor", 3.0f);
-    check_float_parameter("IVROverlay_024_SetOverlayColor", 4.0f);
+    capi_IVROverlay_025_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_025_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_025_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_025_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_025_SetOverlayColor", 4.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayColor, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
-    check_ptr_parameter("IVROverlay_024_GetOverlayColor", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayColor", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)4);
+    capi_IVROverlay_025_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_025_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayColor", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayAlpha, 2, TRUE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayAlpha(1, 2.0f);
-    check_ptr_parameter("IVROverlay_024_SetOverlayAlpha", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayAlpha", 1);
-    check_float_parameter("IVROverlay_024_SetOverlayAlpha", 2.0f);
+    capi_IVROverlay_025_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_025_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_025_SetOverlayAlpha", 2.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayAlpha, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayAlpha(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayAlpha", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayAlpha", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayAlpha", (void *)2);
+    capi_IVROverlay_025_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayAlpha", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTexelAspect, 2, TRUE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTexelAspect(1, 2.0f);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTexelAspect", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTexelAspect", 1);
-    check_float_parameter("IVROverlay_024_SetOverlayTexelAspect", 2.0f);
+    capi_IVROverlay_025_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_025_SetOverlayTexelAspect", 2.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTexelAspect, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTexelAspect(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexelAspect", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTexelAspect", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexelAspect", (void *)2);
+    capi_IVROverlay_025_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexelAspect", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlaySortOrder, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlaySortOrder(1, 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlaySortOrder", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlaySortOrder", 1);
-    check_uint32_parameter("IVROverlay_024_SetOverlaySortOrder", 2);
+    capi_IVROverlay_025_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlaySortOrder", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlaySortOrder, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlaySortOrder(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlaySortOrder", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlaySortOrder", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlaySortOrder", (void *)2);
+    capi_IVROverlay_025_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlaySortOrder", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayWidthInMeters, 2, TRUE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayWidthInMeters(1, 2.0f);
-    check_ptr_parameter("IVROverlay_024_SetOverlayWidthInMeters", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayWidthInMeters", 1);
-    check_float_parameter("IVROverlay_024_SetOverlayWidthInMeters", 2.0f);
+    capi_IVROverlay_025_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_025_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_025_SetOverlayWidthInMeters", 2.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayWidthInMeters, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayWidthInMeters(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayWidthInMeters", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayWidthInMeters", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayWidthInMeters", (void *)2);
+    capi_IVROverlay_025_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayWidthInMeters", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCurvature, 2, TRUE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayCurvature, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayCurvature(1, 2.0f);
-    check_ptr_parameter("IVROverlay_024_SetOverlayCurvature", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayCurvature", 1);
-    check_float_parameter("IVROverlay_024_SetOverlayCurvature", 2.0f);
+    capi_IVROverlay_025_SetOverlayCurvature(1, 2.0f);
+    check_ptr_parameter("IVROverlay_025_SetOverlayCurvature", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayCurvature", 1);
+    check_float_parameter("IVROverlay_025_SetOverlayCurvature", 2.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayCurvature, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayCurvature, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayCurvature(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayCurvature", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayCurvature", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayCurvature", (void *)2);
+    capi_IVROverlay_025_GetOverlayCurvature(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayCurvature", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayCurvature", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayCurvature", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTextureColorSpace(1, 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTextureColorSpace", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTextureColorSpace", 1);
-    check_uint32_parameter("IVROverlay_024_SetOverlayTextureColorSpace", 2);
+    capi_IVROverlay_025_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlayTextureColorSpace", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTextureColorSpace(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTextureColorSpace", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTextureColorSpace", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTextureColorSpace", (void *)2);
+    capi_IVROverlay_025_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTextureColorSpace", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTextureBounds, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTextureBounds(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTextureBounds", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTextureBounds", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTextureBounds", (void *)2);
+    capi_IVROverlay_025_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTextureBounds", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureBounds, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTextureBounds(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTextureBounds", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTextureBounds", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTextureBounds", (void *)2);
+    capi_IVROverlay_025_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTextureBounds", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformType, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTransformType(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformType", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTransformType", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformType", (void *)2);
+    capi_IVROverlay_025_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformType", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTransformAbsolute(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformAbsolute", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTransformAbsolute", 1);
-    check_uint32_parameter("IVROverlay_024_SetOverlayTransformAbsolute", 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformAbsolute", (void *)3);
+    capi_IVROverlay_025_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformAbsolute", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTransformAbsolute", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", (void *)3);
+    capi_IVROverlay_025_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformAbsolute", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", 1);
-    check_uint32_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+    capi_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceRelative", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+    capi_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceRelative", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", 1);
-    check_uint32_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+    capi_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformTrackedDeviceComponent", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", (void *)3);
-    check_uint32_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", 4);
+    capi_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_025_GetOverlayTransformTrackedDeviceComponent", 4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", (void *)3);
+    capi_IVROverlay_025_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTransformOverlayRelative", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformOverlayRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformOverlayRelative", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", 1);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", (void *)3);
+    capi_IVROverlay_025_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTransformOverlayRelative", 1);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTransformOverlayRelative", 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformOverlayRelative", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformCursor, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformCursor)(VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformCursor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformCursor)(VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTransformCursor(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformCursor", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTransformCursor", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTransformCursor", (void *)2);
+    capi_IVROverlay_025_SetOverlayTransformCursor(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformCursor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTransformCursor", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformCursor", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformCursor, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformCursor)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTransformCursor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTransformCursor)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTransformCursor(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformCursor", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTransformCursor", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTransformCursor", (void *)2);
+    capi_IVROverlay_025_GetOverlayTransformCursor(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformCursor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTransformCursor", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTransformCursor", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ShowOverlay, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTransformProjection, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTransformProjection)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ShowOverlay(1);
-    check_ptr_parameter("IVROverlay_024_ShowOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_ShowOverlay", 1);
+    capi_IVROverlay_025_SetOverlayTransformProjection(1, 2, (void *)3, (void *)4, 5);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformProjection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTransformProjection", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlayTransformProjection", 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformProjection", (void *)3);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTransformProjection", (void *)4);
+    check_uint32_parameter("IVROverlay_025_SetOverlayTransformProjection", 5);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_HideOverlay, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_HideOverlay(1);
-    check_ptr_parameter("IVROverlay_024_HideOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_HideOverlay", 1);
+    capi_IVROverlay_025_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_025_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_ShowOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_IsOverlayVisible, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_024_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_IsOverlayVisible(1);
-    check_ptr_parameter("IVROverlay_024_IsOverlayVisible", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_IsOverlayVisible", 1);
+    capi_IVROverlay_025_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_025_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_HideOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_025_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
-    check_ptr_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", 1);
-    check_uint32_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", 2);
-    check_HmdVector2_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
-    check_ptr_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", (void *)4);
+    capi_IVROverlay_025_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_025_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_IsOverlayVisible", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_PollNextOverlayEvent, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_024_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_PollNextOverlayEvent(1, (void *)2, 3);
-    check_ptr_parameter("IVROverlay_024_PollNextOverlayEvent", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_PollNextOverlayEvent", 1);
-    check_ptr_parameter("IVROverlay_024_PollNextOverlayEvent", (void *)2);
-    check_uint32_parameter("IVROverlay_024_PollNextOverlayEvent", 3);
+    capi_IVROverlay_025_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_025_GetTransformForOverlayCoordinates", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayInputMethod, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_025_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayInputMethod(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayInputMethod", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayInputMethod", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayInputMethod", (void *)2);
+    capi_IVROverlay_025_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_025_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_025_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_025_PollNextOverlayEvent", 3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayInputMethod, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayInputMethod(1, 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayInputMethod", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayInputMethod", 1);
-    check_uint32_parameter("IVROverlay_024_SetOverlayInputMethod", 2);
+    capi_IVROverlay_025_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayInputMethod", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayMouseScale, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayMouseScale(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayMouseScale", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayMouseScale", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayMouseScale", (void *)2);
+    capi_IVROverlay_025_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_025_SetOverlayInputMethod", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayMouseScale, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayMouseScale(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayMouseScale", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayMouseScale", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayMouseScale", (void *)2);
+    capi_IVROverlay_025_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayMouseScale", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ComputeOverlayIntersection, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_024_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ComputeOverlayIntersection(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_ComputeOverlayIntersection", 1);
-    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", (void *)2);
-    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", (void *)3);
+    capi_IVROverlay_025_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayMouseScale", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_IsHoverTargetOverlay, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_024_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_025_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_IsHoverTargetOverlay(1);
-    check_ptr_parameter("IVROverlay_024_IsHoverTargetOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_IsHoverTargetOverlay", 1);
+    capi_IVROverlay_025_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_025_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_025_ComputeOverlayIntersection", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayIntersectionMask, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_025_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
-    check_ptr_parameter("IVROverlay_024_SetOverlayIntersectionMask", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayIntersectionMask", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayIntersectionMask", (void *)2);
-    check_uint32_parameter("IVROverlay_024_SetOverlayIntersectionMask", 3);
-    check_uint32_parameter("IVROverlay_024_SetOverlayIntersectionMask", 4);
+    capi_IVROverlay_025_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_025_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_IsHoverTargetOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_TriggerLaserMouseHapticVibration)(VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_TriggerLaserMouseHapticVibration(1, 2.0f, 3.0f, 4.0f);
-    check_ptr_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 1);
-    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 2.0f);
-    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 3.0f);
-    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 4.0f);
+    capi_IVROverlay_025_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_025_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_025_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_025_SetOverlayIntersectionMask", 4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCursor, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCursor)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_TriggerLaserMouseHapticVibration)(VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayCursor(1, 2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayCursor", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayCursor", 1);
-    check_uint64_parameter("IVROverlay_024_SetOverlayCursor", 2);
+    capi_IVROverlay_025_TriggerLaserMouseHapticVibration(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", 1);
+    check_float_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", 2.0f);
+    check_float_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", 3.0f);
+    check_float_parameter("IVROverlay_025_TriggerLaserMouseHapticVibration", 4.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayCursor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayCursor)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayCursorPositionOverride(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", (void *)2);
+    capi_IVROverlay_025_SetOverlayCursor(1, 2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayCursor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayCursor", 1);
+    check_uint64_parameter("IVROverlay_025_SetOverlayCursor", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_ClearOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ClearOverlayCursorPositionOverride(1);
-    check_ptr_parameter("IVROverlay_024_ClearOverlayCursorPositionOverride", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_ClearOverlayCursorPositionOverride", 1);
+    capi_IVROverlay_025_SetOverlayCursorPositionOverride(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayCursorPositionOverride", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayCursorPositionOverride", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayCursorPositionOverride", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTexture, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_ClearOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayTexture(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTexture", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayTexture", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayTexture", (void *)2);
+    capi_IVROverlay_025_ClearOverlayCursorPositionOverride(1);
+    check_ptr_parameter("IVROverlay_025_ClearOverlayCursorPositionOverride", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_ClearOverlayCursorPositionOverride", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ClearOverlayTexture, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ClearOverlayTexture(1);
-    check_ptr_parameter("IVROverlay_024_ClearOverlayTexture", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_ClearOverlayTexture", 1);
+    capi_IVROverlay_025_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayTexture", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayRaw, 5, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayRaw(1, (void *)2, 3, 4, 5);
-    check_ptr_parameter("IVROverlay_024_SetOverlayRaw", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayRaw", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayRaw", (void *)2);
-    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 3);
-    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 4);
-    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 5);
+    capi_IVROverlay_025_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_025_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_ClearOverlayTexture", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayFromFile, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetOverlayFromFile(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_SetOverlayFromFile", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetOverlayFromFile", 1);
-    check_ptr_parameter("IVROverlay_024_SetOverlayFromFile", (void *)2);
+    capi_IVROverlay_025_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_025_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_025_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_025_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_025_SetOverlayRaw", 5);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTexture, 9, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTexture", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)4);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)5);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)6);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)7);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)8);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)9);
+    capi_IVROverlay_025_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_025_SetOverlayFromFile", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTexture, 9, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ReleaseNativeOverlayHandle(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", 1);
-    check_ptr_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", (void *)2);
+    capi_IVROverlay_025_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)8);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTexture", (void *)9);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureSize, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetOverlayTextureSize(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetOverlayTextureSize", 1);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", (void *)3);
+    capi_IVROverlay_025_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_025_ReleaseNativeOverlayHandle", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_CreateDashboardOverlay, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
-    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", this_ptr_value);
-    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)1);
-    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)2);
-    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)3);
-    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)4);
+    capi_IVROverlay_025_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetOverlayTextureSize", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_IsDashboardVisible, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_024_IsDashboardVisible)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_IsDashboardVisible();
-    check_ptr_parameter("IVROverlay_024_IsDashboardVisible", this_ptr_value);
+    capi_IVROverlay_025_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_025_CreateDashboardOverlay", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_IsActiveDashboardOverlay, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_024_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_025_IsDashboardVisible)() = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_IsActiveDashboardOverlay(1);
-    check_ptr_parameter("IVROverlay_024_IsActiveDashboardOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_IsActiveDashboardOverlay", 1);
+    capi_IVROverlay_025_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_025_IsDashboardVisible", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_025_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetDashboardOverlaySceneProcess(1, 2);
-    check_ptr_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", 1);
-    check_uint32_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", 2);
+    capi_IVROverlay_025_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_025_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_IsActiveDashboardOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetDashboardOverlaySceneProcess(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", 1);
-    check_ptr_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", (void *)2);
+    capi_IVROverlay_025_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_025_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_025_SetDashboardOverlaySceneProcess", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ShowDashboard, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_024_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ShowDashboard((void *)1);
-    check_ptr_parameter("IVROverlay_024_ShowDashboard", this_ptr_value);
-    check_ptr_parameter("IVROverlay_024_ShowDashboard", (void *)1);
+    capi_IVROverlay_025_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_025_GetDashboardOverlaySceneProcess", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
-    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_024_GetPrimaryDashboardDevice)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_025_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetPrimaryDashboardDevice();
-    check_ptr_parameter("IVROverlay_024_GetPrimaryDashboardDevice", this_ptr_value);
+    capi_IVROverlay_025_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_025_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_025_ShowDashboard", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ShowKeyboard, 7, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_025_GetPrimaryDashboardDevice)() = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ShowKeyboard(1, 2, 3, (void *)4, 5, (void *)6, 7);
-    check_ptr_parameter("IVROverlay_024_ShowKeyboard", this_ptr_value);
-    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 1);
-    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 2);
-    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 3);
-    check_ptr_parameter("IVROverlay_024_ShowKeyboard", (void *)4);
-    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 5);
-    check_ptr_parameter("IVROverlay_024_ShowKeyboard", (void *)6);
-    check_uint64_parameter("IVROverlay_024_ShowKeyboard", 7);
+    capi_IVROverlay_025_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_025_GetPrimaryDashboardDevice", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ShowKeyboardForOverlay, 8, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ShowKeyboardForOverlay(1, 2, 3, 4, (void *)5, 6, (void *)7, 8);
-    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_ShowKeyboardForOverlay", 1);
-    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 2);
-    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 3);
-    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 4);
-    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", (void *)5);
-    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 6);
-    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", (void *)7);
-    check_uint64_parameter("IVROverlay_024_ShowKeyboardForOverlay", 8);
+    capi_IVROverlay_025_ShowKeyboard(1, 2, 3, (void *)4, 5, (void *)6, 7);
+    check_ptr_parameter("IVROverlay_025_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_025_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_025_ShowKeyboard", 2);
+    check_uint32_parameter("IVROverlay_025_ShowKeyboard", 3);
+    check_ptr_parameter("IVROverlay_025_ShowKeyboard", (void *)4);
+    check_uint32_parameter("IVROverlay_025_ShowKeyboard", 5);
+    check_ptr_parameter("IVROverlay_025_ShowKeyboard", (void *)6);
+    check_uint64_parameter("IVROverlay_025_ShowKeyboard", 7);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_GetKeyboardText, 2, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_024_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_025_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_GetKeyboardText((void *)1, 2);
-    check_ptr_parameter("IVROverlay_024_GetKeyboardText", this_ptr_value);
-    check_ptr_parameter("IVROverlay_024_GetKeyboardText", (void *)1);
-    check_uint32_parameter("IVROverlay_024_GetKeyboardText", 2);
+    capi_IVROverlay_025_ShowKeyboardForOverlay(1, 2, 3, 4, (void *)5, 6, (void *)7, 8);
+    check_ptr_parameter("IVROverlay_025_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_025_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_025_ShowKeyboardForOverlay", 3);
+    check_uint32_parameter("IVROverlay_025_ShowKeyboardForOverlay", 4);
+    check_ptr_parameter("IVROverlay_025_ShowKeyboardForOverlay", (void *)5);
+    check_uint32_parameter("IVROverlay_025_ShowKeyboardForOverlay", 6);
+    check_ptr_parameter("IVROverlay_025_ShowKeyboardForOverlay", (void *)7);
+    check_uint64_parameter("IVROverlay_025_ShowKeyboardForOverlay", 8);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_HideKeyboard, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_024_HideKeyboard)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_025_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_HideKeyboard();
-    check_ptr_parameter("IVROverlay_024_HideKeyboard", this_ptr_value);
+    capi_IVROverlay_025_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_025_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_025_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_025_GetKeyboardText", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_024_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_025_HideKeyboard)() = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetKeyboardTransformAbsolute(1, (void *)2);
-    check_ptr_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", this_ptr_value);
-    check_uint32_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", 1);
-    check_ptr_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", (void *)2);
+    capi_IVROverlay_025_HideKeyboard();
+    check_ptr_parameter("IVROverlay_025_HideKeyboard", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_024_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_025_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
-    check_ptr_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", 1);
-    check_HmdRect2_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+    capi_IVROverlay_025_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_025_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_025_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_025_SetKeyboardTransformAbsolute", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_ShowMessageOverlay, 6, FALSE, FALSE);
-    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_024_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_025_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
-    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", this_ptr_value);
-    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)1);
-    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)2);
-    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)3);
-    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)4);
-    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)5);
-    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)6);
+    capi_IVROverlay_025_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_025_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_025_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_025_SetKeyboardPositionForOverlay", DEFAULT_RECT);
 
-    init_thunk(t, this_ptr_value, IVROverlay_024_CloseMessageOverlay, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_024_CloseMessageOverlay)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_025_ShowMessageOverlay, 6, FALSE, FALSE);
+    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_025_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_024_CloseMessageOverlay();
-    check_ptr_parameter("IVROverlay_024_CloseMessageOverlay", this_ptr_value);
+    capi_IVROverlay_025_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
+    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)4);
+    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)5);
+    check_ptr_parameter("IVROverlay_025_ShowMessageOverlay", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVROverlay_025_CloseMessageOverlay, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_025_CloseMessageOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_025_CloseMessageOverlay();
+    check_ptr_parameter("IVROverlay_025_CloseMessageOverlay", this_ptr_value);
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
@@ -3373,6 +3385,1181 @@ void test_capi_thunks_IVRClientCore_003(void)
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
+void test_capi_thunks_IVRCompositor_026(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_SetTrackingSpace, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_SetTrackingSpace)(ETrackingUniverseOrigin eOrigin) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_SetTrackingSpace(1);
+    check_ptr_parameter("IVRCompositor_026_SetTrackingSpace", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_026_SetTrackingSpace", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetTrackingSpace, 0, FALSE, FALSE);
+    ETrackingUniverseOrigin (__stdcall *capi_IVRCompositor_026_GetTrackingSpace)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetTrackingSpace();
+    check_ptr_parameter("IVRCompositor_026_GetTrackingSpace", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_WaitGetPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_WaitGetPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_WaitGetPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_026_WaitGetPoses", 2);
+    check_ptr_parameter("IVRCompositor_026_WaitGetPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_026_WaitGetPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPoses, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPoses)(TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetLastPoses((void *)1, 2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_026_GetLastPoses", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetLastPoses", (void *)1);
+    check_uint32_parameter("IVRCompositor_026_GetLastPoses", 2);
+    check_ptr_parameter("IVRCompositor_026_GetLastPoses", (void *)3);
+    check_uint32_parameter("IVRCompositor_026_GetLastPoses", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetLastPoseForTrackedDeviceIndex(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", 1);
+    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", (void *)2);
+    check_ptr_parameter("IVRCompositor_026_GetLastPoseForTrackedDeviceIndex", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_Submit, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_Submit)(EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_Submit(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_026_Submit", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_026_Submit", 1);
+    check_ptr_parameter("IVRCompositor_026_Submit", (void *)2);
+    check_ptr_parameter("IVRCompositor_026_Submit", (void *)3);
+    check_uint32_parameter("IVRCompositor_026_Submit", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_ClearLastSubmittedFrame)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ClearLastSubmittedFrame();
+    check_ptr_parameter("IVRCompositor_026_ClearLastSubmittedFrame", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_PostPresentHandoff, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_PostPresentHandoff)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_PostPresentHandoff();
+    check_ptr_parameter("IVRCompositor_026_PostPresentHandoff", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTiming, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_GetFrameTiming)(Compositor_FrameTiming * pTiming, uint32_t unFramesAgo) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetFrameTiming((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_026_GetFrameTiming", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetFrameTiming", (void *)1);
+    check_uint32_parameter("IVRCompositor_026_GetFrameTiming", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTimings, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_026_GetFrameTimings)(Compositor_FrameTiming * pTiming, uint32_t nFrames) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetFrameTimings((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_026_GetFrameTimings", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetFrameTimings", (void *)1);
+    check_uint32_parameter("IVRCompositor_026_GetFrameTimings", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_026_GetFrameTimeRemaining)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetFrameTimeRemaining();
+    check_ptr_parameter("IVRCompositor_026_GetFrameTimeRemaining", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCumulativeStats, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_GetCumulativeStats)(Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetCumulativeStats((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_026_GetCumulativeStats", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetCumulativeStats", (void *)1);
+    check_uint32_parameter("IVRCompositor_026_GetCumulativeStats", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_FadeToColor, 6, TRUE, TRUE);
+    void (__stdcall *capi_IVRCompositor_026_FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_FadeToColor(1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 1);
+    check_ptr_parameter("IVRCompositor_026_FadeToColor", this_ptr_value);
+    check_float_parameter("IVRCompositor_026_FadeToColor", 1.0f);
+    check_float_parameter("IVRCompositor_026_FadeToColor", 2.0f);
+    check_float_parameter("IVRCompositor_026_FadeToColor", 3.0f);
+    check_float_parameter("IVRCompositor_026_FadeToColor", 4.0f);
+    check_float_parameter("IVRCompositor_026_FadeToColor", 5.0f);
+    check_bool_parameter("IVRCompositor_026_FadeToColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentFadeColor, 2, FALSE, FALSE);
+    HmdColor_t *(__stdcall *capi_IVRCompositor_026_GetCurrentFadeColor)(HmdColor_t *_r, bool bBackground) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetCurrentFadeColor(data_ptr_value, 1);
+    check_ptr_parameter("IVRCompositor_026_GetCurrentFadeColor", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetCurrentFadeColor", data_ptr_value);
+    check_bool_parameter("IVRCompositor_026_GetCurrentFadeColor", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_FadeGrid, 2, TRUE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_FadeGrid)(float fSeconds, bool bFadeIn) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_FadeGrid(1.0f, 1);
+    check_ptr_parameter("IVRCompositor_026_FadeGrid", this_ptr_value);
+    check_float_parameter("IVRCompositor_026_FadeGrid", 1.0f);
+    check_bool_parameter("IVRCompositor_026_FadeGrid", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    float (__stdcall *capi_IVRCompositor_026_GetCurrentGridAlpha)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetCurrentGridAlpha();
+    check_ptr_parameter("IVRCompositor_026_GetCurrentGridAlpha", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_SetSkyboxOverride, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SetSkyboxOverride)(Texture_t * pTextures, uint32_t unTextureCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_SetSkyboxOverride((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_026_SetSkyboxOverride", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_SetSkyboxOverride", (void *)1);
+    check_uint32_parameter("IVRCompositor_026_SetSkyboxOverride", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearSkyboxOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_ClearSkyboxOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ClearSkyboxOverride();
+    check_ptr_parameter("IVRCompositor_026_ClearSkyboxOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorBringToFront, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_CompositorBringToFront)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_CompositorBringToFront();
+    check_ptr_parameter("IVRCompositor_026_CompositorBringToFront", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorGoToBack, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_CompositorGoToBack)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_CompositorGoToBack();
+    check_ptr_parameter("IVRCompositor_026_CompositorGoToBack", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorQuit, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_CompositorQuit)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_CompositorQuit();
+    check_ptr_parameter("IVRCompositor_026_CompositorQuit", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_IsFullscreen, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_IsFullscreen)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_IsFullscreen();
+    check_ptr_parameter("IVRCompositor_026_IsFullscreen", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_026_GetCurrentSceneFocusProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetCurrentSceneFocusProcess();
+    check_ptr_parameter("IVRCompositor_026_GetCurrentSceneFocusProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastFrameRenderer, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_026_GetLastFrameRenderer)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetLastFrameRenderer();
+    check_ptr_parameter("IVRCompositor_026_GetLastFrameRenderer", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_CanRenderScene, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_CanRenderScene)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_CanRenderScene();
+    check_ptr_parameter("IVRCompositor_026_CanRenderScene", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ShowMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_ShowMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ShowMirrorWindow();
+    check_ptr_parameter("IVRCompositor_026_ShowMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_HideMirrorWindow, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_HideMirrorWindow)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_HideMirrorWindow();
+    check_ptr_parameter("IVRCompositor_026_HideMirrorWindow", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_IsMirrorWindowVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_IsMirrorWindowVisible();
+    check_ptr_parameter("IVRCompositor_026_IsMirrorWindowVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_CompositorDumpImages, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_CompositorDumpImages)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_CompositorDumpImages();
+    check_ptr_parameter("IVRCompositor_026_CompositorDumpImages", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_ShouldAppRenderWithLowResources)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ShouldAppRenderWithLowResources();
+    check_ptr_parameter("IVRCompositor_026_ShouldAppRenderWithLowResources", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_ForceInterleavedReprojectionOn)(bool bOverride) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ForceInterleavedReprojectionOn(1);
+    check_ptr_parameter("IVRCompositor_026_ForceInterleavedReprojectionOn", this_ptr_value);
+    check_bool_parameter("IVRCompositor_026_ForceInterleavedReprojectionOn", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ForceReconnectProcess, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_ForceReconnectProcess)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ForceReconnectProcess();
+    check_ptr_parameter("IVRCompositor_026_ForceReconnectProcess", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_SuspendRendering, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_SuspendRendering)(bool bSuspend) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_SuspendRendering(1);
+    check_ptr_parameter("IVRCompositor_026_SuspendRendering", this_ptr_value);
+    check_bool_parameter("IVRCompositor_026_SuspendRendering", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetMirrorTextureD3D11(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_026_GetMirrorTextureD3D11", 1);
+    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", (void *)2);
+    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureD3D11", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ReleaseMirrorTextureD3D11((void *)1);
+    check_ptr_parameter("IVRCompositor_026_ReleaseMirrorTextureD3D11", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_ReleaseMirrorTextureD3D11", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetMirrorTextureGL, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetMirrorTextureGL(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_026_GetMirrorTextureGL", 1);
+    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", (void *)2);
+    check_ptr_parameter("IVRCompositor_026_GetMirrorTextureGL", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ReleaseSharedGLTexture(1, (void *)2);
+    check_ptr_parameter("IVRCompositor_026_ReleaseSharedGLTexture", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_026_ReleaseSharedGLTexture", 1);
+    check_ptr_parameter("IVRCompositor_026_ReleaseSharedGLTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_LockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_026_LockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_LockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_UnlockGLSharedTextureForAccess((void *)1);
+    check_ptr_parameter("IVRCompositor_026_UnlockGLSharedTextureForAccess", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_UnlockGLSharedTextureForAccess", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_026_GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetVulkanInstanceExtensionsRequired((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", (void *)1);
+    check_uint32_parameter("IVRCompositor_026_GetVulkanInstanceExtensionsRequired", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRCompositor_026_GetVulkanDeviceExtensionsRequired)(VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetVulkanDeviceExtensionsRequired((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", (void *)1);
+    check_ptr_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", (void *)2);
+    check_uint32_parameter("IVRCompositor_026_GetVulkanDeviceExtensionsRequired", 3);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_SetExplicitTimingMode, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_SetExplicitTimingMode(1);
+    check_ptr_parameter("IVRCompositor_026_SetExplicitTimingMode", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_026_SetExplicitTimingMode", 1);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_SubmitExplicitTimingData, 0, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SubmitExplicitTimingData)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_SubmitExplicitTimingData();
+    check_ptr_parameter("IVRCompositor_026_SubmitExplicitTimingData", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_IsMotionSmoothingEnabled)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_IsMotionSmoothingEnabled();
+    check_ptr_parameter("IVRCompositor_026_IsMotionSmoothingEnabled", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_IsMotionSmoothingSupported, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_IsMotionSmoothingSupported)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_IsMotionSmoothingSupported();
+    check_ptr_parameter("IVRCompositor_026_IsMotionSmoothingSupported", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_IsCurrentSceneFocusAppLoading)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_IsCurrentSceneFocusAppLoading();
+    check_ptr_parameter("IVRCompositor_026_IsCurrentSceneFocusAppLoading", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_SetStageOverride_Async, 4, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_SetStageOverride_Async)(const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_SetStageOverride_Async((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)1);
+    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)2);
+    check_ptr_parameter("IVRCompositor_026_SetStageOverride_Async", (void *)3);
+    check_uint32_parameter("IVRCompositor_026_SetStageOverride_Async", 4);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_ClearStageOverride, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRCompositor_026_ClearStageOverride)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_ClearStageOverride();
+    check_ptr_parameter("IVRCompositor_026_ClearStageOverride", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetCompositorBenchmarkResults, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRCompositor_026_GetCompositorBenchmarkResults)(Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetCompositorBenchmarkResults((void *)1, 2);
+    check_ptr_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", (void *)1);
+    check_uint32_parameter("IVRCompositor_026_GetCompositorBenchmarkResults", 2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetLastPosePredictionIDs, 2, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetLastPosePredictionIDs)(uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetLastPosePredictionIDs((void *)1, (void *)2);
+    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", this_ptr_value);
+    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", (void *)1);
+    check_ptr_parameter("IVRCompositor_026_GetLastPosePredictionIDs", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRCompositor_026_GetPosesForFrame, 3, FALSE, FALSE);
+    EVRCompositorError (__stdcall *capi_IVRCompositor_026_GetPosesForFrame)(uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRCompositor_026_GetPosesForFrame(1, (void *)2, 3);
+    check_ptr_parameter("IVRCompositor_026_GetPosesForFrame", this_ptr_value);
+    check_uint32_parameter("IVRCompositor_026_GetPosesForFrame", 1);
+    check_ptr_parameter("IVRCompositor_026_GetPosesForFrame", (void *)2);
+    check_uint32_parameter("IVRCompositor_026_GetPosesForFrame", 3);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_024(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_024_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_024_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_024_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_024_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_024_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_024_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_024_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_024_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayName, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayName(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayName", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_024_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_024_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_024_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_024_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_024_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_024_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_024_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_024_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_024_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayFlags, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayFlags(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayFlags", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayFlags", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayFlags", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_024_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_024_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_024_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_024_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_024_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_024_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_024_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_024_SetOverlayTexelAspect", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexelAspect", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_024_SetOverlaySortOrder", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlaySortOrder", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_024_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_024_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCurvature, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayCurvature(1, 2.0f);
+    check_ptr_parameter("IVROverlay_024_SetOverlayCurvature", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayCurvature", 1);
+    check_float_parameter("IVROverlay_024_SetOverlayCurvature", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayCurvature, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayCurvature(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayCurvature", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayCurvature", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayCurvature", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_024_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_024_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_024_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", 1);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTransformCursor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTransformCursor)(VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTransformCursor(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformCursor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTransformCursor", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTransformCursor", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTransformCursor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTransformCursor)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTransformCursor(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformCursor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTransformCursor", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTransformCursor", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_024_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_024_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_024_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_024_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_024_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_024_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_024_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_024_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_024_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_024_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_024_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_024_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_024_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_024_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_024_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_024_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_024_SetOverlayIntersectionMask", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_TriggerLaserMouseHapticVibration)(VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_TriggerLaserMouseHapticVibration(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 1);
+    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 2.0f);
+    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 3.0f);
+    check_float_parameter("IVROverlay_024_TriggerLaserMouseHapticVibration", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCursor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCursor)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayCursor(1, 2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayCursor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayCursor", 1);
+    check_uint64_parameter("IVROverlay_024_SetOverlayCursor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayCursorPositionOverride(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayCursorPositionOverride", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_ClearOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ClearOverlayCursorPositionOverride(1);
+    check_ptr_parameter("IVROverlay_024_ClearOverlayCursorPositionOverride", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_ClearOverlayCursorPositionOverride", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_024_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_024_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_024_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_024_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTexture, 9, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, VRTextureBounds_t * pTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)8);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTexture", (void *)9);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_024_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetOverlayTextureSize", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_024_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_024_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_024_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_024_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_024_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_024_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_024_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_024_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_024_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_024_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_024_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_024_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ShowKeyboard(1, 2, 3, (void *)4, 5, (void *)6, 7);
+    check_ptr_parameter("IVROverlay_024_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 2);
+    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 3);
+    check_ptr_parameter("IVROverlay_024_ShowKeyboard", (void *)4);
+    check_uint32_parameter("IVROverlay_024_ShowKeyboard", 5);
+    check_ptr_parameter("IVROverlay_024_ShowKeyboard", (void *)6);
+    check_uint64_parameter("IVROverlay_024_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_024_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ShowKeyboardForOverlay(1, 2, 3, 4, (void *)5, 6, (void *)7, 8);
+    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 3);
+    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 4);
+    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", (void *)5);
+    check_uint32_parameter("IVROverlay_024_ShowKeyboardForOverlay", 6);
+    check_ptr_parameter("IVROverlay_024_ShowKeyboardForOverlay", (void *)7);
+    check_uint64_parameter("IVROverlay_024_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_024_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_024_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_024_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_024_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_024_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_HideKeyboard();
+    check_ptr_parameter("IVROverlay_024_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_024_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_024_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_024_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_024_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_ShowMessageOverlay, 6, FALSE, FALSE);
+    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_024_ShowMessageOverlay)(const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
+    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)4);
+    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)5);
+    check_ptr_parameter("IVROverlay_024_ShowMessageOverlay", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVROverlay_024_CloseMessageOverlay, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_024_CloseMessageOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_024_CloseMessageOverlay();
+    check_ptr_parameter("IVROverlay_024_CloseMessageOverlay", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
 void test_capi_thunks_IVRSystem_021(void)
 {
     struct thunk *t = alloc_thunks(1);
diff --git a/vrclient_x64/tests/main_autogen.c b/vrclient_x64/tests/main_autogen.c
index c424da86..c2c2637e 100644
--- a/vrclient_x64/tests/main_autogen.c
+++ b/vrclient_x64/tests/main_autogen.c
@@ -10,10 +10,10 @@ int main(void)
     test_capi_thunks_IVRSettings_003();
     test_capi_thunks_IVRChaperone_004();
     test_capi_thunks_IVRChaperoneSetup_006();
-    test_capi_thunks_IVRCompositor_026();
+    test_capi_thunks_IVRCompositor_027();
     test_capi_thunks_IVRHeadsetView_001();
     test_capi_thunks_IVRNotifications_002();
-    test_capi_thunks_IVROverlay_024();
+    test_capi_thunks_IVROverlay_025();
     test_capi_thunks_IVROverlayView_003();
     test_capi_thunks_IVRRenderModels_006();
     test_capi_thunks_IVRExtendedDisplay_001();
@@ -24,6 +24,8 @@ int main(void)
     test_capi_thunks_IVRInput_010();
     test_capi_thunks_IVRIOBuffer_002();
     test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVRCompositor_026();
+    test_capi_thunks_IVROverlay_024();
     test_capi_thunks_IVRSystem_021();
     test_capi_thunks_IVRChaperone_003();
     test_capi_thunks_IVRControlPanel_006();
diff --git a/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp b/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp
index 66974b15..da16fad4 100644
--- a/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp b/vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp
index 471449e9..f05df6a7 100644
--- a/vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_004.cpp b/vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_004.cpp
index 6f0c0fbe..cb5b59de 100644
--- a/vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_004.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_004.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp b/vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp
index e780f242..0c8636ce 100644
--- a/vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRClientCore_IVRClientCore_003.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.cpp
new file mode 100644
index 00000000..829a6b3e
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.cpp
@@ -0,0 +1,269 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRCompositor_IVRCompositor_027.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+void cppIVRCompositor_IVRCompositor_027_SetTrackingSpace(void *linux_side, ETrackingUniverseOrigin eOrigin)
+{
+    ((IVRCompositor*)linux_side)->SetTrackingSpace((vr::ETrackingUniverseOrigin)eOrigin);
+}
+
+vr::ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_027_GetTrackingSpace(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetTrackingSpace();
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_WaitGetPoses(void *linux_side, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    return ((IVRCompositor*)linux_side)->WaitGetPoses((vr::TrackedDevicePose_t *)pRenderPoseArray, (uint32_t)unRenderPoseArrayCount, (vr::TrackedDevicePose_t *)pGamePoseArray, (uint32_t)unGamePoseArrayCount);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPoses(void *linux_side, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    return ((IVRCompositor*)linux_side)->GetLastPoses((vr::TrackedDevicePose_t *)pRenderPoseArray, (uint32_t)unRenderPoseArrayCount, (vr::TrackedDevicePose_t *)pGamePoseArray, (uint32_t)unGamePoseArrayCount);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    return ((IVRCompositor*)linux_side)->GetLastPoseForTrackedDeviceIndex((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::TrackedDevicePose_t *)pOutputPose, (vr::TrackedDevicePose_t *)pOutputGamePose);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_Submit(void *linux_side, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    return ((IVRCompositor*)linux_side)->Submit((vr::EVREye)eEye, (const vr::Texture_t *)pTexture, (const vr::VRTextureBounds_t *)pBounds, (vr::EVRSubmitFlags)nSubmitFlags);
+}
+
+void cppIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ClearLastSubmittedFrame();
+}
+
+void cppIVRCompositor_IVRCompositor_027_PostPresentHandoff(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->PostPresentHandoff();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_GetFrameTiming(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    return ((IVRCompositor*)linux_side)->GetFrameTiming((vr::Compositor_FrameTiming *)pTiming, (uint32_t)unFramesAgo);
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_027_GetFrameTimings(void *linux_side, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    return ((IVRCompositor*)linux_side)->GetFrameTimings((vr::Compositor_FrameTiming *)pTiming, (uint32_t)nFrames);
+}
+
+float cppIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetFrameTimeRemaining();
+}
+
+void cppIVRCompositor_IVRCompositor_027_GetCumulativeStats(void *linux_side, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    ((IVRCompositor*)linux_side)->GetCumulativeStats((vr::Compositor_CumulativeStats *)pStats, (uint32_t)nStatsSizeInBytes);
+}
+
+void cppIVRCompositor_IVRCompositor_027_FadeToColor(void *linux_side, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    ((IVRCompositor*)linux_side)->FadeToColor((float)fSeconds, (float)fRed, (float)fGreen, (float)fBlue, (float)fAlpha, (bool)bBackground);
+}
+
+vr::HmdColor_t cppIVRCompositor_IVRCompositor_027_GetCurrentFadeColor(void *linux_side, bool bBackground)
+{
+    return ((IVRCompositor*)linux_side)->GetCurrentFadeColor((bool)bBackground);
+}
+
+void cppIVRCompositor_IVRCompositor_027_FadeGrid(void *linux_side, float fSeconds, bool bFadeGridIn)
+{
+    ((IVRCompositor*)linux_side)->FadeGrid((float)fSeconds, (bool)bFadeGridIn);
+}
+
+float cppIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetCurrentGridAlpha();
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_SetSkyboxOverride(void *linux_side, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    return ((IVRCompositor*)linux_side)->SetSkyboxOverride((const vr::Texture_t *)pTextures, (uint32_t)unTextureCount);
+}
+
+void cppIVRCompositor_IVRCompositor_027_ClearSkyboxOverride(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ClearSkyboxOverride();
+}
+
+void cppIVRCompositor_IVRCompositor_027_CompositorBringToFront(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorBringToFront();
+}
+
+void cppIVRCompositor_IVRCompositor_027_CompositorGoToBack(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorGoToBack();
+}
+
+void cppIVRCompositor_IVRCompositor_027_CompositorQuit(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorQuit();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_IsFullscreen(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsFullscreen();
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetCurrentSceneFocusProcess();
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_027_GetLastFrameRenderer(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->GetLastFrameRenderer();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_CanRenderScene(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->CanRenderScene();
+}
+
+void cppIVRCompositor_IVRCompositor_027_ShowMirrorWindow(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ShowMirrorWindow();
+}
+
+void cppIVRCompositor_IVRCompositor_027_HideMirrorWindow(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->HideMirrorWindow();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsMirrorWindowVisible();
+}
+
+void cppIVRCompositor_IVRCompositor_027_CompositorDumpImages(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->CompositorDumpImages();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->ShouldAppRenderWithLowResources();
+}
+
+void cppIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn(void *linux_side, bool bOverride)
+{
+    ((IVRCompositor*)linux_side)->ForceInterleavedReprojectionOn((bool)bOverride);
+}
+
+void cppIVRCompositor_IVRCompositor_027_ForceReconnectProcess(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ForceReconnectProcess();
+}
+
+void cppIVRCompositor_IVRCompositor_027_SuspendRendering(void *linux_side, bool bSuspend)
+{
+    ((IVRCompositor*)linux_side)->SuspendRendering((bool)bSuspend);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11(void *linux_side, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    return ((IVRCompositor*)linux_side)->GetMirrorTextureD3D11((vr::EVREye)eEye, (void *)pD3D11DeviceOrResource, (void **)ppD3D11ShaderResourceView);
+}
+
+void cppIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11(void *linux_side, void * pD3D11ShaderResourceView)
+{
+    ((IVRCompositor*)linux_side)->ReleaseMirrorTextureD3D11((void *)pD3D11ShaderResourceView);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetMirrorTextureGL(void *linux_side, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    return ((IVRCompositor*)linux_side)->GetMirrorTextureGL((vr::EVREye)eEye, (vr::glUInt_t *)pglTextureId, (vr::glSharedTextureHandle_t *)pglSharedTextureHandle);
+}
+
+bool cppIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture(void *linux_side, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    return ((IVRCompositor*)linux_side)->ReleaseSharedGLTexture((vr::glUInt_t)glTextureId, (vr::glSharedTextureHandle_t)glSharedTextureHandle);
+}
+
+void cppIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    ((IVRCompositor*)linux_side)->LockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
+}
+
+void cppIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess(void *linux_side, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    ((IVRCompositor*)linux_side)->UnlockGLSharedTextureForAccess((vr::glSharedTextureHandle_t)glSharedTextureHandle);
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired(void *linux_side, char * pchValue, uint32_t unBufferSize)
+{
+    return ((IVRCompositor*)linux_side)->GetVulkanInstanceExtensionsRequired((char *)pchValue, (uint32_t)unBufferSize);
+}
+
+uint32_t cppIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired(void *linux_side, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+{
+    return ((IVRCompositor*)linux_side)->GetVulkanDeviceExtensionsRequired((VkPhysicalDevice_T *)pPhysicalDevice, (char *)pchValue, (uint32_t)unBufferSize);
+}
+
+void cppIVRCompositor_IVRCompositor_027_SetExplicitTimingMode(void *linux_side, EVRCompositorTimingMode eTimingMode)
+{
+    ((IVRCompositor*)linux_side)->SetExplicitTimingMode((vr::EVRCompositorTimingMode)eTimingMode);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->SubmitExplicitTimingData();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsMotionSmoothingEnabled();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsMotionSmoothingSupported();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading(void *linux_side)
+{
+    return ((IVRCompositor*)linux_side)->IsCurrentSceneFocusAppLoading();
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_SetStageOverride_Async(void *linux_side, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings)
+{
+    return ((IVRCompositor*)linux_side)->SetStageOverride_Async((const char *)pchRenderModelPath, (const vr::HmdMatrix34_t *)pTransform, (const vr::Compositor_StageRenderSettings *)pRenderSettings, (uint32_t)nSizeOfRenderSettings);
+}
+
+void cppIVRCompositor_IVRCompositor_027_ClearStageOverride(void *linux_side)
+{
+    ((IVRCompositor*)linux_side)->ClearStageOverride();
+}
+
+bool cppIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults(void *linux_side, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults)
+{
+    return ((IVRCompositor*)linux_side)->GetCompositorBenchmarkResults((vr::Compositor_BenchmarkResults *)pBenchmarkResults, (uint32_t)nSizeOfBenchmarkResults);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs(void *linux_side, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID)
+{
+    return ((IVRCompositor*)linux_side)->GetLastPosePredictionIDs((uint32_t *)pRenderPosePredictionID, (uint32_t *)pGamePosePredictionID);
+}
+
+vr::EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetPosesForFrame(void *linux_side, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
+{
+    return ((IVRCompositor*)linux_side)->GetPosesForFrame((uint32_t)unPosePredictionID, (vr::TrackedDevicePose_t *)pPoseArray, (uint32_t)unPoseArrayCount);
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.h b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.h
new file mode 100644
index 00000000..d18a5c4d
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_027.h
@@ -0,0 +1,57 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void cppIVRCompositor_IVRCompositor_027_SetTrackingSpace(void *, ETrackingUniverseOrigin);
+extern ETrackingUniverseOrigin cppIVRCompositor_IVRCompositor_027_GetTrackingSpace(void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_WaitGetPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPoses(void *, TrackedDevicePose_t *, uint32_t, TrackedDevicePose_t *, uint32_t);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(void *, TrackedDeviceIndex_t, TrackedDevicePose_t *, TrackedDevicePose_t *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_Submit(void *, EVREye, Texture_t *, VRTextureBounds_t *, EVRSubmitFlags);
+extern void cppIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame(void *);
+extern void cppIVRCompositor_IVRCompositor_027_PostPresentHandoff(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_GetFrameTiming(void *, Compositor_FrameTiming *, uint32_t);
+extern uint32_t cppIVRCompositor_IVRCompositor_027_GetFrameTimings(void *, Compositor_FrameTiming *, uint32_t);
+extern float cppIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining(void *);
+extern void cppIVRCompositor_IVRCompositor_027_GetCumulativeStats(void *, Compositor_CumulativeStats *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_027_FadeToColor(void *, float, float, float, float, float, bool);
+extern HmdColor_t cppIVRCompositor_IVRCompositor_027_GetCurrentFadeColor(void *, bool);
+extern void cppIVRCompositor_IVRCompositor_027_FadeGrid(void *, float, bool);
+extern float cppIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha(void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_SetSkyboxOverride(void *, Texture_t *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_027_ClearSkyboxOverride(void *);
+extern void cppIVRCompositor_IVRCompositor_027_CompositorBringToFront(void *);
+extern void cppIVRCompositor_IVRCompositor_027_CompositorGoToBack(void *);
+extern void cppIVRCompositor_IVRCompositor_027_CompositorQuit(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_IsFullscreen(void *);
+extern uint32_t cppIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess(void *);
+extern uint32_t cppIVRCompositor_IVRCompositor_027_GetLastFrameRenderer(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_CanRenderScene(void *);
+extern void cppIVRCompositor_IVRCompositor_027_ShowMirrorWindow(void *);
+extern void cppIVRCompositor_IVRCompositor_027_HideMirrorWindow(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible(void *);
+extern void cppIVRCompositor_IVRCompositor_027_CompositorDumpImages(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources(void *);
+extern void cppIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn(void *, bool);
+extern void cppIVRCompositor_IVRCompositor_027_ForceReconnectProcess(void *);
+extern void cppIVRCompositor_IVRCompositor_027_SuspendRendering(void *, bool);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11(void *, EVREye, void *, void **);
+extern void cppIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11(void *, void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetMirrorTextureGL(void *, EVREye, glUInt_t *, glSharedTextureHandle_t *);
+extern bool cppIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture(void *, glUInt_t, glSharedTextureHandle_t);
+extern void cppIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
+extern void cppIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess(void *, glSharedTextureHandle_t);
+extern uint32_t cppIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired(void *, char *, uint32_t);
+extern uint32_t cppIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired(void *, VkPhysicalDevice_T *, char *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_027_SetExplicitTimingMode(void *, EVRCompositorTimingMode);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading(void *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_SetStageOverride_Async(void *, const char *, HmdMatrix34_t *, Compositor_StageRenderSettings *, uint32_t);
+extern void cppIVRCompositor_IVRCompositor_027_ClearStageOverride(void *);
+extern bool cppIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults(void *, Compositor_BenchmarkResults *, uint32_t);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs(void *, uint32_t *, uint32_t *);
+extern EVRCompositorError cppIVRCompositor_IVRCompositor_027_GetPosesForFrame(void *, uint32_t, TrackedDevicePose_t *, uint32_t);
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp b/vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp
index 54e77fa4..3c8eb936 100644
--- a/vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp b/vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp
index bb847665..40273e6b 100644
--- a/vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRExtendedDisplay_IVRExtendedDisplay_001.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.cpp b/vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.cpp
index 03e51f31..bacf96b7 100644
--- a/vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRHeadsetView_IVRHeadsetView_001.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp b/vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp
index b042f123..91b07187 100644
--- a/vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRIOBuffer_IVRIOBuffer_002.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp
index 037218c7..bf67b776 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/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_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputDigitalActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputDigitalActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputDigitalActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputAnalogActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputAnalogActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputAnalogActionData_t_1168_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_11415 * 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_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputPoseActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputPoseActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputPoseActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputPoseActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputPoseActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputPoseActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_11415 * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1168 * pActionData, uint32_t unActionDataSize)
 {
     InputSkeletalActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputSkeletalActionData_t_11415_win_to_lin(pActionData, &lin);
+        struct_InputSkeletalActionData_t_1168_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_11415_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputSkeletalActionData_t_1168_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.h b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.h
index 1371bf16..6a831b1f 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_010.h
+++ b/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_11415 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_11415 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_11415 *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1168 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_010_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1168 *, 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 *);
diff --git a/vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp b/vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp
index fb25d5f3..ff632abb 100644
--- a/vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.cpp b/vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.cpp
index 8808c5ab..d22e5406 100644
--- a/vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVROverlayView_IVROverlayView_003.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/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_11415_win_to_lin(pvrEvent, &lin);
+        struct_VREvent_t_1168_win_to_lin(pvrEvent, &lin);
     ((IVROverlayView*)linux_side)->PostOverlayEvent((vr::VROverlayHandle_t)ulOverlayHandle, pvrEvent ? &lin : nullptr);
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.cpp b/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.cpp
new file mode 100644
index 00000000..72bd6789
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.cpp
@@ -0,0 +1,416 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVROverlay_IVROverlay_025.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_DestroyOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->DestroyOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+uint32_t cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_GetOverlayErrorNameFromEnum(void *linux_side, EVROverlayError error)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayErrorNameFromEnum((vr::EVROverlayError)error);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_GetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_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_025_SetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float)fAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float)fTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_SetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float)fCurvature);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfCurvature);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_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_025_GetOverlayTransformOverlayRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTransformOverlayRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayHandle_t *)ulOverlayHandleParent, (vr::HmdMatrix34_t *)pmatParentOverlayToOverlayTransform);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative(void *linux_side, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTransformOverlayRelative((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VROverlayHandle_t)ulOverlayHandleParent, (const vr::HmdMatrix34_t *)pmatParentOverlayToOverlayTransform);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_ShowOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ShowOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_HideOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->HideOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+bool cppIVROverlay_IVROverlay_025_IsOverlayVisible(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsOverlayVisible((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates(void *linux_side, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    return ((IVROverlay*)linux_side)->GetTransformForOverlayCoordinates((vr::VROverlayHandle_t)ulOverlayHandle, (vr::ETrackingUniverseOrigin)eTrackingOrigin, (vr::HmdVector2_t)coordinatesInOverlay, (vr::HmdMatrix34_t *)pmatTransform);
+}
+
+bool cppIVROverlay_IVROverlay_025_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent)
+{
+    VREvent_t lin;
+    bool _ret;
+    if(pEvent)
+        struct_VREvent_t_1168_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_1168_lin_to_win(&lin, pEvent, uncbVREvent);
+    return _ret;
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_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_025_IsHoverTargetOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsHoverTargetOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_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_025_ClearOverlayCursorPositionOverride(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ClearOverlayCursorPositionOverride((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_ClearOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ClearOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_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_025_ReleaseNativeOverlayHandle(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    return ((IVROverlay*)linux_side)->ReleaseNativeOverlayHandle((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pNativeTextureHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_IsDashboardVisible(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->IsDashboardVisible();
+}
+
+bool cppIVROverlay_IVROverlay_025_IsActiveDashboardOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsActiveDashboardOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_ShowDashboard(void *linux_side, const char * pchOverlayToShow)
+{
+    ((IVROverlay*)linux_side)->ShowDashboard((const char *)pchOverlayToShow);
+}
+
+vr::TrackedDeviceIndex_t cppIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->GetPrimaryDashboardDevice();
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_025_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_025_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_025_GetKeyboardText(void *linux_side, char * pchText, uint32_t cchText)
+{
+    return ((IVROverlay*)linux_side)->GetKeyboardText((char *)pchText, (uint32_t)cchText);
+}
+
+void cppIVROverlay_IVROverlay_025_HideKeyboard(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->HideKeyboard();
+}
+
+void cppIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute(void *linux_side, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    ((IVROverlay*)linux_side)->SetKeyboardTransformAbsolute((vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToKeyboardTransform);
+}
+
+void cppIVROverlay_IVROverlay_025_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_025_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_025_CloseMessageOverlay(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->CloseMessageOverlay();
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.h b/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.h
new file mode 100644
index 00000000..b9d03eaa
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_025.h
@@ -0,0 +1,85 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVROverlayError cppIVROverlay_IVROverlay_025_FindOverlay(void *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_CreateOverlay(void *, const char *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_DestroyOverlay(void *, VROverlayHandle_t);
+extern uint32_t cppIVROverlay_IVROverlay_025_GetOverlayKey(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern uint32_t cppIVROverlay_IVROverlay_025_GetOverlayName(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayName(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayImageData(void *, VROverlayHandle_t, void *, uint32_t, uint32_t *, uint32_t *);
+extern const char * cppIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum(void *, EVROverlayError);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayRenderingPid(void *, VROverlayHandle_t, uint32_t);
+extern uint32_t cppIVROverlay_IVROverlay_025_GetOverlayRenderingPid(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayFlags(void *, VROverlayHandle_t, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayColor(void *, VROverlayHandle_t, float, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayColor(void *, VROverlayHandle_t, float *, float *, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayAlpha(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayAlpha(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTexelAspect(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTexelAspect(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayWidthInMeters(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayWidthInMeters(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayCurvature(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayCurvature(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformType(void *, VROverlayHandle_t, VROverlayTransformType *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, char *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTransformCursor(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTransformProjection(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *, VROverlayProjection_t *, EVREye);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_ShowOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_HideOverlay(void *, VROverlayHandle_t);
+extern bool cppIVROverlay_IVROverlay_025_IsOverlayVisible(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
+extern bool cppIVROverlay_IVROverlay_025_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1168 *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern bool cppIVROverlay_IVROverlay_025_ComputeOverlayIntersection(void *, VROverlayHandle_t, VROverlayIntersectionParams_t *, VROverlayIntersectionResults_t *);
+extern bool cppIVROverlay_IVROverlay_025_IsHoverTargetOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayIntersectionMask(void *, VROverlayHandle_t, VROverlayIntersectionMaskPrimitive_t *, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration(void *, VROverlayHandle_t, float, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayCursor(void *, VROverlayHandle_t, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayTexture(void *, VROverlayHandle_t, Texture_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_ClearOverlayTexture(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayRaw(void *, VROverlayHandle_t, void *, uint32_t, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetOverlayFromFile(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTexture(void *, VROverlayHandle_t, void **, void *, uint32_t *, uint32_t *, uint32_t *, ETextureType *, EColorSpace *, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle(void *, VROverlayHandle_t, void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetOverlayTextureSize(void *, VROverlayHandle_t, uint32_t *, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_CreateDashboardOverlay(void *, const char *, const char *, VROverlayHandle_t *, VROverlayHandle_t *);
+extern bool cppIVROverlay_IVROverlay_025_IsDashboardVisible(void *);
+extern bool cppIVROverlay_IVROverlay_025_IsActiveDashboardOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t *);
+extern void cppIVROverlay_IVROverlay_025_ShowDashboard(void *, const char *);
+extern TrackedDeviceIndex_t cppIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice(void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_ShowKeyboard(void *, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_025_ShowKeyboardForOverlay(void *, VROverlayHandle_t, EGamepadTextInputMode, EGamepadTextInputLineMode, uint32_t, const char *, uint32_t, const char *, uint64_t);
+extern uint32_t cppIVROverlay_IVROverlay_025_GetKeyboardText(void *, char *, uint32_t);
+extern void cppIVROverlay_IVROverlay_025_HideKeyboard(void *);
+extern void cppIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute(void *, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern void cppIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay(void *, VROverlayHandle_t, HmdRect2_t);
+extern VRMessageOverlayResponse cppIVROverlay_IVROverlay_025_ShowMessageOverlay(void *, const char *, const char *, const char *, const char *, const char *, const char *);
+extern void cppIVROverlay_IVROverlay_025_CloseMessageOverlay(void *);
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
index 2ec5ad28..7e84369c 100644
--- a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/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_11415 ** ppRenderModel)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1168 ** 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_11415_wrap(lin);
+        *ppRenderModel = struct_RenderModel_t_1168_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_11415 * pRenderModel)
+void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1168 * pRenderModel)
 {
-    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_11415_unwrap(pRenderModel));
+    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1168_unwrap(pRenderModel));
 }
 
-vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_11415 ** ppTexture)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1168 ** 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_11415_wrap(lin);
+        *ppTexture = struct_RenderModel_TextureMap_t_1168_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_11415 * pTexture)
+void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1168 * pTexture)
 {
-    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_11415_unwrap(pTexture));
+    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1168_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_11415_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_1168_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;
 }
diff --git a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h b/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h
index 739cd8be..dc5e52a6 100644
--- a/vrclient_x64/vrclient_x64/cppIVRRenderModels_IVRRenderModels_006.h
+++ b/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_11415 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_11415 *);
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_11415 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_11415 *);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1168 **);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1168 *);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1168 **);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1168 *);
 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 *);
diff --git a/vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp b/vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp
index 047f104f..2f076e3a 100644
--- a/vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRResources_IVRResources_001.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp b/vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp
index 503a8169..aad8ed96 100644
--- a/vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRScreenshots_IVRScreenshots_001.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_003.cpp b/vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_003.cpp
index ed939550..38c1137c 100644
--- a/vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_003.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_003.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.cpp b/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.cpp
index a8e2c0d2..f9f02775 100644
--- a/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/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_11415 * pEvent, uint32_t uncbVREvent)
+bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *linux_side, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent)
 {
     VREvent_t lin;
     bool _ret;
     if(pEvent)
-        struct_VREvent_t_11415_win_to_lin(pEvent, &lin);
+        struct_VREvent_t_1168_win_to_lin(pEvent, &lin);
     _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
     if(pEvent)
-        struct_VREvent_t_11415_lin_to_win(&lin, pEvent, uncbVREvent);
+        struct_VREvent_t_1168_lin_to_win(&lin, pEvent, uncbVREvent);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_11415 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
 {
     VREvent_t lin;
     bool _ret;
     if(pEvent)
-        struct_VREvent_t_11415_win_to_lin(pEvent, &lin);
+        struct_VREvent_t_1168_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_11415_lin_to_win(&lin, pEvent, uncbVREvent);
+        struct_VREvent_t_1168_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_11415 * pControllerState, uint32_t unControllerStateSize)
+bool cppIVRSystem_IVRSystem_022_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1168 * pControllerState, uint32_t unControllerStateSize)
 {
     VRControllerState001_t lin;
     bool _ret;
     if(pControllerState)
-        struct_VRControllerState001_t_11415_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_1168_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_11415_lin_to_win(&lin, pControllerState, unControllerStateSize);
+        struct_VRControllerState001_t_1168_lin_to_win(&lin, pControllerState, unControllerStateSize);
     return _ret;
 }
 
-bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_11415 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1168 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     VRControllerState001_t lin;
     bool _ret;
     if(pControllerState)
-        struct_VRControllerState001_t_11415_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_1168_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_11415_lin_to_win(&lin, pControllerState, unControllerStateSize);
+        struct_VRControllerState001_t_1168_lin_to_win(&lin, pControllerState, unControllerStateSize);
     return _ret;
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.h b/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.h
index 6f6db001..0f04b928 100644
--- a/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_022.h
+++ b/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_11415 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_11415 *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_022_PollNextEvent(void *, winVREvent_t_1168 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_022_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1168 *, 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_11415 *, uint32_t);
-extern bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_11415 *, uint32_t, TrackedDevicePose_t *);
+extern bool cppIVRSystem_IVRSystem_022_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1168 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1168 *, 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);
diff --git a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp
index c3ab2cec..5a2fda0b 100644
--- a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.14.15/ivrclientcore.h"
+#include "openvr_v1.16.8/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_11415 * 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_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_11415_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1168_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_11415_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1168_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_11415 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_11415_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1168_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_11415_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1168_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_11415 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_11415_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1168_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_11415_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1168_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
     return _ret;
 }
 
diff --git a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.h b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.h
index 46d89a01..9db1f74d 100644
--- a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.h
+++ b/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_11415 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1168 *, 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_11415 *, uint32_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_11415 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_1168 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1168 *, 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 *);
diff --git a/vrclient_x64/vrclient_x64/struct_converters.h b/vrclient_x64/vrclient_x64/struct_converters.h
index b513e016..d483423f 100644
--- a/vrclient_x64/vrclient_x64/struct_converters.h
+++ b/vrclient_x64/vrclient_x64/struct_converters.h
@@ -1,3 +1,37 @@
+typedef struct winVRVulkanTextureArrayData_t_1168 winVRVulkanTextureArrayData_t_1168;
+extern void struct_VRVulkanTextureArrayData_t_1168_lin_to_win(void *l, void *w);
+extern void struct_VRVulkanTextureArrayData_t_1168_win_to_lin(void *w, void *l);
+typedef struct winVREvent_t_1168 winVREvent_t_1168;
+extern void struct_VREvent_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_VREvent_t_1168_win_to_lin(void *w, void *l);
+typedef struct winVRControllerState001_t_1168 winVRControllerState001_t_1168;
+extern void struct_VRControllerState001_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_VRControllerState001_t_1168_win_to_lin(void *w, void *l);
+typedef struct winCameraVideoStreamFrameHeader_t_1168 winCameraVideoStreamFrameHeader_t_1168;
+extern void struct_CameraVideoStreamFrameHeader_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_CameraVideoStreamFrameHeader_t_1168_win_to_lin(void *w, void *l);
+typedef struct winRenderModel_TextureMap_t_1168 winRenderModel_TextureMap_t_1168;
+extern void struct_RenderModel_TextureMap_t_1168_lin_to_win(void *l, void *w);
+extern void struct_RenderModel_TextureMap_t_1168_win_to_lin(void *w, void *l);
+extern struct winRenderModel_TextureMap_t_1168 *struct_RenderModel_TextureMap_t_1168_wrap(void *l);
+extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1168_unwrap(winRenderModel_TextureMap_t_1168 *w);
+typedef struct winRenderModel_t_1168 winRenderModel_t_1168;
+extern void struct_RenderModel_t_1168_lin_to_win(void *l, void *w);
+extern void struct_RenderModel_t_1168_win_to_lin(void *w, void *l);
+extern struct winRenderModel_t_1168 *struct_RenderModel_t_1168_wrap(void *l);
+extern RenderModel_t *struct_RenderModel_t_1168_unwrap(winRenderModel_t_1168 *w);
+typedef struct winInputAnalogActionData_t_1168 winInputAnalogActionData_t_1168;
+extern void struct_InputAnalogActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputAnalogActionData_t_1168_win_to_lin(void *w, void *l);
+typedef struct winInputDigitalActionData_t_1168 winInputDigitalActionData_t_1168;
+extern void struct_InputDigitalActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputDigitalActionData_t_1168_win_to_lin(void *w, void *l);
+typedef struct winInputPoseActionData_t_1168 winInputPoseActionData_t_1168;
+extern void struct_InputPoseActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputPoseActionData_t_1168_win_to_lin(void *w, void *l);
+typedef struct winInputSkeletalActionData_t_1168 winInputSkeletalActionData_t_1168;
+extern void struct_InputSkeletalActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputSkeletalActionData_t_1168_win_to_lin(void *w, void *l);
 typedef struct winVRVulkanTextureArrayData_t_11415 winVRVulkanTextureArrayData_t_11415;
 extern void struct_VRVulkanTextureArrayData_t_11415_lin_to_win(void *l, void *w);
 extern void struct_VRVulkanTextureArrayData_t_11415_win_to_lin(void *w, void *l);
diff --git a/vrclient_x64/vrclient_x64/struct_converters_1168.cpp b/vrclient_x64/vrclient_x64/struct_converters_1168.cpp
new file mode 100644
index 00000000..2ff2fbe8
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/struct_converters_1168.cpp
@@ -0,0 +1,358 @@
+#include <stdlib.h>
+#include <string.h>
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.16.8/openvr.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+#pragma pack(push, 8)
+struct winVRVulkanTextureArrayData_t_1168 {
+    uint32_t m_unArrayIndex;
+    uint32_t m_unArraySize;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VRVulkanTextureArrayData_t_1168_lin_to_win(void *l, void *w)
+{
+    struct winVRVulkanTextureArrayData_t_1168 *win = (struct winVRVulkanTextureArrayData_t_1168 *)w;
+    VRVulkanTextureArrayData_t *lin = (VRVulkanTextureArrayData_t *)l;
+    win->m_unArrayIndex = lin->m_unArrayIndex;
+    win->m_unArraySize = lin->m_unArraySize;
+}
+
+void struct_VRVulkanTextureArrayData_t_1168_win_to_lin(void *w, void *l)
+{
+    struct winVRVulkanTextureArrayData_t_1168 *win = (struct winVRVulkanTextureArrayData_t_1168 *)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_1168 {
+    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_1168_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winVREvent_t_1168 *win = (struct winVREvent_t_1168 *)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_1168_win_to_lin(void *w, void *l)
+{
+    struct winVREvent_t_1168 *win = (struct winVREvent_t_1168 *)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_1168 {
+    uint32_t unPacketNum;
+    uint64_t ulButtonPressed;
+    uint64_t ulButtonTouched;
+    vr::VRControllerAxis_t rAxis[5];
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VRControllerState001_t_1168_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winVRControllerState001_t_1168 *win = (struct winVRControllerState001_t_1168 *)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_1168_win_to_lin(void *w, void *l)
+{
+    struct winVRControllerState001_t_1168 *win = (struct winVRControllerState001_t_1168 *)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_1168 {
+    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_1168_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winCameraVideoStreamFrameHeader_t_1168 *win = (struct winCameraVideoStreamFrameHeader_t_1168 *)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_1168_win_to_lin(void *w, void *l)
+{
+    struct winCameraVideoStreamFrameHeader_t_1168 *win = (struct winCameraVideoStreamFrameHeader_t_1168 *)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_1168 {
+    uint16_t unWidth;
+    uint16_t unHeight;
+    const uint8_t * rubTextureMapData;
+    vr::EVRRenderModelTextureFormat format;
+
+    RenderModel_TextureMap_t *linux_side;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_RenderModel_TextureMap_t_1168_lin_to_win(void *l, void *w)
+{
+    struct winRenderModel_TextureMap_t_1168 *win = (struct winRenderModel_TextureMap_t_1168 *)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;
+}
+
+void struct_RenderModel_TextureMap_t_1168_win_to_lin(void *w, void *l)
+{
+    struct winRenderModel_TextureMap_t_1168 *win = (struct winRenderModel_TextureMap_t_1168 *)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;
+}
+
+struct winRenderModel_TextureMap_t_1168 *struct_RenderModel_TextureMap_t_1168_wrap(void *l)
+{
+    struct winRenderModel_TextureMap_t_1168 *win = (struct winRenderModel_TextureMap_t_1168 *)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->linux_side = lin;
+    return win;
+}
+
+struct RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1168_unwrap(winRenderModel_TextureMap_t_1168 *w)
+{
+    RenderModel_TextureMap_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winRenderModel_t_1168 {
+    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_1168_lin_to_win(void *l, void *w)
+{
+    struct winRenderModel_t_1168 *win = (struct winRenderModel_t_1168 *)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_1168_win_to_lin(void *w, void *l)
+{
+    struct winRenderModel_t_1168 *win = (struct winRenderModel_t_1168 *)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_1168 *struct_RenderModel_t_1168_wrap(void *l)
+{
+    struct winRenderModel_t_1168 *win = (struct winRenderModel_t_1168 *)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_1168_unwrap(winRenderModel_t_1168 *w)
+{
+    RenderModel_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winInputAnalogActionData_t_1168 {
+    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_1168_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputAnalogActionData_t_1168 *win = (struct winInputAnalogActionData_t_1168 *)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_1168_win_to_lin(void *w, void *l)
+{
+    struct winInputAnalogActionData_t_1168 *win = (struct winInputAnalogActionData_t_1168 *)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_1168 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    bool bState;
+    bool bChanged;
+    float fUpdateTime;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputDigitalActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputDigitalActionData_t_1168 *win = (struct winInputDigitalActionData_t_1168 *)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_1168_win_to_lin(void *w, void *l)
+{
+    struct winInputDigitalActionData_t_1168 *win = (struct winInputDigitalActionData_t_1168 *)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_1168 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    vr::TrackedDevicePose_t pose __attribute__((aligned(4)));
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputPoseActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputPoseActionData_t_1168 *win = (struct winInputPoseActionData_t_1168 *)w;
+    InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+    win->pose = lin->pose;
+}
+
+void struct_InputPoseActionData_t_1168_win_to_lin(void *w, void *l)
+{
+    struct winInputPoseActionData_t_1168 *win = (struct winInputPoseActionData_t_1168 *)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_1168 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputSkeletalActionData_t_1168_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputSkeletalActionData_t_1168 *win = (struct winInputSkeletalActionData_t_1168 *)w;
+    InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+}
+
+void struct_InputSkeletalActionData_t_1168_win_to_lin(void *w, void *l)
+{
+    struct winInputSkeletalActionData_t_1168 *win = (struct winInputSkeletalActionData_t_1168 *)w;
+    InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
+    lin->bActive = win->bActive;
+    lin->activeOrigin = win->activeOrigin;
+}
+
+
+}
diff --git a/vrclient_x64/vrclient_x64/vrclient_defs.h b/vrclient_x64/vrclient_x64/vrclient_defs.h
index 9aeae065..c499ff93 100644
--- a/vrclient_x64/vrclient_x64/vrclient_defs.h
+++ b/vrclient_x64/vrclient_x64/vrclient_defs.h
@@ -132,6 +132,7 @@ typedef struct VRSkeletalSummaryData_t VRSkeletalSummaryData_t;
 typedef struct InputBindingInfo_t InputBindingInfo_t;
 typedef struct VRNativeDevice_t VRNativeDevice_t;
 typedef struct VROverlayView_t VROverlayView_t;
+typedef struct VROverlayProjection_t VROverlayProjection_t;
 
 /* dereferenced structs */
 typedef struct HmdMatrix34_t
@@ -234,6 +235,13 @@ struct VRVulkanTextureData_t
     uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
 };
 
+struct VRVulkanTextureArrayData_t
+{
+    struct VRVulkanTextureData_t t;
+    uint32_t m_unArrayIndex;
+    uint32_t m_unArraySize;
+};
+
 typedef struct Texture_t
 {
     void *handle;
@@ -269,30 +277,40 @@ typedef struct VRTextureWithPoseAndDepth_t
 
 typedef enum EVRSubmitFlags
 {
-    // Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
-    Submit_Default = 0x00,
+	// Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+	Submit_Default = 0x00,
+
+	// App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+	// barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+	// vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+	Submit_LensDistortionAlreadyApplied = 0x01,
+
+	// If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+	Submit_GlRenderBuffer = 0x02,
+
+	// Do not use
+	Submit_Reserved = 0x04,
 
-    // App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
-    // barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
-    // vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
-    Submit_LensDistortionAlreadyApplied = 0x01,
+	// Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+	// This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithPose = 0x08,
 
-    // If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
-    Submit_GlRenderBuffer = 0x02,
+	// Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
+	// This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
+	Submit_TextureWithDepth = 0x10,
 
-    // Do not use
-    Submit_Reserved = 0x04,
+	// Set to indicate a discontinuity between this and the last frame.
+	// This will prevent motion smoothing from attempting to extrapolate using the pair.
+	Submit_FrameDiscontinuty = 0x20,
 
-    Submit_Screenshot = 0x04,
-    Submit_VulkanTexture = 0x04,
+	// Set to indicate that pTexture->handle is a contains VRVulkanTextureArrayData_t
+	Submit_VulkanTextureWithArrayData = 0x40,
 
-    // Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
-    // This flag can be combined with Submit_TextureWithDepth to pass a VRTextureWithPoseAndDepth_t.
-    Submit_TextureWithPose = 0x08,
+	// If the texture pointer passed in is an OpenGL Array texture, set this flag
+	Submit_GlArrayTexture = 0x80,
 
-    // Set to indicate that pTexture is a pointer to a VRTextureWithDepth_t.
-    // This flag can be combined with Submit_TextureWithPose to pass a VRTextureWithPoseAndDepth_t.
-    Submit_TextureWithDepth = 0x10,
+	// Do not use
+	Submit_Reserved2 = 0x8000,
 } EVRSubmitFlags;
 
 typedef enum EVRCompositorTimingMode
diff --git a/vrclient_x64/vrclient_x64/vrclient_main.c b/vrclient_x64/vrclient_x64/vrclient_main.c
index 59aa8b59..8706512c 100644
--- a/vrclient_x64/vrclient_x64/vrclient_main.c
+++ b/vrclient_x64/vrclient_x64/vrclient_main.c
@@ -41,8 +41,8 @@ typedef struct winRenderModel_TextureMap_t_1015 winRenderModel_TextureMap_t_1015
 
 /* this is cast to 1015 during load_linux_texture_map, so ensure they're
  * binary compatible before updating this number */
-typedef struct winRenderModel_t_11415 winRenderModel_t_11415;
-typedef struct winRenderModel_TextureMap_t_11415 winRenderModel_TextureMap_t_11415;
+typedef struct winRenderModel_t_1168 winRenderModel_t_1168;
+typedef struct winRenderModel_TextureMap_t_1168 winRenderModel_TextureMap_t_1168;
 #include "cppIVRRenderModels_IVRRenderModels_006.h"
 
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
@@ -881,6 +881,7 @@ static EVRCompositorError ivrcompositor_submit_dxvk(
         void *linux_side, EVREye eye, Texture_t *texture, VRTextureBounds_t *bounds, EVRSubmitFlags flags,
         unsigned int version, IDXGIVkInteropSurface *dxvk_surface)
 {
+    static const EVRSubmitFlags supported_flags = Submit_LensDistortionAlreadyApplied | Submit_FrameDiscontinuty;
     struct VRVulkanTextureData_t vkdata;
     IDXGIVkInteropDevice *dxvk_device;
     struct Texture_t vktexture;
@@ -895,8 +896,8 @@ static EVRCompositorError ivrcompositor_submit_dxvk(
 
     compositor_data.dxvk_device = dxvk_device;
 
-    if (flags & (Submit_TextureWithPose | Submit_TextureWithDepth))
-        FIXME("Unhandled flags %#x.\n", flags & (Submit_TextureWithPose | Submit_TextureWithDepth));
+    if (flags & ~supported_flags)
+        FIXME("Unhandled flags %#x.\n", flags);
 
     subresources.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
     subresources.baseMipLevel = 0;
@@ -950,7 +951,8 @@ static EVRCompositorError ivrcompositor_submit_vulkan(
         void *linux_side, EVREye eye, Texture_t *texture, VRTextureBounds_t *bounds, EVRSubmitFlags flags,
         unsigned int version)
 {
-    struct VRVulkanTextureData_t our_vkdata, our_depth_vkdata, *their_vkdata;
+    struct VRVulkanTextureData_t our_depth_vkdata, *their_vkdata;
+    struct VRVulkanTextureArrayData_t our_vkdata;
     VRTextureWithPoseAndDepth_t our_both;
     VRTextureWithDepth_t our_depth;
     VRTextureWithPose_t our_pose;
@@ -961,11 +963,13 @@ static EVRCompositorError ivrcompositor_submit_vulkan(
 
     their_vkdata = texture->handle;
 
-    our_vkdata = *their_vkdata;
-    our_vkdata.m_pDevice = get_native_VkDevice(our_vkdata.m_pDevice);
-    our_vkdata.m_pPhysicalDevice = get_native_VkPhysicalDevice(our_vkdata.m_pPhysicalDevice);
-    our_vkdata.m_pInstance = get_native_VkInstance(our_vkdata.m_pInstance);
-    our_vkdata.m_pQueue = get_native_VkQueue(our_vkdata.m_pQueue);
+    memcpy(&our_vkdata, their_vkdata, flags & Submit_VulkanTextureWithArrayData
+            ? sizeof(struct VRVulkanTextureArrayData_t) : sizeof(struct VRVulkanTextureData_t));
+
+    our_vkdata.t.m_pDevice = get_native_VkDevice(our_vkdata.t.m_pDevice);
+    our_vkdata.t.m_pPhysicalDevice = get_native_VkPhysicalDevice(our_vkdata.t.m_pPhysicalDevice);
+    our_vkdata.t.m_pInstance = get_native_VkInstance(our_vkdata.t.m_pInstance);
+    our_vkdata.t.m_pQueue = get_native_VkQueue(our_vkdata.t.m_pQueue);
 
     switch (flags & (Submit_TextureWithPose | Submit_TextureWithDepth))
     {
@@ -1527,7 +1531,7 @@ static EVRRenderModelError load_linux_texture_map(void *linux_side, TextureID_t
     case 5:
         return cppIVRRenderModels_IVRRenderModels_005_LoadTexture_Async(linux_side, texture_id, texture_map);
     case 6:
-        return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_11415 **)texture_map);
+        return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_1168 **)texture_map);
     }
     FIXME("Unsupported IVRRenderModels version! %u\n", version);
     return VRRenderModelError_NotSupported;
@@ -1544,7 +1548,7 @@ static void free_linux_texture_map(void *linux_side,
         cppIVRRenderModels_IVRRenderModels_005_FreeTexture(linux_side, texture_map);
         break;
     case 6:
-        cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_11415 *)texture_map);
+        cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_1168 *)texture_map);
         break;
     default:
         FIXME("Unsupported IVRRenderModels version! %u\n", version);
diff --git a/vrclient_x64/vrclient_x64/winIVRCompositor.c b/vrclient_x64/vrclient_x64/winIVRCompositor.c
index 9116eceb..4a3800fe 100644
--- a/vrclient_x64/vrclient_x64/winIVRCompositor.c
+++ b/vrclient_x64/vrclient_x64/winIVRCompositor.c
@@ -18,6 +18,525 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRCompositor_IVRCompositor_027.h"
+
+typedef struct __winIVRCompositor_IVRCompositor_027 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRCompositor_IVRCompositor_027;
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SetTrackingSpace, 8)
+void __thiscall winIVRCompositor_IVRCompositor_027_SetTrackingSpace(winIVRCompositor_IVRCompositor_027 *_this, ETrackingUniverseOrigin eOrigin)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_SetTrackingSpace(_this->linux_side, eOrigin);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetTrackingSpace, 4)
+ETrackingUniverseOrigin __thiscall winIVRCompositor_IVRCompositor_027_GetTrackingSpace(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetTrackingSpace(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_WaitGetPoses, 20)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_WaitGetPoses(winIVRCompositor_IVRCompositor_027 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_WaitGetPoses(_this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetLastPoses, 20)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetLastPoses(winIVRCompositor_IVRCompositor_027 *_this, TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetLastPoses(_this->linux_side, pRenderPoseArray, unRenderPoseArrayCount, pGamePoseArray, unGamePoseArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(winIVRCompositor_IVRCompositor_027 *_this, TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pOutputGamePose)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex(_this->linux_side, unDeviceIndex, pOutputPose, pOutputGamePose);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_Submit, 20)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_Submit(winIVRCompositor_IVRCompositor_027 *_this, EVREye eEye, Texture_t * pTexture, VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags)
+{
+    TRACE("%p\n", _this);
+    return ivrcompositor_submit(cppIVRCompositor_IVRCompositor_027_Submit, _this->linux_side, eEye, pTexture, pBounds, nSubmitFlags, 27);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_PostPresentHandoff, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_PostPresentHandoff(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    ivrcompositor_post_present_handoff(cppIVRCompositor_IVRCompositor_027_PostPresentHandoff, _this->linux_side, 27);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetFrameTiming, 12)
+bool __thiscall winIVRCompositor_IVRCompositor_027_GetFrameTiming(winIVRCompositor_IVRCompositor_027 *_this, Compositor_FrameTiming * pTiming, uint32_t unFramesAgo)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetFrameTiming(_this->linux_side, pTiming, unFramesAgo);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetFrameTimings, 12)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetFrameTimings(winIVRCompositor_IVRCompositor_027 *_this, Compositor_FrameTiming * pTiming, uint32_t nFrames)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetFrameTimings(_this->linux_side, pTiming, nFrames);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining, 4)
+float __thiscall winIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCumulativeStats, 12)
+void __thiscall winIVRCompositor_IVRCompositor_027_GetCumulativeStats(winIVRCompositor_IVRCompositor_027 *_this, Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_GetCumulativeStats(_this->linux_side, pStats, nStatsSizeInBytes);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_FadeToColor, 25)
+void __thiscall winIVRCompositor_IVRCompositor_027_FadeToColor(winIVRCompositor_IVRCompositor_027 *_this, float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_FadeToColor(_this->linux_side, fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCurrentFadeColor, 9)
+HmdColor_t *__thiscall winIVRCompositor_IVRCompositor_027_GetCurrentFadeColor(winIVRCompositor_IVRCompositor_027 *_this, HmdColor_t *_r, bool bBackground)
+{
+    TRACE("%p\n", _this);
+    *_r = cppIVRCompositor_IVRCompositor_027_GetCurrentFadeColor(_this->linux_side, bBackground);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_FadeGrid, 9)
+void __thiscall winIVRCompositor_IVRCompositor_027_FadeGrid(winIVRCompositor_IVRCompositor_027 *_this, float fSeconds, bool bFadeGridIn)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_FadeGrid(_this->linux_side, fSeconds, bFadeGridIn);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha, 4)
+float __thiscall winIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SetSkyboxOverride, 12)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_SetSkyboxOverride(winIVRCompositor_IVRCompositor_027 *_this, Texture_t * pTextures, uint32_t unTextureCount)
+{
+    TRACE("%p\n", _this);
+    return ivrcompositor_set_skybox_override(cppIVRCompositor_IVRCompositor_027_SetSkyboxOverride, _this->linux_side, pTextures, unTextureCount, 27);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ClearSkyboxOverride, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_ClearSkyboxOverride(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_ClearSkyboxOverride(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CompositorBringToFront, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_CompositorBringToFront(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_CompositorBringToFront(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CompositorGoToBack, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_CompositorGoToBack(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_CompositorGoToBack(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CompositorQuit, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_CompositorQuit(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_CompositorQuit(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsFullscreen, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_027_IsFullscreen(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_IsFullscreen(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess, 4)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetLastFrameRenderer, 4)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetLastFrameRenderer(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetLastFrameRenderer(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CanRenderScene, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_027_CanRenderScene(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_CanRenderScene(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ShowMirrorWindow, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_ShowMirrorWindow(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_ShowMirrorWindow(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_HideMirrorWindow, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_HideMirrorWindow(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_HideMirrorWindow(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_CompositorDumpImages, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_CompositorDumpImages(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_CompositorDumpImages(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn, 5)
+void __thiscall winIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn(winIVRCompositor_IVRCompositor_027 *_this, bool bOverride)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn(_this->linux_side, bOverride);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ForceReconnectProcess, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_ForceReconnectProcess(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_ForceReconnectProcess(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SuspendRendering, 5)
+void __thiscall winIVRCompositor_IVRCompositor_027_SuspendRendering(winIVRCompositor_IVRCompositor_027 *_this, bool bSuspend)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_SuspendRendering(_this->linux_side, bSuspend);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11(winIVRCompositor_IVRCompositor_027 *_this, EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11(_this->linux_side, eEye, pD3D11DeviceOrResource, ppD3D11ShaderResourceView);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11, 8)
+void __thiscall winIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11(winIVRCompositor_IVRCompositor_027 *_this, void * pD3D11ShaderResourceView)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11(_this->linux_side, pD3D11ShaderResourceView);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetMirrorTextureGL, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetMirrorTextureGL(winIVRCompositor_IVRCompositor_027 *_this, EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetMirrorTextureGL(_this->linux_side, eEye, pglTextureId, pglSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture, 12)
+bool __thiscall winIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture(winIVRCompositor_IVRCompositor_027 *_this, glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture(_this->linux_side, glTextureId, glSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess, 8)
+void __thiscall winIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_027 *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess, 8)
+void __thiscall winIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess(winIVRCompositor_IVRCompositor_027 *_this, glSharedTextureHandle_t glSharedTextureHandle)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess(_this->linux_side, glSharedTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired, 12)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired(winIVRCompositor_IVRCompositor_027 *_this, char * pchValue, uint32_t unBufferSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired, 16)
+uint32_t __thiscall winIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired(winIVRCompositor_IVRCompositor_027 *_this, VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize)
+{
+    TRACE("%p\n", _this);
+    return ivrcompositor_get_vulkan_device_extensions_required(cppIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired, _this->linux_side, pPhysicalDevice, pchValue, unBufferSize, 27);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SetExplicitTimingMode, 8)
+void __thiscall winIVRCompositor_IVRCompositor_027_SetExplicitTimingMode(winIVRCompositor_IVRCompositor_027 *_this, EVRCompositorTimingMode eTimingMode)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_SetExplicitTimingMode(_this->linux_side, eTimingMode);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData, 4)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading, 4)
+bool __thiscall winIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_SetStageOverride_Async, 20)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_SetStageOverride_Async(winIVRCompositor_IVRCompositor_027 *_this, const char * pchRenderModelPath, HmdMatrix34_t * pTransform, Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings)
+{
+    char lin_pchRenderModelPath[PATH_MAX];
+    vrclient_dos_path_to_unix_path(pchRenderModelPath, lin_pchRenderModelPath);
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_SetStageOverride_Async(_this->linux_side, pchRenderModelPath ? lin_pchRenderModelPath : NULL, pTransform, pRenderSettings, nSizeOfRenderSettings);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_ClearStageOverride, 4)
+void __thiscall winIVRCompositor_IVRCompositor_027_ClearStageOverride(winIVRCompositor_IVRCompositor_027 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRCompositor_IVRCompositor_027_ClearStageOverride(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults, 12)
+bool __thiscall winIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults(winIVRCompositor_IVRCompositor_027 *_this, Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults(_this->linux_side, pBenchmarkResults, nSizeOfBenchmarkResults);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs, 12)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs(winIVRCompositor_IVRCompositor_027 *_this, uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs(_this->linux_side, pRenderPosePredictionID, pGamePosePredictionID);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_027_GetPosesForFrame, 16)
+EVRCompositorError __thiscall winIVRCompositor_IVRCompositor_027_GetPosesForFrame(winIVRCompositor_IVRCompositor_027 *_this, uint32_t unPosePredictionID, TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    return cppIVRCompositor_IVRCompositor_027_GetPosesForFrame(_this->linux_side, unPosePredictionID, pPoseArray, unPoseArrayCount);
+}
+
+extern vtable_ptr winIVRCompositor_IVRCompositor_027_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRCompositor_IVRCompositor_027,
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SetTrackingSpace)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetTrackingSpace)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_WaitGetPoses)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetLastPoses)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_Submit)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_PostPresentHandoff)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetFrameTiming)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetFrameTimings)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCumulativeStats)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_FadeToColor)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCurrentFadeColor)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_FadeGrid)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SetSkyboxOverride)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ClearSkyboxOverride)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CompositorBringToFront)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CompositorGoToBack)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CompositorQuit)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsFullscreen)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetLastFrameRenderer)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CanRenderScene)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ShowMirrorWindow)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_HideMirrorWindow)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_CompositorDumpImages)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ForceReconnectProcess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SuspendRendering)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetMirrorTextureGL)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SetExplicitTimingMode)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_SetStageOverride_Async)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_ClearStageOverride)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs)
+        VTABLE_ADD_FUNC(winIVRCompositor_IVRCompositor_027_GetPosesForFrame)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRCompositor_IVRCompositor_027 *create_winIVRCompositor_IVRCompositor_027(void *linux_side)
+{
+    winIVRCompositor_IVRCompositor_027 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_027));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRCompositor_IVRCompositor_027_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRCompositor_IVRCompositor_027(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRCompositor_IVRCompositor_027 *create_winIVRCompositor_IVRCompositor_027_FnTable(void *linux_side)
+{
+    winIVRCompositor_IVRCompositor_027 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRCompositor_IVRCompositor_027));
+    struct thunk *thunks = alloc_thunks(51);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 51 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRCompositor_IVRCompositor_027_SetTrackingSpace, 1, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRCompositor_IVRCompositor_027_GetTrackingSpace, 0, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRCompositor_IVRCompositor_027_WaitGetPoses, 4, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRCompositor_IVRCompositor_027_GetLastPoses, 4, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRCompositor_IVRCompositor_027_GetLastPoseForTrackedDeviceIndex, 3, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRCompositor_IVRCompositor_027_Submit, 4, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRCompositor_IVRCompositor_027_ClearLastSubmittedFrame, 0, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRCompositor_IVRCompositor_027_PostPresentHandoff, 0, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVRCompositor_IVRCompositor_027_GetFrameTiming, 2, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRCompositor_IVRCompositor_027_GetFrameTimings, 2, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRCompositor_IVRCompositor_027_GetFrameTimeRemaining, 0, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRCompositor_IVRCompositor_027_GetCumulativeStats, 2, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVRCompositor_IVRCompositor_027_FadeToColor, 6, TRUE, TRUE);
+    init_thunk(&thunks[13], r, winIVRCompositor_IVRCompositor_027_GetCurrentFadeColor, 2, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVRCompositor_IVRCompositor_027_FadeGrid, 2, TRUE, FALSE);
+    init_thunk(&thunks[15], r, winIVRCompositor_IVRCompositor_027_GetCurrentGridAlpha, 0, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRCompositor_IVRCompositor_027_SetSkyboxOverride, 2, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRCompositor_IVRCompositor_027_ClearSkyboxOverride, 0, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVRCompositor_IVRCompositor_027_CompositorBringToFront, 0, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVRCompositor_IVRCompositor_027_CompositorGoToBack, 0, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVRCompositor_IVRCompositor_027_CompositorQuit, 0, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVRCompositor_IVRCompositor_027_IsFullscreen, 0, FALSE, FALSE);
+    init_thunk(&thunks[22], r, winIVRCompositor_IVRCompositor_027_GetCurrentSceneFocusProcess, 0, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVRCompositor_IVRCompositor_027_GetLastFrameRenderer, 0, FALSE, FALSE);
+    init_thunk(&thunks[24], r, winIVRCompositor_IVRCompositor_027_CanRenderScene, 0, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVRCompositor_IVRCompositor_027_ShowMirrorWindow, 0, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVRCompositor_IVRCompositor_027_HideMirrorWindow, 0, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVRCompositor_IVRCompositor_027_IsMirrorWindowVisible, 0, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVRCompositor_IVRCompositor_027_CompositorDumpImages, 0, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVRCompositor_IVRCompositor_027_ShouldAppRenderWithLowResources, 0, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVRCompositor_IVRCompositor_027_ForceInterleavedReprojectionOn, 1, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVRCompositor_IVRCompositor_027_ForceReconnectProcess, 0, FALSE, FALSE);
+    init_thunk(&thunks[32], r, winIVRCompositor_IVRCompositor_027_SuspendRendering, 1, FALSE, FALSE);
+    init_thunk(&thunks[33], r, winIVRCompositor_IVRCompositor_027_GetMirrorTextureD3D11, 3, FALSE, FALSE);
+    init_thunk(&thunks[34], r, winIVRCompositor_IVRCompositor_027_ReleaseMirrorTextureD3D11, 1, FALSE, FALSE);
+    init_thunk(&thunks[35], r, winIVRCompositor_IVRCompositor_027_GetMirrorTextureGL, 3, FALSE, FALSE);
+    init_thunk(&thunks[36], r, winIVRCompositor_IVRCompositor_027_ReleaseSharedGLTexture, 2, FALSE, FALSE);
+    init_thunk(&thunks[37], r, winIVRCompositor_IVRCompositor_027_LockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    init_thunk(&thunks[38], r, winIVRCompositor_IVRCompositor_027_UnlockGLSharedTextureForAccess, 1, FALSE, FALSE);
+    init_thunk(&thunks[39], r, winIVRCompositor_IVRCompositor_027_GetVulkanInstanceExtensionsRequired, 2, FALSE, FALSE);
+    init_thunk(&thunks[40], r, winIVRCompositor_IVRCompositor_027_GetVulkanDeviceExtensionsRequired, 3, FALSE, FALSE);
+    init_thunk(&thunks[41], r, winIVRCompositor_IVRCompositor_027_SetExplicitTimingMode, 1, FALSE, FALSE);
+    init_thunk(&thunks[42], r, winIVRCompositor_IVRCompositor_027_SubmitExplicitTimingData, 0, FALSE, FALSE);
+    init_thunk(&thunks[43], r, winIVRCompositor_IVRCompositor_027_IsMotionSmoothingEnabled, 0, FALSE, FALSE);
+    init_thunk(&thunks[44], r, winIVRCompositor_IVRCompositor_027_IsMotionSmoothingSupported, 0, FALSE, FALSE);
+    init_thunk(&thunks[45], r, winIVRCompositor_IVRCompositor_027_IsCurrentSceneFocusAppLoading, 0, FALSE, FALSE);
+    init_thunk(&thunks[46], r, winIVRCompositor_IVRCompositor_027_SetStageOverride_Async, 4, FALSE, FALSE);
+    init_thunk(&thunks[47], r, winIVRCompositor_IVRCompositor_027_ClearStageOverride, 0, FALSE, FALSE);
+    init_thunk(&thunks[48], r, winIVRCompositor_IVRCompositor_027_GetCompositorBenchmarkResults, 2, FALSE, FALSE);
+    init_thunk(&thunks[49], r, winIVRCompositor_IVRCompositor_027_GetLastPosePredictionIDs, 2, FALSE, FALSE);
+    init_thunk(&thunks[50], r, winIVRCompositor_IVRCompositor_027_GetPosesForFrame, 3, FALSE, FALSE);
+    for (i = 0; i < 51; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRCompositor_IVRCompositor_027_FnTable(void *object)
+{
+    winIVRCompositor_IVRCompositor_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 "cppIVRCompositor_IVRCompositor_026.h"
 
 typedef struct __winIVRCompositor_IVRCompositor_026 {
@@ -302,12 +821,8 @@ void __thiscall winIVRCompositor_IVRCompositor_026_UnlockGLSharedTextureForAcces
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired, 12)
 uint32_t __thiscall winIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(winIVRCompositor_IVRCompositor_026 *_this, char * pchValue, uint32_t unBufferSize)
 {
-    uint32_t ret;
-
     TRACE("%p\n", _this);
-    ret = cppIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
-    TRACE("ret %u, value %s.\n", ret, pchValue);
-    return ret;
+    return cppIVRCompositor_IVRCompositor_026_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_026_GetVulkanDeviceExtensionsRequired, 16)
@@ -1318,12 +1833,7 @@ DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_022_GetVulkanInstanceExte
 uint32_t __thiscall winIVRCompositor_IVRCompositor_022_GetVulkanInstanceExtensionsRequired(winIVRCompositor_IVRCompositor_022 *_this, char * pchValue, uint32_t unBufferSize)
 {
     TRACE("%p\n", _this);
-    uint32_t ret;
-
-    TRACE("%p\n", _this);
-    ret = cppIVRCompositor_IVRCompositor_022_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
-    TRACE("ret %u, value %s.\n", ret, pchValue);
-    return ret;
+    return cppIVRCompositor_IVRCompositor_022_GetVulkanInstanceExtensionsRequired(_this->linux_side, pchValue, unBufferSize);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRCompositor_IVRCompositor_022_GetVulkanDeviceExtensionsRequired, 16)
diff --git a/vrclient_x64/vrclient_x64/winIVRInput.c b/vrclient_x64/vrclient_x64/winIVRInput.c
index 3251b268..f21eced0 100644
--- a/vrclient_x64/vrclient_x64/winIVRInput.c
+++ b/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_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetDigitalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1168 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_010_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_010_GetAnalogActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetAnalogActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1168 * 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_11415 * 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_1168 * 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_11415 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1168 * 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_11415 * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_010_GetSkeletalActionData(winIVRInput_IVRInput_010 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1168 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_010_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);
diff --git a/vrclient_x64/vrclient_x64/winIVROverlay.c b/vrclient_x64/vrclient_x64/winIVROverlay.c
index 7c180627..54772c36 100644
--- a/vrclient_x64/vrclient_x64/winIVROverlay.c
+++ b/vrclient_x64/vrclient_x64/winIVROverlay.c
@@ -18,6 +18,776 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVROverlay_IVROverlay_025.h"
+
+typedef struct __winIVROverlay_IVROverlay_025 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVROverlay_IVROverlay_025;
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_FindOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_FindOverlay(winIVROverlay_IVROverlay_025 *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_FindOverlay(_this->linux_side, pchOverlayKey, pOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_CreateOverlay, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_CreateOverlay(winIVROverlay_IVROverlay_025 *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_CreateOverlay(_this->linux_side, pchOverlayKey, pchOverlayName, pOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_DestroyOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_DestroyOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_DestroyOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayKey, 24)
+uint32_t __thiscall winIVROverlay_IVROverlay_025_GetOverlayKey(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayKey(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayName, 24)
+uint32_t __thiscall winIVROverlay_IVROverlay_025_GetOverlayName(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayName(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayName, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayName(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayName(_this->linux_side, ulOverlayHandle, pchName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayImageData, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayImageData(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayImageData(_this->linux_side, ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum, 8)
+const char * __thiscall winIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum(winIVROverlay_IVROverlay_025 *_this, EVROverlayError error)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum(_this->linux_side, error);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayRenderingPid, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayRenderingPid(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayRenderingPid(_this->linux_side, ulOverlayHandle, unPID);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayRenderingPid, 12)
+uint32_t __thiscall winIVROverlay_IVROverlay_025_GetOverlayRenderingPid(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayRenderingPid(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayFlag, 17)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayFlag(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, bEnabled);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayFlag, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayFlag(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, pbEnabled);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayFlags, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayFlags(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayFlags(_this->linux_side, ulOverlayHandle, pFlags);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayColor, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayColor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayColor(_this->linux_side, ulOverlayHandle, fRed, fGreen, fBlue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayColor, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayColor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayColor(_this->linux_side, ulOverlayHandle, pfRed, pfGreen, pfBlue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayAlpha, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayAlpha(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayAlpha(_this->linux_side, ulOverlayHandle, fAlpha);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayAlpha, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayAlpha(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayAlpha(_this->linux_side, ulOverlayHandle, pfAlpha);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTexelAspect, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTexelAspect(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, fTexelAspect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTexelAspect, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTexelAspect(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, pfTexelAspect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlaySortOrder, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlaySortOrder(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlaySortOrder(_this->linux_side, ulOverlayHandle, unSortOrder);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlaySortOrder, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlaySortOrder(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlaySortOrder(_this->linux_side, ulOverlayHandle, punSortOrder);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayWidthInMeters, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayWidthInMeters(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, fWidthInMeters);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayWidthInMeters, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayWidthInMeters(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, pfWidthInMeters);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayCurvature, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayCurvature(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayCurvature(_this->linux_side, ulOverlayHandle, fCurvature);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayCurvature, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayCurvature(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayCurvature(_this->linux_side, ulOverlayHandle, pfCurvature);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, eTextureColorSpace);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, peTextureColorSpace);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTextureBounds, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTextureBounds(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTextureBounds, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTextureBounds(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformType, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformType(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTransformType(_this->linux_side, ulOverlayHandle, peTransformType);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, unDeviceIndex, pchComponentName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformCursor, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformCursor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulCursorOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTransformCursor(_this->linux_side, ulCursorOverlayHandle, pvHotspot);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTransformCursor, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTransformCursor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvHotspot)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTransformCursor(_this->linux_side, ulOverlayHandle, pvHotspot);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTransformProjection, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTransformProjection(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, VROverlayProjection_t * pProjection, EVREye eEye)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayTransformProjection(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform, pProjection, eEye);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ShowOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_ShowOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_HideOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_HideOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_HideOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_IsOverlayVisible, 12)
+bool __thiscall winIVROverlay_IVROverlay_025_IsOverlayVisible(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_IsOverlayVisible(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates(_this->linux_side, ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_PollNextOverlayEvent, 20)
+bool __thiscall winIVROverlay_IVROverlay_025_PollNextOverlayEvent(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1168 * pEvent, uint32_t uncbVREvent)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayInputMethod, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayInputMethod(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayInputMethod(_this->linux_side, ulOverlayHandle, peInputMethod);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayInputMethod, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayInputMethod(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayInputMethod(_this->linux_side, ulOverlayHandle, eInputMethod);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayMouseScale, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayMouseScale(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayMouseScale, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayMouseScale(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ComputeOverlayIntersection, 20)
+bool __thiscall winIVROverlay_IVROverlay_025_ComputeOverlayIntersection(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_ComputeOverlayIntersection(_this->linux_side, ulOverlayHandle, pParams, pResults);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_IsHoverTargetOverlay, 12)
+bool __thiscall winIVROverlay_IVROverlay_025_IsHoverTargetOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_IsHoverTargetOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayIntersectionMask, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayIntersectionMask(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayIntersectionMask(_this->linux_side, ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration(_this->linux_side, ulOverlayHandle, fDurationSeconds, fFrequency, fAmplitude);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayCursor, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayCursor(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayCursor(_this->linux_side, ulOverlayHandle, ulCursorHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvCursor)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle, pvCursor);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayTexture, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayTexture(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    TRACE("%p\n", _this);
+    return ivroverlay_set_overlay_texture(cppIVROverlay_IVROverlay_025_SetOverlayTexture, _this->linux_side, ulOverlayHandle, pTexture, 25);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ClearOverlayTexture, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ClearOverlayTexture(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_ClearOverlayTexture(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayRaw, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayRaw(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetOverlayRaw(_this->linux_side, ulOverlayHandle, pvBuffer, unWidth, unHeight, unBytesPerPixel);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetOverlayFromFile, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetOverlayFromFile(winIVROverlay_IVROverlay_025 *_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_025_SetOverlayFromFile(_this->linux_side, ulOverlayHandle, pchFilePath ? lin_pchFilePath : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTexture, 44)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTexture(winIVROverlay_IVROverlay_025 *_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_025_GetOverlayTexture(_this->linux_side, ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle(_this->linux_side, ulOverlayHandle, pNativeTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetOverlayTextureSize, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetOverlayTextureSize(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetOverlayTextureSize(_this->linux_side, ulOverlayHandle, pWidth, pHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_CreateDashboardOverlay, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_CreateDashboardOverlay(winIVROverlay_IVROverlay_025 *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_CreateDashboardOverlay(_this->linux_side, pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_IsDashboardVisible, 4)
+bool __thiscall winIVROverlay_IVROverlay_025_IsDashboardVisible(winIVROverlay_IVROverlay_025 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_IsDashboardVisible(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_IsActiveDashboardOverlay, 12)
+bool __thiscall winIVROverlay_IVROverlay_025_IsActiveDashboardOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_IsActiveDashboardOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, unProcessId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, punProcessId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowDashboard, 8)
+void __thiscall winIVROverlay_IVROverlay_025_ShowDashboard(winIVROverlay_IVROverlay_025 *_this, const char * pchOverlayToShow)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_025_ShowDashboard(_this->linux_side, pchOverlayToShow);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice, 4)
+TrackedDeviceIndex_t __thiscall winIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice(winIVROverlay_IVROverlay_025 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowKeyboard, 36)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ShowKeyboard(winIVROverlay_IVROverlay_025 *_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_025_ShowKeyboard(_this->linux_side, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowKeyboardForOverlay, 44)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_025_ShowKeyboardForOverlay(winIVROverlay_IVROverlay_025 *_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_025_ShowKeyboardForOverlay(_this->linux_side, ulOverlayHandle, eInputMode, eLineInputMode, unFlags, pchDescription, unCharMax, pchExistingText, uUserValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_GetKeyboardText, 12)
+uint32_t __thiscall winIVROverlay_IVROverlay_025_GetKeyboardText(winIVROverlay_IVROverlay_025 *_this, char * pchText, uint32_t cchText)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_025_GetKeyboardText(_this->linux_side, pchText, cchText);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_HideKeyboard, 4)
+void __thiscall winIVROverlay_IVROverlay_025_HideKeyboard(winIVROverlay_IVROverlay_025 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_025_HideKeyboard(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute, 12)
+void __thiscall winIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute(winIVROverlay_IVROverlay_025 *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute(_this->linux_side, eTrackingOrigin, pmatTrackingOriginToKeyboardTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay, 28)
+void __thiscall winIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay(winIVROverlay_IVROverlay_025 *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay(_this->linux_side, ulOverlayHandle, avoidRect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_ShowMessageOverlay, 28)
+VRMessageOverlayResponse __thiscall winIVROverlay_IVROverlay_025_ShowMessageOverlay(winIVROverlay_IVROverlay_025 *_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_025_ShowMessageOverlay(_this->linux_side, pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_025_CloseMessageOverlay, 4)
+void __thiscall winIVROverlay_IVROverlay_025_CloseMessageOverlay(winIVROverlay_IVROverlay_025 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_025_CloseMessageOverlay(_this->linux_side);
+}
+
+extern vtable_ptr winIVROverlay_IVROverlay_025_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVROverlay_IVROverlay_025,
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_FindOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_CreateOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_DestroyOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayKey)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayName)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayName)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayImageData)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayRenderingPid)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayRenderingPid)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayFlag)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayFlag)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayFlags)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayColor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayColor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayAlpha)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayAlpha)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTexelAspect)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTexelAspect)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlaySortOrder)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlaySortOrder)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayWidthInMeters)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayWidthInMeters)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayCurvature)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayCurvature)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTextureBounds)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTextureBounds)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformType)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTransformCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTransformProjection)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_HideOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_IsOverlayVisible)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_PollNextOverlayEvent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayInputMethod)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayInputMethod)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayMouseScale)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayMouseScale)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ComputeOverlayIntersection)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_IsHoverTargetOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayIntersectionMask)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayCursor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ClearOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayRaw)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetOverlayFromFile)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetOverlayTextureSize)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_CreateDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_IsDashboardVisible)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_IsActiveDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowDashboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowKeyboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowKeyboardForOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_GetKeyboardText)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_HideKeyboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_ShowMessageOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_025_CloseMessageOverlay)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVROverlay_IVROverlay_025 *create_winIVROverlay_IVROverlay_025(void *linux_side)
+{
+    winIVROverlay_IVROverlay_025 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_025));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVROverlay_IVROverlay_025_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVROverlay_IVROverlay_025(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVROverlay_IVROverlay_025 *create_winIVROverlay_IVROverlay_025_FnTable(void *linux_side)
+{
+    winIVROverlay_IVROverlay_025 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_025));
+    struct thunk *thunks = alloc_thunks(79);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 79 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_025_FindOverlay, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_025_CreateOverlay, 3, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_025_DestroyOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_025_GetOverlayKey, 4, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_025_GetOverlayName, 4, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_025_SetOverlayName, 2, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_025_GetOverlayImageData, 5, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_025_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_025_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_025_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_025_SetOverlayFlag, 3, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_025_GetOverlayFlag, 3, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_025_GetOverlayFlags, 2, FALSE, FALSE);
+    init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_025_SetOverlayColor, 4, TRUE, TRUE);
+    init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_025_GetOverlayColor, 4, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_025_SetOverlayAlpha, 2, TRUE, FALSE);
+    init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_025_GetOverlayAlpha, 2, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_025_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_025_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_025_SetOverlaySortOrder, 2, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_025_GetOverlaySortOrder, 2, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_025_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_025_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_025_SetOverlayCurvature, 2, TRUE, FALSE);
+    init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_025_GetOverlayCurvature, 2, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_025_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_025_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_025_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_025_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_025_GetOverlayTransformType, 2, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_025_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_025_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_025_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_025_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_025_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_025_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_025_SetOverlayTransformCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_025_GetOverlayTransformCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_025_SetOverlayTransformProjection, 5, FALSE, FALSE);
+    init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_025_ShowOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_025_HideOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_025_IsOverlayVisible, 1, FALSE, FALSE);
+    init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_025_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_025_PollNextOverlayEvent, 3, FALSE, FALSE);
+    init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_025_GetOverlayInputMethod, 2, FALSE, FALSE);
+    init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_025_SetOverlayInputMethod, 2, FALSE, FALSE);
+    init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_025_GetOverlayMouseScale, 2, FALSE, FALSE);
+    init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_025_SetOverlayMouseScale, 2, FALSE, FALSE);
+    init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_025_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_025_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_025_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_025_TriggerLaserMouseHapticVibration, 4, TRUE, TRUE);
+    init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_025_SetOverlayCursor, 2, FALSE, FALSE);
+    init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_025_SetOverlayCursorPositionOverride, 2, FALSE, FALSE);
+    init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_025_ClearOverlayCursorPositionOverride, 1, FALSE, FALSE);
+    init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_025_SetOverlayTexture, 2, FALSE, FALSE);
+    init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_025_ClearOverlayTexture, 1, FALSE, FALSE);
+    init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_025_SetOverlayRaw, 5, FALSE, FALSE);
+    init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_025_SetOverlayFromFile, 2, FALSE, FALSE);
+    init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_025_GetOverlayTexture, 9, FALSE, FALSE);
+    init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_025_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_025_GetOverlayTextureSize, 3, FALSE, FALSE);
+    init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_025_CreateDashboardOverlay, 4, FALSE, FALSE);
+    init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_025_IsDashboardVisible, 0, FALSE, FALSE);
+    init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_025_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_025_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_025_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_025_ShowDashboard, 1, FALSE, FALSE);
+    init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_025_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_025_ShowKeyboard, 7, FALSE, FALSE);
+    init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_025_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_025_GetKeyboardText, 2, FALSE, FALSE);
+    init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_025_HideKeyboard, 0, FALSE, FALSE);
+    init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_025_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    init_thunk(&thunks[76], r, winIVROverlay_IVROverlay_025_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    init_thunk(&thunks[77], r, winIVROverlay_IVROverlay_025_ShowMessageOverlay, 6, FALSE, FALSE);
+    init_thunk(&thunks[78], r, winIVROverlay_IVROverlay_025_CloseMessageOverlay, 0, FALSE, FALSE);
+    for (i = 0; i < 79; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVROverlay_IVROverlay_025_FnTable(void *object)
+{
+    winIVROverlay_IVROverlay_025 *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_024.h"
 
 typedef struct __winIVROverlay_IVROverlay_024 {
diff --git a/vrclient_x64/vrclient_x64/winIVRRenderModels.c b/vrclient_x64/vrclient_x64/winIVRRenderModels.c
index 9ed970f2..9a15b3c3 100644
--- a/vrclient_x64/vrclient_x64/winIVRRenderModels.c
+++ b/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_11415 ** ppRenderModel)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1168 ** 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_11415 * pRenderModel)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1168 * 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_11415 ** ppTexture)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1168 ** 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_11415 * pTexture)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1168 * pTexture)
 {
     TRACE("%p\n", _this);
     cppIVRRenderModels_IVRRenderModels_006_FreeTexture(_this->linux_side, pTexture);
diff --git a/vrclient_x64/vrclient_x64/winIVRSystem.c b/vrclient_x64/vrclient_x64/winIVRSystem.c
index f4d316bf..db5032de 100644
--- a/vrclient_x64/vrclient_x64/winIVRSystem.c
+++ b/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_11415 * pEvent, uint32_t uncbVREvent)
+bool __thiscall winIVRSystem_IVRSystem_022_PollNextEvent(winIVRSystem_IVRSystem_022 *_this, winVREvent_t_1168 * 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_11415 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_022_PollNextEventWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1168 * 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_11415 * pControllerState, uint32_t unControllerStateSize)
+bool __thiscall winIVRSystem_IVRSystem_022_GetControllerState(winIVRSystem_IVRSystem_022 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1168 * 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_11415 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall winIVRSystem_IVRSystem_022_GetControllerStateWithPose(winIVRSystem_IVRSystem_022 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1168 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     TRACE("%p\n", _this);
     return cppIVRSystem_IVRSystem_022_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);
diff --git a/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c b/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c
index 24eb96cd..1bb09ca4 100644
--- a/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c
+++ b/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_11415 * 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_1168 * 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_11415 * 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_1168 * 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_11415 * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1168 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     TRACE("%p\n", _this);
     return cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(_this->linux_side, hTrackedCamera, eFrameType, pglTextureId, pFrameHeader, nFrameHeaderSize);
diff --git a/vrclient_x64/vrclient_x64/win_constructors.h b/vrclient_x64/vrclient_x64/win_constructors.h
index ae2741ef..224985be 100644
--- a/vrclient_x64/vrclient_x64/win_constructors.h
+++ b/vrclient_x64/vrclient_x64/win_constructors.h
@@ -8,14 +8,14 @@ extern void *create_winIVRChaperone_IVRChaperone_004(void *);
 extern void *create_winIVRChaperone_IVRChaperone_004_FnTable(void *);
 extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_006(void *);
 extern void *create_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable(void *);
-extern void *create_winIVRCompositor_IVRCompositor_026(void *);
-extern void *create_winIVRCompositor_IVRCompositor_026_FnTable(void *);
+extern void *create_winIVRCompositor_IVRCompositor_027(void *);
+extern void *create_winIVRCompositor_IVRCompositor_027_FnTable(void *);
 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_024(void *);
-extern void *create_winIVROverlay_IVROverlay_024_FnTable(void *);
+extern void *create_winIVROverlay_IVROverlay_025(void *);
+extern void *create_winIVROverlay_IVROverlay_025_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,10 @@ 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_winIVRCompositor_IVRCompositor_026(void *);
+extern void *create_winIVRCompositor_IVRCompositor_026_FnTable(void *);
+extern void *create_winIVROverlay_IVROverlay_024(void *);
+extern void *create_winIVROverlay_IVROverlay_024_FnTable(void *);
 extern void *create_winIVRSystem_IVRSystem_021(void *);
 extern void *create_winIVRSystem_IVRSystem_021_FnTable(void *);
 extern void *create_winIVRChaperone_IVRChaperone_003(void *);
diff --git a/vrclient_x64/vrclient_x64/win_constructors_table.dat b/vrclient_x64/vrclient_x64/win_constructors_table.dat
index 0236c1f4..8a85f570 100644
--- a/vrclient_x64/vrclient_x64/win_constructors_table.dat
+++ b/vrclient_x64/vrclient_x64/win_constructors_table.dat
@@ -8,14 +8,14 @@
     {"FnTable:IVRChaperone_004", &create_winIVRChaperone_IVRChaperone_004_FnTable, &destroy_winIVRChaperone_IVRChaperone_004_FnTable},
     {"IVRChaperoneSetup_006", &create_winIVRChaperoneSetup_IVRChaperoneSetup_006, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006},
     {"FnTable:IVRChaperoneSetup_006", &create_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable, &destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable},
-    {"IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026, &destroy_winIVRCompositor_IVRCompositor_026},
-    {"FnTable:IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026_FnTable, &destroy_winIVRCompositor_IVRCompositor_026_FnTable},
+    {"IVRCompositor_027", &create_winIVRCompositor_IVRCompositor_027, &destroy_winIVRCompositor_IVRCompositor_027},
+    {"FnTable:IVRCompositor_027", &create_winIVRCompositor_IVRCompositor_027_FnTable, &destroy_winIVRCompositor_IVRCompositor_027_FnTable},
     {"IVRHeadsetView_001", &create_winIVRHeadsetView_IVRHeadsetView_001, &destroy_winIVRHeadsetView_IVRHeadsetView_001},
     {"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_024", &create_winIVROverlay_IVROverlay_024, &destroy_winIVROverlay_IVROverlay_024},
-    {"FnTable:IVROverlay_024", &create_winIVROverlay_IVROverlay_024_FnTable, &destroy_winIVROverlay_IVROverlay_024_FnTable},
+    {"IVROverlay_025", &create_winIVROverlay_IVROverlay_025, &destroy_winIVROverlay_IVROverlay_025},
+    {"FnTable:IVROverlay_025", &create_winIVROverlay_IVROverlay_025_FnTable, &destroy_winIVROverlay_IVROverlay_025_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,10 @@
     {"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},
+    {"IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026, &destroy_winIVRCompositor_IVRCompositor_026},
+    {"FnTable:IVRCompositor_026", &create_winIVRCompositor_IVRCompositor_026_FnTable, &destroy_winIVRCompositor_IVRCompositor_026_FnTable},
+    {"IVROverlay_024", &create_winIVROverlay_IVROverlay_024, &destroy_winIVROverlay_IVROverlay_024},
+    {"FnTable:IVROverlay_024", &create_winIVROverlay_IVROverlay_024_FnTable, &destroy_winIVROverlay_IVROverlay_024_FnTable},
     {"IVRSystem_021", &create_winIVRSystem_IVRSystem_021, &destroy_winIVRSystem_IVRSystem_021},
     {"FnTable:IVRSystem_021", &create_winIVRSystem_IVRSystem_021_FnTable, &destroy_winIVRSystem_IVRSystem_021_FnTable},
     {"IVRChaperone_003", &create_winIVRChaperone_IVRChaperone_003, &destroy_winIVRChaperone_IVRChaperone_003},
diff --git a/vrclient_x64/vrclient_x64/win_destructors.h b/vrclient_x64/vrclient_x64/win_destructors.h
index 3d9d4f2e..2a2d0bc6 100644
--- a/vrclient_x64/vrclient_x64/win_destructors.h
+++ b/vrclient_x64/vrclient_x64/win_destructors.h
@@ -8,14 +8,14 @@ extern void destroy_winIVRChaperone_IVRChaperone_004(void *);
 extern void destroy_winIVRChaperone_IVRChaperone_004_FnTable(void *);
 extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006(void *);
 extern void destroy_winIVRChaperoneSetup_IVRChaperoneSetup_006_FnTable(void *);
-extern void destroy_winIVRCompositor_IVRCompositor_026(void *);
-extern void destroy_winIVRCompositor_IVRCompositor_026_FnTable(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_027(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_027_FnTable(void *);
 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_024(void *);
-extern void destroy_winIVROverlay_IVROverlay_024_FnTable(void *);
+extern void destroy_winIVROverlay_IVROverlay_025(void *);
+extern void destroy_winIVROverlay_IVROverlay_025_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,10 @@ 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_winIVRCompositor_IVRCompositor_026(void *);
+extern void destroy_winIVRCompositor_IVRCompositor_026_FnTable(void *);
+extern void destroy_winIVROverlay_IVROverlay_024(void *);
+extern void destroy_winIVROverlay_IVROverlay_024_FnTable(void *);
 extern void destroy_winIVRSystem_IVRSystem_021(void *);
 extern void destroy_winIVRSystem_IVRSystem_021_FnTable(void *);
 extern void destroy_winIVRChaperone_IVRChaperone_003(void *);