vrclient: Support openvr v1.8.19

43 files changed, 12681 insertions, 1484 deletions

diff --git a/vrclient_x64/gen_wrapper.py b/vrclient_x64/gen_wrapper.py
index 93020b34..6ed6fc06 100755
--- a/vrclient_x64/gen_wrapper.py
+++ b/vrclient_x64/gen_wrapper.py
@@ -14,6 +14,7 @@ import os
 import re
 
 sdk_versions = [
+    "v1.8.19",
     "v1.7.15",
     "v1.6.10",
     "v1.5.17",
diff --git a/vrclient_x64/openvr_v1.8.19/ivrclientcore.h b/vrclient_x64/openvr_v1.8.19/ivrclientcore.h
new file mode 100644
index 00000000..61d557fb
--- /dev/null
+++ b/vrclient_x64/openvr_v1.8.19/ivrclientcore.h
@@ -0,0 +1,36 @@
+//========= Copyright Valve Corporation ============//
+
+#include "openvr.h"
+
+namespace vr
+{
+
+class IVRClientCore
+{
+public:
+	/** Initializes the system */
+	virtual EVRInitError Init( vr::EVRApplicationType eApplicationType, const char *pStartupInfo ) = 0;
+
+	/** cleans up everything in vrclient.dll and prepares the DLL to be unloaded */
+	virtual void Cleanup() = 0;
+
+	/** checks to see if the specified interface/version is supported in this vrclient.dll */
+	virtual EVRInitError IsInterfaceVersionValid( const char *pchInterfaceVersion ) = 0;
+
+	/** Retrieves any interface from vrclient.dll */
+	virtual void *GetGenericInterface( const char *pchNameAndVersion, EVRInitError *peError ) = 0;
+
+	/** Returns true if any driver has an HMD attached. Can be called outside of Init/Cleanup */
+	virtual bool BIsHmdPresent() = 0;
+
+	/** Returns an English error string from inside vrclient.dll which might be newer than the API DLL */
+	virtual const char *GetEnglishStringForHmdError( vr::EVRInitError eError ) = 0;
+
+	/** Returns an error symbol from inside vrclient.dll which might be newer than the API DLL */
+	virtual const char *GetIDForVRInitError( vr::EVRInitError eError ) = 0;
+};
+
+static const char * const IVRClientCore_Version = "IVRClientCore_003";
+
+
+}
diff --git a/vrclient_x64/openvr_v1.8.19/openvr.h b/vrclient_x64/openvr_v1.8.19/openvr.h
new file mode 100644
index 00000000..cf1434f4
--- /dev/null
+++ b/vrclient_x64/openvr_v1.8.19/openvr.h
@@ -0,0 +1,5154 @@
+
+// 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 = 8;
+	static const uint32_t k_nSteamVRVersionBuild = 19;
+} // namespace vr
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack( push, 8 )
+
+/** A handle for a spatial anchor.  This handle is only valid during the session it was created in.
+* Anchors that live beyond one session should be saved by their string descriptors. */
+typedef uint32_t SpatialAnchorHandle_t;
+
+typedef void* glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is forward
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+	float m[3][4];
+};
+
+struct HmdMatrix33_t
+{
+	float m[3][3];
+};
+
+struct HmdMatrix44_t
+{
+	float m[4][4];
+};
+
+struct HmdVector3_t
+{
+	float v[3];
+};
+
+struct HmdVector4_t
+{
+	float v[4];
+};
+
+struct HmdVector3d_t
+{
+	double v[3];
+};
+
+struct HmdVector2_t
+{
+	float v[2];
+};
+
+struct HmdQuaternion_t
+{
+	double w, x, y, z;
+};
+
+struct HmdQuaternionf_t
+{
+	float w, x, y, z;
+};
+
+struct HmdColor_t
+{
+	float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+	HmdVector3_t vCorners[ 4 ];
+};
+
+struct HmdRect2_t
+{
+	HmdVector2_t vTopLeft;
+	HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+	float rfRed[2];
+	float rfGreen[2];
+	float rfBlue[2];
+};
+
+enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1
+};
+
+enum ETextureType
+{
+	TextureType_Invalid = -1, // Handle has been invalidated
+	TextureType_DirectX = 0, // Handle is an ID3D11Texture
+	TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+	TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
+	TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef, deprecated in favor of TextureType_Metal on supported platforms
+	TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
+	TextureType_DXGISharedHandle = 5, // Handle is a HANDLE DXGI share handle, only supported for Overlay render targets. 
+									  // this texture is used directly by our renderer, so only perform atomic (copyresource or resolve) on it
+	TextureType_Metal = 6, // Handle is a MTLTexture conforming to the MTLSharedTexture protocol. Textures submitted to IVRCompositor::Submit which
+						   // are of type MTLTextureType2DArray assume layer 0 is the left eye texture (vr::EVREye::Eye_left), layer 1 is the right
+						   // eye texture (vr::EVREye::Eye_Right)
+};
+
+enum EColorSpace
+{
+	ColorSpace_Auto = 0,	// Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+	ColorSpace_Gamma = 1,	// Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+	ColorSpace_Linear = 2,	// Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+	void* handle; // See ETextureType definition above
+	ETextureType eType;
+	EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE	((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+	TrackingResult_Uninitialized			= 1,
+
+	TrackingResult_Calibrating_InProgress	= 100,
+	TrackingResult_Calibrating_OutOfRange	= 101,
+
+	TrackingResult_Running_OK				= 200,
+	TrackingResult_Running_OutOfRange		= 201,
+
+	TrackingResult_Fallback_RotationOnly	= 300,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 64;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+	TrackedDeviceClass_Invalid = 0,				// the ID was not valid.
+	TrackedDeviceClass_HMD = 1,					// Head-Mounted Displays
+	TrackedDeviceClass_Controller = 2,			// Tracked controllers
+	TrackedDeviceClass_GenericTracker = 3,		// Generic trackers, similar to controllers
+	TrackedDeviceClass_TrackingReference = 4,	// Camera and base stations that serve as tracking reference points
+	TrackedDeviceClass_DisplayRedirect = 5,		// Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+
+	TrackedDeviceClass_Max
+};
+
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+	TrackedControllerRole_Invalid = 0,					// Invalid value for controller type
+	TrackedControllerRole_LeftHand = 1,					// Tracked device associated with the left hand
+	TrackedControllerRole_RightHand = 2,				// Tracked device associated with the right hand
+	TrackedControllerRole_OptOut = 3,					// Tracked device is opting out of left/right hand selection
+	TrackedControllerRole_Treadmill = 4,				// Tracked device is a treadmill
+	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_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,
+
+	// 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_HmdProvidesDisplaySettings_Bool		= 2077,
+
+
+	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_DashboardLayoutPathName_String 		= 2090,
+	Prop_DashboardScale_Float 					= 2091,
+	Prop_IpdUIRangeMinMeters_Float 				= 2100,
+	Prop_IpdUIRangeMaxMeters_Float 				= 2101,
+
+	// Driver requested mura correction properties
+	Prop_DriverRequestedMuraCorrectionMode_Int32		= 2200,
+	Prop_DriverRequestedMuraFeather_InnerLeft_Int32		= 2201,
+	Prop_DriverRequestedMuraFeather_InnerRight_Int32	= 2202,
+	Prop_DriverRequestedMuraFeather_InnerTop_Int32		= 2203,
+	Prop_DriverRequestedMuraFeather_InnerBottom_Int32	= 2204,
+	Prop_DriverRequestedMuraFeather_OuterLeft_Int32		= 2205,
+	Prop_DriverRequestedMuraFeather_OuterRight_Int32	= 2206,
+	Prop_DriverRequestedMuraFeather_OuterTop_Int32		= 2207,
+	Prop_DriverRequestedMuraFeather_OuterBottom_Int32	= 2208,
+
+	Prop_Audio_DefaultPlaybackDeviceId_String		= 2300,
+	Prop_Audio_DefaultRecordingDeviceId_String		= 2301,
+	Prop_Audio_DefaultPlaybackDeviceVolume_Float	= 2302,
+
+	// Properties that are unique to TrackedDeviceClass_Controller
+	Prop_AttachedDeviceId_String				= 3000,
+	Prop_SupportedButtons_Uint64				= 3001,
+	Prop_Axis0Type_Int32						= 3002, // Return value is of type EVRControllerAxisType
+	Prop_Axis1Type_Int32						= 3003, // Return value is of type EVRControllerAxisType
+	Prop_Axis2Type_Int32						= 3004, // Return value is of type EVRControllerAxisType
+	Prop_Axis3Type_Int32						= 3005, // Return value is of type EVRControllerAxisType
+	Prop_Axis4Type_Int32						= 3006, // Return value is of type EVRControllerAxisType
+	Prop_ControllerRoleHint_Int32				= 3007, // Return value is of type ETrackedControllerRole
+
+	// Properties that are unique to TrackedDeviceClass_TrackingReference
+	Prop_FieldOfViewLeftDegrees_Float			= 4000,
+	Prop_FieldOfViewRightDegrees_Float			= 4001,
+	Prop_FieldOfViewTopDegrees_Float			= 4002,
+	Prop_FieldOfViewBottomDegrees_Float			= 4003,
+	Prop_TrackingRangeMinimumMeters_Float		= 4004,
+	Prop_TrackingRangeMaximumMeters_Float		= 4005,
+	Prop_ModeLabel_String						= 4006,
+	Prop_CanWirelessIdentify_Bool               = 4007, // volatile, based on radio presence and fw discovery
+	Prop_Nonce_Int32                            = 4008,
+
+	// Properties that are used for user interface like icons names
+	Prop_IconPathName_String						= 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+	Prop_NamedIconPathDeviceOff_String				= 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearching_String		= 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceSearchingAlert_String	= 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReady_String			= 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceReadyAlert_String		= 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceNotReady_String			= 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandby_String			= 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceAlertLow_String			= 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+	Prop_NamedIconPathDeviceStandbyAlert_String		= 5009, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+	// Properties that are used by helpers, but are opaque to applications
+	Prop_DisplayHiddenArea_Binary_Start				= 5100,
+	Prop_DisplayHiddenArea_Binary_End				= 5150,
+	Prop_ParentContainer							= 5151,
+	Prop_OverrideContainer_Uint64					= 5152,
+
+	// Properties that are unique to drivers
+	Prop_UserConfigPath_String					= 6000,
+	Prop_InstallPath_String						= 6001,
+	Prop_HasDisplayComponent_Bool				= 6002,
+	Prop_HasControllerComponent_Bool			= 6003,
+	Prop_HasCameraComponent_Bool				= 6004,
+	Prop_HasDriverDirectModeComponent_Bool		= 6005,
+	Prop_HasVirtualDisplayComponent_Bool		= 6006,
+	Prop_HasSpatialAnchorsSupport_Bool		    = 6007,
+
+	// Properties that are set internally based on other information provided by drivers
+	Prop_ControllerType_String					= 7000,
+	//Prop_LegacyInputProfile_String				= 7001, // This is no longer used. See "legacy_binding" in the input profile instead.
+	Prop_ControllerHandSelectionPriority_Int32	= 7002, // Allows hand assignments to prefer some controllers over others. High numbers are selected over low numbers
+
+	// Vendors are free to expose private debug data in this reserved region
+	Prop_VendorSpecific_Reserved_Start			= 10000,
+	Prop_VendorSpecific_Reserved_End			= 10999,
+	
+	Prop_TrackedDeviceProperty_Max				= 1000000,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+	TrackedProp_Success						= 0,
+	TrackedProp_WrongDataType				= 1,
+	TrackedProp_WrongDeviceClass			= 2,
+	TrackedProp_BufferTooSmall				= 3,
+	TrackedProp_UnknownProperty				= 4, // Driver has not set the property (and may not ever).
+	TrackedProp_InvalidDevice				= 5,
+	TrackedProp_CouldNotContactServer		= 6,
+	TrackedProp_ValueNotProvidedByDevice	= 7,
+	TrackedProp_StringExceedsMaximumLength	= 8,
+	TrackedProp_NotYetAvailable				= 9, // The property value isn't known yet, but is expected soon. Call again later.
+	TrackedProp_PermissionDenied			= 10,
+	TrackedProp_InvalidOperation			= 11,
+	TrackedProp_CannotWriteToWildcards		= 12,
+	TrackedProp_IPCReadFailure				= 13,
+};
+
+/** 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,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. 
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage; // VkImage
+	VkDevice_T *m_pDevice;
+	VkPhysicalDevice_T *m_pPhysicalDevice;
+	VkInstance_T *m_pInstance;
+	VkQueue_T *m_pQueue;
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+	ID3D12Resource *m_pResource;
+	ID3D12CommandQueue *m_pCommandQueue;
+	uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+	VRState_Undefined = -1,
+	VRState_Off = 0,
+	VRState_Searching = 1,
+	VRState_Searching_Alert = 2,
+	VRState_Ready = 3,
+	VRState_Ready_Alert = 4,
+	VRState_NotReady = 5,
+	VRState_Standby = 6,
+	VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+enum EVREventType
+{
+	VREvent_None = 0,
+
+	VREvent_TrackedDeviceActivated		= 100,
+	VREvent_TrackedDeviceDeactivated	= 101,
+	VREvent_TrackedDeviceUpdated		= 102,
+	VREvent_TrackedDeviceUserInteractionStarted	= 103,
+	VREvent_TrackedDeviceUserInteractionEnded	= 104,
+	VREvent_IpdChanged					= 105,
+	VREvent_EnterStandbyMode			= 106,
+	VREvent_LeaveStandbyMode			= 107,
+	VREvent_TrackedDeviceRoleChanged	= 108,
+	VREvent_WatchdogWakeUpRequested		= 109,
+	VREvent_LensDistortionChanged		= 110,
+	VREvent_PropertyChanged				= 111,
+	VREvent_WirelessDisconnect			= 112,
+	VREvent_WirelessReconnect			= 113,
+
+	VREvent_ButtonPress					= 200, // data is controller
+	VREvent_ButtonUnpress				= 201, // data is controller
+	VREvent_ButtonTouch					= 202, // data is controller
+	VREvent_ButtonUntouch				= 203, // data is controller
+
+	VREvent_DualAnalog_Press			= 250, // data is dualAnalog
+	VREvent_DualAnalog_Unpress			= 251, // data is dualAnalog
+	VREvent_DualAnalog_Touch			= 252, // data is dualAnalog
+	VREvent_DualAnalog_Untouch			= 253, // data is dualAnalog
+	VREvent_DualAnalog_Move				= 254, // data is dualAnalog
+	VREvent_DualAnalog_ModeSwitch1		= 255, // data is dualAnalog
+	VREvent_DualAnalog_ModeSwitch2		= 256, // data is dualAnalog
+	VREvent_DualAnalog_Cancel			= 257, // data is dualAnalog
+
+	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_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
+	VREvent_ImageLoaded					= 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+	VREvent_ShowKeyboard				= 509, // Sent to keyboard renderer in the dashboard to invoke it
+	VREvent_HideKeyboard				= 510, // Sent to keyboard renderer in the dashboard to hide it
+	VREvent_OverlayGamepadFocusGained	= 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+	VREvent_OverlayGamepadFocusLost		= 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+	VREvent_OverlaySharedTextureChanged = 513,
+	//VREvent_DashboardGuideButtonDown	= 514, // These are no longer sent
+	//VREvent_DashboardGuideButtonUp		= 515,
+	VREvent_ScreenshotTriggered			= 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
+	VREvent_ImageFailed					= 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+	VREvent_DashboardOverlayCreated		= 518,
+	VREvent_SwitchGamepadFocus			= 519,
+
+	// Screenshot API
+	VREvent_RequestScreenshot				= 520, // Sent by vrclient application to compositor to take a screenshot
+	VREvent_ScreenshotTaken					= 521, // Sent by compositor to the application that the screenshot has been taken
+	VREvent_ScreenshotFailed				= 522, // Sent by compositor to the application that the screenshot failed to be taken
+	VREvent_SubmitScreenshotToDashboard		= 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
+	VREvent_ScreenshotProgressToDashboard	= 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+	VREvent_PrimaryDashboardDeviceChanged	= 525,
+	VREvent_RoomViewShown					= 526, // Sent by compositor whenever room-view is enabled
+	VREvent_RoomViewHidden					= 527, // Sent by compositor whenever room-view is disabled
+	VREvent_ShowUI							= 528, // data is showUi
+	VREvent_ShowDevTools					= 529, // data is showDevTools
+
+	VREvent_Notification_Shown				= 600,
+	VREvent_Notification_Hidden				= 601,
+	VREvent_Notification_BeginInteraction	= 602,
+	VREvent_Notification_Destroyed			= 603,
+
+	VREvent_Quit							= 700, // data is process
+	VREvent_ProcessQuit						= 701, // data is process
+	//VREvent_QuitAborted_UserPrompt			= 702, // data is process
+	VREvent_QuitAcknowledged				= 703, // data is process
+	VREvent_DriverRequestedQuit				= 704, // The driver has requested that SteamVR shut down
+	VREvent_RestartRequested				= 705, // A driver or other component wants the user to restart SteamVR
+
+	VREvent_ChaperoneDataHasChanged			= 800, // this will never happen with the new chaperone system
+	VREvent_ChaperoneUniverseHasChanged		= 801,
+	VREvent_ChaperoneTempDataHasChanged		= 802, // this will never happen with the new chaperone system
+	VREvent_ChaperoneSettingsHaveChanged	= 803,
+	VREvent_SeatedZeroPoseReset				= 804,
+	VREvent_ChaperoneFlushCache				= 805, // Sent when the process needs to reload any cached data it retrieved from VRChaperone()
+	VREvent_ChaperoneRoomSetupStarting	    = 806, // Triggered by CVRChaperoneClient::RoomSetupStarting
+	VREvent_ChaperoneRoomSetupFinished	    = 807, // Triggered by CVRChaperoneClient::CommitWorkingCopy
+
+	VREvent_AudioSettingsHaveChanged		= 820,
+
+	VREvent_BackgroundSettingHasChanged				= 850,
+	VREvent_CameraSettingsHaveChanged				= 851,
+	VREvent_ReprojectionSettingHasChanged			= 852,
+	VREvent_ModelSkinSettingsHaveChanged			= 853,
+	VREvent_EnvironmentSettingsHaveChanged			= 854,
+	VREvent_PowerSettingsHaveChanged				= 855,
+	VREvent_EnableHomeAppSettingsHaveChanged		= 856,
+	VREvent_SteamVRSectionSettingChanged			= 857,
+	VREvent_LighthouseSectionSettingChanged			= 858,
+	VREvent_NullSectionSettingChanged				= 859,
+	VREvent_UserInterfaceSectionSettingChanged		= 860,
+	VREvent_NotificationsSectionSettingChanged		= 861,
+	VREvent_KeyboardSectionSettingChanged			= 862,
+	VREvent_PerfSectionSettingChanged				= 863,
+	VREvent_DashboardSectionSettingChanged			= 864,
+	VREvent_WebInterfaceSectionSettingChanged		= 865,
+	VREvent_TrackersSectionSettingChanged			= 866,
+	VREvent_LastKnownSectionSettingChanged			= 867,
+	VREvent_DismissedWarningsSectionSettingChanged	= 868,
+
+	VREvent_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_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_SpatialAnchors_PoseUpdated		= 1800,        // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_DescriptorUpdated = 1801,       // data is spatialAnchor. broadcast
+	VREvent_SpatialAnchors_RequestPoseUpdate = 1802,       // data is spatialAnchor. sent to specific driver
+	VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, // data is spatialAnchor. sent to specific driver
+
+	VREvent_SystemReport_Started			= 1900, // user or system initiated generation of a system report. broadcast
+
+	VREvent_Monitor_ShowHeadsetView			= 2000, // data is process
+	VREvent_Monitor_HideHeadsetView			= 2001, // data is process
+
+	// Vendors are free to expose private events in this reserved region
+	VREvent_VendorSpecific_Reserved_Start	= 10000,
+	VREvent_VendorSpecific_Reserved_End		= 19999,
+};
+
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{	
+	k_EDeviceActivityLevel_Unknown = -1,									
+	k_EDeviceActivityLevel_Idle = 0,						// No activity for the last 10 seconds
+	k_EDeviceActivityLevel_UserInteraction = 1,				// Activity (movement or prox sensor) is happening now	
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,		// No activity for the last 0.5 seconds
+	k_EDeviceActivityLevel_Standby = 3,						// Idle for at least 5 seconds (configurable in Settings -> Power Management)
+	k_EDeviceActivityLevel_Idle_Timeout = 4,
+};
+
+
+/** VR controller button and axis IDs */
+enum EVRButtonId
+{
+	k_EButton_System			= 0,
+	k_EButton_ApplicationMenu	= 1,
+	k_EButton_Grip				= 2,
+	k_EButton_DPad_Left			= 3,
+	k_EButton_DPad_Up			= 4,
+	k_EButton_DPad_Right		= 5,
+	k_EButton_DPad_Down			= 6,
+	k_EButton_A					= 7,
+	
+	k_EButton_ProximitySensor   = 31,
+
+	k_EButton_Axis0				= 32,
+	k_EButton_Axis1				= 33,
+	k_EButton_Axis2				= 34,
+	k_EButton_Axis3				= 35,
+	k_EButton_Axis4				= 36,
+
+	// aliases for well known controllers
+	k_EButton_SteamVR_Touchpad	= k_EButton_Axis0,
+	k_EButton_SteamVR_Trigger	= k_EButton_Axis1,
+
+	k_EButton_Dashboard_Back	= k_EButton_Grip,
+
+	k_EButton_IndexController_A		= k_EButton_Grip,
+	k_EButton_IndexController_B		= k_EButton_ApplicationMenu,
+	k_EButton_IndexController_JoyStick	= k_EButton_Axis3,
+
+	k_EButton_Max				= 64
+};
+
+inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+	uint32_t button; // EVRButtonId enum
+};
+
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+	VRMouseButton_Left					= 0x0001,
+	VRMouseButton_Right					= 0x0002,
+	VRMouseButton_Middle				= 0x0004,
+};
+
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+	float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
+	uint32_t button; // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll */
+struct VREvent_Scroll_t
+{
+	float xdelta, ydelta;
+	uint32_t unused;
+	float viewportscale; // For scrolling on an overlay with laser mouse, this is the overlay's vertical size relative to the overlay height. Range: [0,1]
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it). These events are sent to overlays with the VROverlayFlags_SendVRTouchpadEvents
+   flag set.
+**/
+struct VREvent_TouchPadMove_t
+{
+	// true if the users finger is detected on the touch pad
+	bool bFingerDown;
+
+	// How long the finger has been down in seconds
+	float flSecondsFingerDown;
+
+	// These values indicate the starting finger position (so you can do some basic swipe stuff)
+	float fValueXFirst;
+	float fValueYFirst;
+
+	// This is the raw sampled coordinate without deadzoning
+	float fValueXRaw;
+	float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+	// If the associated event was triggered by a connection loss
+	bool bConnectionLost;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+	uint64_t devicePath;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+	uint32_t statusState; // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+	char cNewInput[8];	// Up to 11 bytes of new input
+	uint64_t uUserValue;	// Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+	float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+	uint64_t reserved2;
+	uint64_t reserved3;
+	uint64_t reserved4;
+	uint64_t reserved5;
+};
+
+struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	ETrackedDeviceProperty prop;
+};
+
+enum EDualAnalogWhich
+{
+	k_EDualAnalog_Left = 0,
+	k_EDualAnalog_Right = 1,
+};
+
+struct VREvent_DualAnalog_t
+{
+	float x, y; // coordinates are -1..1 analog values
+	float transformedX, transformedY; // transformed by the center and radius numbers provided by the overlay
+	EDualAnalogWhich which;
+};
+
+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,
+};
+
+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_DualAnalog_t dualAnalog;
+	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
+
+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,
+};
+
+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
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+	uint32_t size; // sizeof(Compositor_OverlaySettings)
+	bool curved, antialias;
+	float scale, distance, alpha;
+	float uOffset, vOffset, uScale, vScale;
+	float gridDivs, gridWidth, gridScale;
+	HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+	VROverlayError_None						= 0,
+
+	VROverlayError_UnknownOverlay			= 10,
+	VROverlayError_InvalidHandle			= 11,
+	VROverlayError_PermissionDenied			= 12,
+	VROverlayError_OverlayLimitExceeded		= 13, // No more overlays could be created because the maximum number already exist
+	VROverlayError_WrongVisibilityType		= 14,
+	VROverlayError_KeyTooLong				= 15,
+	VROverlayError_NameTooLong				= 16,
+	VROverlayError_KeyInUse					= 17,
+	VROverlayError_WrongTransformType		= 18,
+	VROverlayError_InvalidTrackedDevice		= 19,
+	VROverlayError_InvalidParameter			= 20,
+	VROverlayError_ThumbnailCantBeDestroyed	= 21,
+	VROverlayError_ArrayTooSmall			= 22,
+	VROverlayError_RequestFailed			= 23,
+	VROverlayError_InvalidTexture			= 24,
+	VROverlayError_UnableToLoadFile			= 25,
+	VROverlayError_KeyboardAlreadyInUse		= 26,
+	VROverlayError_NoNeighbor				= 27,
+	VROverlayError_TooManyMaskPrimitives	= 29,
+	VROverlayError_BadMaskPrimitive			= 30,
+	VROverlayError_TextureAlreadyLocked		= 31,
+	VROverlayError_TextureLockCapacityReached = 32,
+	VROverlayError_TextureNotLocked			= 33,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+	VRApplication_Other = 0,		// Some other kind of application that isn't covered by the other entries 
+	VRApplication_Scene	= 1,		// Application will submit 3D frames 
+	VRApplication_Overlay = 2,		// Application only interacts with overlays
+	VRApplication_Background = 3,	// Application should not start SteamVR if it's not already running, and should not
+									// keep it running if everything else quits.
+	VRApplication_Utility = 4,		// Init should not try to load any drivers. The application needs access to utility
+									// interfaces (like IVRSettings and IVRApplications) but not hardware.
+	VRApplication_VRMonitor = 5,	// Reserved for vrmonitor
+	VRApplication_SteamWatchdog = 6,// Reserved for Steam
+	VRApplication_Bootstrapper = 7, // reserved for vrstartup
+	VRApplication_WebHelper = 8,	// reserved for vrwebhelper
+
+	VRApplication_Max
+};
+
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+	VRFirmwareError_None = 0,
+	VRFirmwareError_Success = 1,
+	VRFirmwareError_Fail = 2,
+};
+
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+	VRNotificationError_OK = 0,
+	VRNotificationError_InvalidNotificationId = 100,
+	VRNotificationError_NotificationQueueFull = 101,
+	VRNotificationError_InvalidOverlayHandle = 102,
+	VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+
+enum EVRSkeletalMotionRange
+{
+	// The range of motion of the skeleton takes into account any physical limits imposed by
+	// the controller itself.  This will tend to be the most accurate pose compared to the user's
+	// actual hand pose, but might not allow a closed fist for example
+	VRSkeletalMotionRange_WithController = 0,
+
+	// Retarget the range of motion provided by the input device to make the hand appear to move
+	// as if it was not holding a controller.  eg: map "hand grasping controller" to "closed fist"
+	VRSkeletalMotionRange_WithoutController = 1,
+};
+
+enum EVRSkeletalTrackingLevel
+{
+	// body part location can't be directly determined by the device. Any skeletal pose provided by
+	// the device is estimated by assuming the position required to active buttons, triggers, joysticks, 
+	// or other input sensors. 
+	// E.g. Vive Controller, Gamepad
+	VRSkeletalTracking_Estimated = 0,
+
+	// body part location can be measured directly but with fewer degrees of freedom than the actual body 
+	// part. Certain body part positions may be unmeasured by the device and estimated from other input data. 
+	// E.g. Index Controllers, gloves that only measure finger curl
+	VRSkeletalTracking_Partial,
+
+	// 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,
+
+	VRSkeletalTrackingLevel_Count,
+	VRSkeletalTrackingLevel_Max = VRSkeletalTrackingLevel_Count - 1
+};
+
+
+
+/** Holds the transform for a single bone */
+struct VRBoneTransform_t
+{
+	HmdVector4_t position;
+	HmdQuaternionf_t orientation;
+};
+
+/** Type used for referring to bones by their index */
+typedef int32_t BoneIndex_t;
+const BoneIndex_t k_unInvalidBoneIndex = -1;
+
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+	VRInitError_None	= 0,
+	VRInitError_Unknown = 1,
+
+	VRInitError_Init_InstallationNotFound			= 100,
+	VRInitError_Init_InstallationCorrupt			= 101,
+	VRInitError_Init_VRClientDLLNotFound			= 102,
+	VRInitError_Init_FileNotFound					= 103,
+	VRInitError_Init_FactoryNotFound				= 104,
+	VRInitError_Init_InterfaceNotFound				= 105,
+	VRInitError_Init_InvalidInterface				= 106,
+	VRInitError_Init_UserConfigDirectoryInvalid		= 107,
+	VRInitError_Init_HmdNotFound					= 108,
+	VRInitError_Init_NotInitialized					= 109,
+	VRInitError_Init_PathRegistryNotFound			= 110,
+	VRInitError_Init_NoConfigPath					= 111,
+	VRInitError_Init_NoLogPath						= 112,
+	VRInitError_Init_PathRegistryNotWritable		= 113,
+	VRInitError_Init_AppInfoInitFailed				= 114,
+	VRInitError_Init_Retry							= 115, // Used internally to cause retries to vrserver
+	VRInitError_Init_InitCanceledByUser				= 116, // The calling application should silently exit. The user canceled app startup
+	VRInitError_Init_AnotherAppLaunching			= 117, 
+	VRInitError_Init_SettingsInitFailed				= 118, 
+	VRInitError_Init_ShuttingDown					= 119,
+	VRInitError_Init_TooManyObjects					= 120,
+	VRInitError_Init_NoServerForBackgroundApp		= 121,
+	VRInitError_Init_NotSupportedWithCompositor		= 122,
+	VRInitError_Init_NotAvailableToUtilityApps		= 123,
+	VRInitError_Init_Internal				 		= 124,
+	VRInitError_Init_HmdDriverIdIsNone		 		= 125,
+	VRInitError_Init_HmdNotFoundPresenceFailed 		= 126,
+	VRInitError_Init_VRMonitorNotFound				= 127,
+	VRInitError_Init_VRMonitorStartupFailed			= 128,
+	VRInitError_Init_LowPowerWatchdogNotSupported	= 129, 
+	VRInitError_Init_InvalidApplicationType			= 130,
+	VRInitError_Init_NotAvailableToWatchdogApps		= 131,
+	VRInitError_Init_WatchdogDisabledInSettings		= 132,
+	VRInitError_Init_VRDashboardNotFound			= 133,
+	VRInitError_Init_VRDashboardStartupFailed		= 134,
+	VRInitError_Init_VRHomeNotFound					= 135,
+	VRInitError_Init_VRHomeStartupFailed			= 136,
+	VRInitError_Init_RebootingBusy					= 137,
+	VRInitError_Init_FirmwareUpdateBusy				= 138,
+	VRInitError_Init_FirmwareRecoveryBusy			= 139,
+	VRInitError_Init_USBServiceBusy					= 140,
+	VRInitError_Init_VRWebHelperStartupFailed		= 141,
+	VRInitError_Init_TrackerManagerInitFailed		= 142,
+	VRInitError_Init_AlreadyRunning					= 143,
+	VRInitError_Init_FailedForVrMonitor				= 144,
+	VRInitError_Init_PropertyManagerInitFailed		= 145,
+	VRInitError_Init_WebServerFailed				= 146,
+
+	VRInitError_Driver_Failed						= 200,
+	VRInitError_Driver_Unknown						= 201,
+	VRInitError_Driver_HmdUnknown					= 202,
+	VRInitError_Driver_NotLoaded					= 203,
+	VRInitError_Driver_RuntimeOutOfDate				= 204,
+	VRInitError_Driver_HmdInUse						= 205,
+	VRInitError_Driver_NotCalibrated				= 206,
+	VRInitError_Driver_CalibrationInvalid			= 207,
+	VRInitError_Driver_HmdDisplayNotFound			= 208,
+	VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	// VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+	VRInitError_Driver_HmdDriverIdOutOfBounds		= 211,
+	VRInitError_Driver_HmdDisplayMirrored			= 212,
+	VRInitError_Driver_HmdDisplayNotFoundLaptop		= 213,
+	// Never make error 259 because we return it from main and it would conflict with STILL_ACTIVE
+
+	VRInitError_IPC_ServerInitFailed				= 300,
+	VRInitError_IPC_ConnectFailed					= 301,
+	VRInitError_IPC_SharedStateInitFailed			= 302,
+	VRInitError_IPC_CompositorInitFailed			= 303,
+	VRInitError_IPC_MutexInitFailed					= 304,
+	VRInitError_IPC_Failed							= 305,
+	VRInitError_IPC_CompositorConnectFailed			= 306,
+	VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
+	VRInitError_IPC_NamespaceUnavailable			 = 310,
+
+	VRInitError_Compositor_Failed												= 400,
+	VRInitError_Compositor_D3D11HardwareRequired								= 401,
+	VRInitError_Compositor_FirmwareRequiresUpdate								= 402,
+	VRInitError_Compositor_OverlayInitFailed									= 403,
+	VRInitError_Compositor_ScreenshotsInitFailed								= 404,
+	VRInitError_Compositor_UnableToCreateDevice									= 405,
+	VRInitError_Compositor_SharedStateIsNull									= 406,
+	VRInitError_Compositor_NotificationManagerIsNull							= 407,
+	VRInitError_Compositor_ResourceManagerClientIsNull							= 408,
+	VRInitError_Compositor_MessageOverlaySharedStateInitFailure					= 409,
+	VRInitError_Compositor_PropertiesInterfaceIsNull							= 410,
+	VRInitError_Compositor_CreateFullscreenWindowFailed							= 411,
+	VRInitError_Compositor_SettingsInterfaceIsNull								= 412,
+	VRInitError_Compositor_FailedToShowWindow									= 413,
+	VRInitError_Compositor_DistortInterfaceIsNull								= 414,
+	VRInitError_Compositor_DisplayFrequencyFailure								= 415,
+	VRInitError_Compositor_RendererInitializationFailed							= 416,
+	VRInitError_Compositor_DXGIFactoryInterfaceIsNull							= 417,
+	VRInitError_Compositor_DXGIFactoryCreateFailed								= 418,
+	VRInitError_Compositor_DXGIFactoryQueryFailed								= 419,
+	VRInitError_Compositor_InvalidAdapterDesktop								= 420,
+	VRInitError_Compositor_InvalidHmdAttachment									= 421,
+	VRInitError_Compositor_InvalidOutputDesktop									= 422,
+	VRInitError_Compositor_InvalidDeviceProvided								= 423,
+	VRInitError_Compositor_D3D11RendererInitializationFailed					= 424,
+	VRInitError_Compositor_FailedToFindDisplayMode								= 425,
+	VRInitError_Compositor_FailedToCreateSwapChain								= 426,
+	VRInitError_Compositor_FailedToGetBackBuffer								= 427,
+	VRInitError_Compositor_FailedToCreateRenderTarget							= 428,
+	VRInitError_Compositor_FailedToCreateDXGI2SwapChain							= 429,
+	VRInitError_Compositor_FailedtoGetDXGI2BackBuffer							= 430,
+	VRInitError_Compositor_FailedToCreateDXGI2RenderTarget						= 431,
+	VRInitError_Compositor_FailedToGetDXGIDeviceInterface						= 432,
+	VRInitError_Compositor_SelectDisplayMode									= 433,
+	VRInitError_Compositor_FailedToCreateNvAPIRenderTargets						= 434,
+	VRInitError_Compositor_NvAPISetDisplayMode									= 435,
+	VRInitError_Compositor_FailedToCreateDirectModeDisplay						= 436,
+	VRInitError_Compositor_InvalidHmdPropertyContainer							= 437,
+	VRInitError_Compositor_UpdateDisplayFrequency								= 438,
+	VRInitError_Compositor_CreateRasterizerState								= 439,
+	VRInitError_Compositor_CreateWireframeRasterizerState						= 440,
+	VRInitError_Compositor_CreateSamplerState									= 441,
+	VRInitError_Compositor_CreateClampToBorderSamplerState						= 442,
+	VRInitError_Compositor_CreateAnisoSamplerState								= 443,
+	VRInitError_Compositor_CreateOverlaySamplerState							= 444,
+	VRInitError_Compositor_CreatePanoramaSamplerState							= 445,
+	VRInitError_Compositor_CreateFontSamplerState								= 446,
+	VRInitError_Compositor_CreateNoBlendState									= 447,
+	VRInitError_Compositor_CreateBlendState										= 448,
+	VRInitError_Compositor_CreateAlphaBlendState								= 449,
+	VRInitError_Compositor_CreateBlendStateMaskR								= 450,
+	VRInitError_Compositor_CreateBlendStateMaskG								= 451,
+	VRInitError_Compositor_CreateBlendStateMaskB								= 452,
+	VRInitError_Compositor_CreateDepthStencilState								= 453,
+	VRInitError_Compositor_CreateDepthStencilStateNoWrite						= 454,
+	VRInitError_Compositor_CreateDepthStencilStateNoDepth						= 455,
+	VRInitError_Compositor_CreateFlushTexture									= 456,
+	VRInitError_Compositor_CreateDistortionSurfaces								= 457,
+	VRInitError_Compositor_CreateConstantBuffer									= 458,
+	VRInitError_Compositor_CreateHmdPoseConstantBuffer							= 459,
+	VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer					= 460,
+	VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer					= 461,
+	VRInitError_Compositor_CreateOverlayConstantBuffer							= 462,
+	VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer				= 463,
+	VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer		= 464,
+	VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer		= 465,
+	VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer			= 466,
+	VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer	= 467,
+	VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer					= 468,
+	VRInitError_Compositor_CreateGeomConstantBuffer								= 469,
+	VRInitError_Compositor_CreatePanelMaskConstantBuffer						= 470,
+	VRInitError_Compositor_CreatePixelSimUBO									= 471,
+	VRInitError_Compositor_CreateMSAARenderTextures								= 472,
+	VRInitError_Compositor_CreateResolveRenderTextures							= 473,
+	VRInitError_Compositor_CreateComputeResolveRenderTextures					= 474,
+	VRInitError_Compositor_CreateDriverDirectModeResolveTextures				= 475,
+	VRInitError_Compositor_OpenDriverDirectModeResolveTextures					= 476,
+	VRInitError_Compositor_CreateFallbackSyncTexture							= 477,
+	VRInitError_Compositor_ShareFallbackSyncTexture								= 478,
+	VRInitError_Compositor_CreateOverlayIndexBuffer								= 479,
+	VRInitError_Compositor_CreateOverlayVertextBuffer							= 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_VendorSpecific_UnableToConnectToOculusRuntime		= 1000,
+	VRInitError_VendorSpecific_WindowsNotInDevMode					= 1001,
+
+	VRInitError_VendorSpecific_HmdFound_CantOpenDevice 				= 1101,
+	VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart	= 1102,
+	VRInitError_VendorSpecific_HmdFound_NoStoredConfig 				= 1103,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooBig 				= 1104,
+	VRInitError_VendorSpecific_HmdFound_ConfigTooSmall 				= 1105,
+	VRInitError_VendorSpecific_HmdFound_UnableToInitZLib 			= 1106,
+	VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion 	= 1107,
+	VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart	= 1108,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart	= 1109,
+	VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext		= 1110,
+	VRInitError_VendorSpecific_HmdFound_UserDataAddressRange		= 1111,
+	VRInitError_VendorSpecific_HmdFound_UserDataError				= 1112,
+	VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck		= 1113,
+	VRInitError_VendorSpecific_OculusRuntimeBadInstall				= 1114,
+
+	VRInitError_Steam_SteamInstallationNotFound = 2000,
+
+	// Strictly a placeholder
+	VRInitError_LastError
+};
+
+enum EVRScreenshotType
+{
+	VRScreenshotType_None = 0,
+	VRScreenshotType_Mono = 1, // left eye only
+	VRScreenshotType_Stereo = 2,
+	VRScreenshotType_Cubemap = 3,
+	VRScreenshotType_MonoPanorama = 4,
+	VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+	VRScreenshotPropertyFilenames_Preview = 0,
+	VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+	VRTrackedCameraError_None                       = 0,
+	VRTrackedCameraError_OperationFailed            = 100,
+	VRTrackedCameraError_InvalidHandle              = 101,	
+	VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
+	VRTrackedCameraError_OutOfHandles               = 103,
+	VRTrackedCameraError_IPCFailure                 = 104,
+	VRTrackedCameraError_NotSupportedForThisDevice  = 105,
+	VRTrackedCameraError_SharedMemoryFailure        = 106,
+	VRTrackedCameraError_FrameBufferingFailure      = 107,
+	VRTrackedCameraError_StreamSetupFailure         = 108,
+	VRTrackedCameraError_InvalidGLTextureId         = 109,
+	VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	VRTrackedCameraError_FailedToGetGLTextureId     = 111,
+	VRTrackedCameraError_SharedTextureFailure       = 112,
+	VRTrackedCameraError_NoFrameAvailable           = 113,
+	VRTrackedCameraError_InvalidArgument            = 114,
+	VRTrackedCameraError_InvalidFrameBufferSize     = 115,
+};
+
+enum EVRTrackedCameraFrameLayout
+{
+	EVRTrackedCameraFrameLayout_Mono				= 0x0001,
+	EVRTrackedCameraFrameLayout_Stereo				= 0x0002,
+	EVRTrackedCameraFrameLayout_VerticalLayout		= 0x0010,	// Stereo frames are Top/Bottom (left/right)
+	EVRTrackedCameraFrameLayout_HorizontalLayout	= 0x0020,	// Stereo frames are Left/Right
+};
+	
+enum EVRTrackedCameraFrameType
+{
+	VRTrackedCameraFrameType_Distorted = 0,			// This is the camera video frame size in pixels, still distorted.
+	VRTrackedCameraFrameType_Undistorted,			// In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+	VRTrackedCameraFrameType_MaximumUndistorted,	// In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+	MAX_CAMERA_FRAME_TYPES
+};
+
+enum EVRDistortionFunctionType
+{
+	VRDistortionFunctionType_None,
+	VRDistortionFunctionType_FTheta,
+	VRDistortionFunctionType_Extended_FTheta,
+	MAX_DISTORTION_FUNCTION_TYPES,
+};
+
+static const uint32_t k_unMaxDistortionFunctionParameters = 8;
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE	((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+	EVRTrackedCameraFrameType eFrameType;
+
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+
+	uint32_t nFrameSequence;
+
+	TrackedDevicePose_t trackedDevicePose;
+	
+	uint64_t ulFrameExposureTime;						// mid-point of the exposure of the image in host system ticks
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+/** Compositor frame timing reprojection flags. */
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync = 0x04;	// This flag indicates the async reprojection mode is active,
+															// but does not indicate if reprojection actually happened or not.
+															// Use the ReprojectionReason flags above to check if reprojection
+															// was actually applied (i.e. scene texture was reused).
+															// NumFramePresents > 1 also indicates the scene texture was reused,
+															// and also the number of times that it was presented in total.
+
+const uint32_t VRCompositor_ReprojectionMotion = 0x08;	// This flag indicates whether or not motion smoothing was triggered for this frame
+
+const uint32_t VRCompositor_PredictionMask = 0x30;	// The runtime may predict more than one frame (up to four) ahead if
+															// it detects the application is taking too long to render. These two
+															// bits will contain the count of additional frames (normally zero).
+															// Use the VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+const uint32_t VRCompositor_ThrottleMask = 0xC0;	// Number of frames the compositor is throttling the application.
+															// Use the VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES macro to read from
+															// the latest frame timing entry.
+
+#define VR_COMPOSITOR_ADDITIONAL_PREDICTED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_PredictionMask ) >> 4 )
+#define VR_COMPOSITOR_NUMBER_OF_THROTTLED_FRAMES( timing ) ( ( ( timing ).m_nReprojectionFlags & vr::VRCompositor_ThrottleMask ) >> 6 )
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+	uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents; // number of times this frame was presented
+	uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
+	uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
+	uint32_t m_nReprojectionFlags;
+
+	/** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+	double m_flSystemTimeInSeconds;
+
+	/** These times may include work from other processes due to OS scheduling.
+	* The fewer packets of work these are broken up into, the less likely this will happen.
+	* GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+	* processing that work earlier in the frame. */
+	float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+	float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
+	float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+	float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
+	float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
+	float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)
+
+	/** Miscellaneous measured intervals. */
+	float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
+	float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
+	float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+	float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+	/** The following are all relative to this frame's SystemTimeInSeconds */
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+
+	vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
+
+	uint32_t m_nNumVSyncsReadyForUse;
+	uint32_t m_nNumVSyncsToFirstView;
+};
+
+/** 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;
+};
+
+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;
+
+	/** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+	* ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+	* will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+	* is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+	* ResetSeatedZeroPose may not be exactly an identity matrix.
+	*
+	* NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+	* Users are also able to set their seated zero pose via the OpenVR Dashboard.
+	**/
+	virtual void ResetSeatedZeroPose() = 0;
+
+	/** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+	* applications to represent the seated origin to used or transform object positions from one coordinate
+	* system to the other. 
+	*
+	* The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+	* depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+	virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+	* applications to convert from raw tracking space to the calibrated standing coordinate system. */
+	virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+	/** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+	* relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+	* in the list, or the size of the array needed if not large enough. */
+	virtual uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) = 0;
+
+	/** Returns the level of activity on the device. */
+	virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) = 0;
+
+	/** Convenience utility to apply the specified transform to the specified pose.
+	*   This properly transforms all pose components, including velocity and angular velocity
+	*/
+	virtual void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) = 0;
+
+	/** Returns the device index associated with a specific role, for example the left hand or the right hand. This function is deprecated in favor of the new IVRInput system. */
+	virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) = 0;
+
+	/** Returns the controller type associated with a device index. This function is deprecated in favor of the new IVRInput system. */
+	virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	// ------------------------------------
+	// Property methods
+	// ------------------------------------
+
+	/** Returns the device class of a tracked device. If there has not been a device connected in this slot
+	* since the application started this function will return TrackedDevice_Invalid. For previous detected
+	* devices the function will return the previously observed device class. 
+	*
+	* To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+	* the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+	* actual tracked device. */
+	virtual ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	/** Returns true if there is a device connected in this slot. */
+	virtual bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	/** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+	virtual bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+	virtual float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+	virtual int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+	virtual uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+	virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+	
+	/** Returns an array of one type of property. If the device index is not valid or the property is not a single value or an array of the specified type,
+	* this function will return 0. Otherwise it returns the number of bytes necessary to hold the array of properties. If unBufferSize is
+	* greater than the returned size and pBuffer is non-NULL, pBuffer is filled with the contents of array of properties. */
+	virtual uint32_t GetArrayTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void *pBuffer, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+	virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+	/** returns a string that corresponds with the specified property error. The string will be the name 
+	* of the error enum value for all valid error codes */
+	virtual const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) = 0;
+
+	// ------------------------------------
+	// Event methods
+	// ------------------------------------
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+	/** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+	* this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+	* This pose will always be older than the call to this function and should not be used to render the device. 
+	uncbVREvent should be the size in bytes of the VREvent_t struct */
+	virtual bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+	/** returns the name of an EVREvent enum value */
+	virtual const char *GetEventTypeNameFromEnum( EVREventType eType ) = 0;
+
+	// ------------------------------------
+	// Rendering helper methods
+	// ------------------------------------
+
+	/** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+	* applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+	* This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+	* This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+	* NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+	* Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+	* Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+	*/
+	virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) = 0;
+
+	// ------------------------------------
+	// Controller methods
+	// ------------------------------------
+
+	/** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+	* is invalid. This function is deprecated in favor of the new IVRInput system. */
+	virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) = 0;
+
+	/** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+	* the controller when the controller state was updated most recently. Use this form if you need a precise controller
+	* pose as input to your application when the user presses or releases a button. This function is deprecated in favor of the new IVRInput system. */
+	virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+	/** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+	* and axis combination for 5ms. This function is deprecated in favor of the new IVRInput system. */
+	virtual void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) = 0;
+
+	/** returns the name of an EVRButtonId enum value. This function is deprecated in favor of the new IVRInput system.  */
+	virtual const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) = 0;
+
+	/** returns the name of an EVRControllerAxisType enum value. This function is deprecated in favor of the new IVRInput system. */
+	virtual const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) = 0;
+
+	/** Returns true if this application is receiving input from the system. This would return false if 
+	* system-related functionality is consuming the input stream. */
+	virtual bool IsInputAvailable() = 0;
+
+	/** Returns true SteamVR is drawing controllers on top of the application. Applications should consider
+	* not drawing anything attached to the user's hands in this case. */
+	virtual bool IsSteamVRDrawingControllers() = 0;
+
+	/** Returns true if the user has put SteamVR into a mode that is distracting them from the application.
+	* For applications where this is appropriate, the application should pause ongoing activity. */
+	virtual bool ShouldApplicationPause() = 0;
+
+	/** Returns true if SteamVR is doing significant rendering work and the game should do what it can to reduce
+	* its own workload. One common way to do this is to reduce the size of the render target provided for each eye. */
+	virtual bool ShouldApplicationReduceRenderingWork() = 0;
+
+	// ------------------------------------
+	// Firmware methods
+	// ------------------------------------
+	
+	/** Performs the actual firmware update if applicable. 
+	 * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+	 * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+	 * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+	 * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+	virtual vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+	// ------------------------------------
+	// Application life cycle methods
+	// ------------------------------------
+
+	/** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+	* This extends the timeout until the process is killed. */
+	virtual void AcknowledgeQuit_Exiting() = 0;
+
+	// -------------------------------------
+	// App container sandbox methods
+	// -------------------------------------
+
+	/** Retrieves a null-terminated, semicolon-delimited list of UTF8 file paths that an application 
+	* must have read access to when running inside of an app container. Returns the number of bytes
+	* needed to hold the list. */
+	virtual uint32_t GetAppContainerFilePaths( VR_OUT_STRING() char *pchBuffer, uint32_t unBufferSize ) = 0;
+
+	// -------------------------------------
+	// System methods
+	// -------------------------------------
+
+	/** Returns the current version of the SteamVR runtime. The returned string will remain valid until VR_Shutdown is called.
+	*
+	* NOTE: Is it not appropriate to use this version to test for the presence of any SteamVR feature. Only use this version
+	* number for logging or showing to a user, and not to try to detect anything at runtime. When appropriate, feature-specific
+	* presence information is provided by other APIs. */
+	virtual const char *GetRuntimeVersion() = 0;
+
+};
+
+static const char * const IVRSystem_Version = "IVRSystem_021";
+
+}
+
+
+// ivrapplications.h
+namespace vr
+{
+
+	/** Used for all errors reported by the IVRApplications interface */
+	enum EVRApplicationError
+	{
+		VRApplicationError_None = 0,
+
+		VRApplicationError_AppKeyAlreadyExists = 100,	// Only one application can use any given key
+		VRApplicationError_NoManifest = 101,			// the running application does not have a manifest
+		VRApplicationError_NoApplication = 102,			// No application is running
+		VRApplicationError_InvalidIndex = 103,
+		VRApplicationError_UnknownApplication = 104,	// the application could not be found
+		VRApplicationError_IPCFailed = 105,				// An IPC failure caused the request to fail
+		VRApplicationError_ApplicationAlreadyRunning = 106, 
+		VRApplicationError_InvalidManifest = 107,
+		VRApplicationError_InvalidApplication = 108,
+		VRApplicationError_LaunchFailed = 109,			// the process didn't start
+		VRApplicationError_ApplicationAlreadyStarting = 110, // the system was already starting the same application
+		VRApplicationError_LaunchInProgress = 111,		// The system was already starting a different application
+		VRApplicationError_OldApplicationQuitting = 112, 
+		VRApplicationError_TransitionAborted = 113,
+		VRApplicationError_IsTemplate = 114, // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+		VRApplicationError_SteamVRIsExiting = 115,
+
+		VRApplicationError_BufferTooSmall = 200,		// The provided buffer was too small to fit the requested data
+		VRApplicationError_PropertyNotSet = 201,		// The requested property was not set
+		VRApplicationError_UnknownProperty = 202,
+		VRApplicationError_InvalidParameter = 203,
+	};
+
+	/** The maximum length of an application key */
+	static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+	/** these are the properties available on applications. */
+	enum EVRApplicationProperty
+	{
+		VRApplicationProperty_Name_String				= 0,
+
+		VRApplicationProperty_LaunchType_String			= 11,
+		VRApplicationProperty_WorkingDirectory_String	= 12,
+		VRApplicationProperty_BinaryPath_String			= 13,
+		VRApplicationProperty_Arguments_String			= 14,
+		VRApplicationProperty_URL_String				= 15,
+
+		VRApplicationProperty_Description_String		= 50,
+		VRApplicationProperty_NewsURL_String			= 51,
+		VRApplicationProperty_ImagePath_String			= 52,
+		VRApplicationProperty_Source_String				= 53,
+		VRApplicationProperty_ActionManifestURL_String	= 54,
+
+		VRApplicationProperty_IsDashboardOverlay_Bool	= 60,
+		VRApplicationProperty_IsTemplate_Bool			= 61,
+		VRApplicationProperty_IsInstanced_Bool			= 62,
+		VRApplicationProperty_IsInternal_Bool			= 63,
+		VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+		VRApplicationProperty_IsHidden_Bool				= 65,
+
+		VRApplicationProperty_LastLaunchTime_Uint64		= 70,
+	};
+
+	enum EVRSceneApplicationState
+	{
+		EVRSceneApplicationState_None						      = 0, // Scene Application is not running
+		EVRSceneApplicationState_Starting					      = 1, // Scene Application is starting
+		EVRSceneApplicationState_Quitting					      = 2, // Scene Application is quitting
+		EVRSceneApplicationState_Running						  = 3, // Scene Application is running, and submitting frames, a custom skybox, or a visible overlay
+		EVRSceneApplicationState_Waiting						  = 4, // Scene Application is running, but not drawing anything
+	};
+
+	struct AppOverrideKeys_t
+	{
+		const char *pchKey;
+		const char *pchValue;
+	};
+
+	/** Currently recognized mime types */
+	static const char * const k_pch_MimeType_HomeApp		= "vr/home";
+	static const char * const k_pch_MimeType_GameTheater	= "vr/game_theater";
+
+	class IVRApplications
+	{
+	public:
+
+		// ---------------  Application management  --------------- //
+
+		/** Adds an application manifest to the list to load when building the list of installed applications. 
+		* Temporary manifests are not automatically loaded */
+		virtual EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) = 0;
+
+		/** Removes an application manifest from the list to load when building the list of installed applications. */
+		virtual EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) = 0;
+
+		/** Returns true if an application is installed */
+		virtual bool IsApplicationInstalled( const char *pchAppKey ) = 0;
+
+		/** Returns the number of applications available in the list */
+		virtual uint32_t GetApplicationCount() = 0;
+
+		/** Returns the key of the specified application. The index is at least 0 and is less than the return 
+		* value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+		* fit the key. */
+		virtual EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Returns the key of the application for the specified Process Id. The buffer should be at least 
+		* k_unMaxApplicationKeyLength in order to fit the key. */
+		virtual EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Launches the application. The existing scene application will exit and then the new application will start.
+		* This call is not valid for dashboard overlay applications. */
+		virtual EVRApplicationError LaunchApplication( const char *pchAppKey ) = 0;
+
+		/** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+		* from the manifest file via AppOverrideKeys_t
+		*/
+		virtual EVRApplicationError LaunchTemplateApplication( const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT( unKeys ) const AppOverrideKeys_t *pKeys, uint32_t unKeys ) = 0;
+
+		/** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+		virtual vr::EVRApplicationError LaunchApplicationFromMimeType( const char *pchMimeType, const char *pchArgs ) = 0;
+
+		/** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+		* dashboard overlay applications. */
+		virtual EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) = 0;
+
+		/** Cancel a pending launch for an application */
+		virtual bool CancelApplicationLaunch( const char *pchAppKey ) = 0;
+
+		/** Identifies a running application. OpenVR can't always tell which process started in response
+		* to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+		* for the now running application. Passing a process ID of 0 identifies the calling process. 
+		* The application must be one that's known to the system via a call to AddApplicationManifest. */
+		virtual EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) = 0;
+
+		/** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+		virtual uint32_t GetApplicationProcessId( const char *pchAppKey ) = 0;
+
+		/** Returns a string for an applications error */
+		virtual const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) = 0;
+
+		// ---------------  Application properties  --------------- //
+
+		/** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+		virtual uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Returns a bool value for an application property. Returns false in all error cases. */
+		virtual bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+		virtual uint64_t GetApplicationPropertyUint64( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+		/** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		virtual EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) = 0;
+
+		/** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+		virtual bool GetApplicationAutoLaunch( const char *pchAppKey ) = 0;
+
+		/** Adds this mime-type to the list of supported mime types for this application*/
+		virtual EVRApplicationError SetDefaultApplicationForMimeType( const char *pchAppKey, const char *pchMimeType ) = 0;
+
+		/** return the app key that will open this mime type */
+		virtual bool GetDefaultApplicationForMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Get the list of supported mime types for this application, comma-delimited */
+		virtual bool GetApplicationSupportedMimeTypes( const char *pchAppKey, VR_OUT_STRING() char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer ) = 0;
+
+		/** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+		virtual uint32_t GetApplicationsThatSupportMimeType( const char *pchMimeType, VR_OUT_STRING() char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer ) = 0;
+
+		/** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+		virtual uint32_t GetApplicationLaunchArguments( uint32_t unHandle, VR_OUT_STRING() char *pchArgs, uint32_t unArgs ) = 0;
+
+		// ---------------  Transition methods --------------- //
+
+		/** Returns the app key for the application that is starting up */
+		virtual EVRApplicationError GetStartingApplication( VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+		/** Returns the application transition state */
+		virtual EVRSceneApplicationState GetSceneApplicationState() = 0;
+
+		/** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+		* cause the current scene application to quit, so only call it when you are actually about to launch something else.
+		* What the caller should do about these failures depends on the failure:
+		*   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+		*                                               and try again.
+		*   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+		*   VRApplicationError_LaunchInProgress	      - A different application is already starting. This is a permanent failure.
+		*   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+		*/
+		virtual EVRApplicationError PerformApplicationPrelaunchCheck( const char *pchAppKey ) = 0;
+
+		/** Returns a string for an application transition state */
+		virtual const char *GetSceneApplicationStateNameFromEnum( EVRSceneApplicationState state ) = 0;
+
+		/** Starts a subprocess within the calling application. This
+		* suppresses all application transition UI and automatically identifies the new executable 
+		* as part of the same application. On success the calling process should exit immediately. 
+		* If working directory is NULL or "" the directory portion of the binary path will be 
+		* the working directory. */
+		virtual EVRApplicationError LaunchInternalProcess( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory ) = 0;
+
+		/** Returns the current scene process ID according to the application system. A scene process will get scene
+		* focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+		* type. */
+		virtual uint32_t GetCurrentSceneProcessId() = 0;
+	};
+
+	static const char * const IVRApplications_Version = "IVRApplications_007";
+
+} // namespace vr
+
+// ivrsettings.h
+#include <string>
+
+namespace vr
+{
+	enum EVRSettingsError
+	{
+		VRSettingsError_None = 0,
+		VRSettingsError_IPCFailed = 1,
+		VRSettingsError_WriteFailed = 2,
+		VRSettingsError_ReadFailed = 3,
+		VRSettingsError_JsonParseFailed = 4,
+		VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
+	};
+
+	// The maximum length of a settings key
+	static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+	class IVRSettings
+	{
+	public:
+		virtual const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) = 0;
+
+		// Returns true if file sync occurred (force or settings dirty)
+		virtual bool Sync( bool bForce = false, EVRSettingsError *peError = nullptr ) = 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_002";
+
+	class CVRSettingHelper
+	{
+		IVRSettings *m_pSettings;
+	public:
+		CVRSettingHelper( IVRSettings *pSettings ) 
+		{ 
+			m_pSettings = pSettings; 
+		}
+
+		const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) 
+		{ 
+			return m_pSettings->GetSettingsErrorNameFromEnum( eError ); 
+		}
+
+		// Returns true if file sync occurred (force or settings dirty)
+		bool Sync( bool bForce = false, EVRSettingsError *peError = nullptr ) 
+		{ 
+			return m_pSettings->Sync( bForce, peError ); 
+		}
+
+		void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetBool( pchSection, pchSettingsKey, bValue, peError );
+		}
+
+		void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetInt32( pchSection, pchSettingsKey, nValue, peError );
+		}
+		void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetFloat( pchSection, pchSettingsKey, flValue, peError );
+		}
+		void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( pchSection, pchSettingsKey, pchValue, peError );
+		}
+		void SetString( const std::string & sSection, const std::string &  sSettingsKey, const std::string & sValue, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->SetString( sSection.c_str(), sSettingsKey.c_str(), sValue.c_str(), peError );
+		}
+
+		bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetBool( pchSection, pchSettingsKey, peError );
+		}
+		int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetInt32( pchSection, pchSettingsKey, peError );
+		}
+		float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			return m_pSettings->GetFloat( pchSection, pchSettingsKey, peError );
+		}
+		void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->GetString( pchSection, pchSettingsKey, pchValue, unValueLen, peError );
+		}
+		std::string GetString( const std::string & sSection, const std::string & sSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			char buf[4096];
+			vr::EVRSettingsError eError;
+			m_pSettings->GetString( sSection.c_str(), sSettingsKey.c_str(), buf, sizeof( buf ), &eError );
+			if ( peError )
+				*peError = eError;
+			if ( eError == vr::VRSettingsError_None )
+				return buf;
+			else
+				return "";
+		}
+
+		void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveSection( pchSection, peError );
+		}
+		void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr )
+		{
+			m_pSettings->RemoveKeyInSection( pchSection, pchSettingsKey, peError );
+		}
+	};
+
+
+	//-----------------------------------------------------------------------------
+	// steamvr keys
+	static const char * const k_pch_SteamVR_Section = "steamvr";
+	static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+	static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+	static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+	static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+	static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+	static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+	static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+	static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
+	static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+	static const char * const k_pch_SteamVR_IPD_Float = "ipd";
+	static const char * const k_pch_SteamVR_Background_String = "background";
+	static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+	static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+	static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+	static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
+	static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+	static const char * const k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+	static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
+	static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+	static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+	static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+	static const char * const k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+	static const char * const k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+	static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+	static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+	static const char * const k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+	static const char * const k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+	static const char * const k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+	static const char * const k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+	static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+	static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+	static const char * const k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+	static const char * const k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+	static const char * const k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+	static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+	static const char * const k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+	static const char * const k_pch_SteamVR_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_DebugInput = "debugInput";
+	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";
+
+	//-----------------------------------------------------------------------------
+	// 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";
+
+	//-----------------------------------------------------------------------------
+	// 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_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+	static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+	static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+	static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+	static const char * const k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+
+	//-----------------------------------------------------------------------------
+	// camera keys
+	static const char * const k_pch_Camera_Section = "camera";
+	static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+	static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+	static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+	static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+	static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+	static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+	static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+	static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+	static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+	static const char * const k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode";
+
+	//-----------------------------------------------------------------------------
+	// audio keys
+	static const char * const k_pch_audio_Section = "audio";
+	static const char * const k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+	static const char * const k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+	static const char * const k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+	static const char * const k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+	static const char * const k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+	static const char * const k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+	static const char * const k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+	static const char * const k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+	static const char * const k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+	static const char * const k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+	static const char * const k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+	static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+	//-----------------------------------------------------------------------------
+	// power management keys
+	static const char * const k_pch_Power_Section = "power";
+	static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+	static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+	static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+	static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+	static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+	static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+	//-----------------------------------------------------------------------------
+	// dashboard keys
+	static const char * const k_pch_Dashboard_Section = "dashboard";
+	static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+	static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+	static const char * const k_pch_Dashboard_UseWebKeyboard = "useWebKeyboard";
+	static const char * const k_pch_Dashboard_UseWebSettings = "useWebSettings";
+
+	//-----------------------------------------------------------------------------
+	// 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_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_BindingCurrentURLSuffix_String = "CurrentURL";
+	static const char* const k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+
+	//-----------------------------------------------------------------------------
+	// 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";
+
+
+} // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+enum ChaperoneCalibrationState
+{
+	// OK!
+	ChaperoneCalibrationState_OK = 1,									// Chaperone is fully calibrated and working correctly
+
+	// Warnings
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,	// A base station thinks that it might have moved
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,			// There are less base stations than when calibrated
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,		// Seated bounds haven't been calibrated for the current tracking center
+
+	// Errors
+	ChaperoneCalibrationState_Error = 200,								// The UniverseID is invalid
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,		// Tracking center hasn't be calibrated for at least one of the base stations
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,			// Tracking center is calibrated, but base stations disagree on the tracking space
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,				// Play Area hasn't been calibrated for the current tracking center
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,		// Collision Bounds haven't been calibrated for the current tracking center
+};
+
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+
+	/** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+	virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+	* Tracking space center (0,0,0) is the center of the Play Area. **/
+	virtual bool GetPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+	* Corners are in counter-clockwise order.
+	* Standing center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+	/** Reload Chaperone data from the .vrchap file on disk. */
+	virtual void ReloadInfo( void ) = 0;
+
+	/** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+	virtual void SetSceneColor( HmdColor_t color ) = 0;
+
+	/** Get the current chaperone bounds draw color and brightness **/
+	virtual void GetBoundsColor( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor ) = 0;
+
+	/** Determine whether the bounds are showing right now **/
+	virtual bool AreBoundsVisible() = 0;
+
+	/** Force the bounds to show, mostly for utilities **/
+	virtual void ForceBoundsVisible( bool bForce ) = 0;
+};
+
+static const char * const IVRChaperone_Version = "IVRChaperone_003";
+
+#pragma pack( pop )
+
+}
+
+// ivrchaperonesetup.h
+namespace vr
+{
+
+enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,		// The live chaperone config, used by most applications and games
+	EChaperoneConfigFile_Temp = 2,		// The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+
+	/** Saves the current working copy to disk */
+	virtual bool CommitWorkingCopy( EChaperoneConfigFile configFile ) = 0;
+
+	/** Reverts the working copy to match the live chaperone calibration.
+	* To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+	* Only after this should you do gets and sets on the existing data. */
+	virtual void RevertWorkingCopy() = 0;
+
+	/** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+	* Tracking space center (0,0,0) is the center of the Play Area. */
+	virtual bool GetWorkingPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+	/** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+	* Corners are in clockwise order.
+	* Tracking space center (0,0,0) is the center of the Play Area.
+	* It's a rectangle.
+	* 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+	* Height of every corner is 0Y (on the floor). **/
+	virtual bool GetWorkingPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified from the working copy. */
+	virtual bool GetWorkingCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+	/** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+	* into the buffer up to the max specified. */
+	virtual bool GetLiveCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+	/** Returns the preferred seated position from the working copy. */
+	virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+	/** Returns the standing origin from the working copy. */
+	virtual bool GetWorkingStandingZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose ) = 0;
+
+	/** Sets the Play Area in the working copy. */
+	virtual void SetWorkingPlayAreaSize( float sizeX, float sizeZ ) = 0;
+
+	/** Sets the Collision Bounds in the working copy. */
+	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,
+};
+
+/** 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;
+};
+
+#pragma pack( pop )
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+	/** Sets tracking space returned by WaitGetPoses */
+	virtual void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) = 0;
+
+	/** Gets current tracking space returned by WaitGetPoses */
+	virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+	/** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+	* This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+	* start rendering.
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+	*/
+	virtual EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+	/** Get the last set of poses returned by WaitGetPoses. */
+	virtual EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+		VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+	/** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+	* Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+	* It is okay to pass NULL for either pose if you only want one of the values. */
+	virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) = 0;
+
+	/** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+	* Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+	*
+	* OpenGL dirty state:
+	*	glBindTexture
+	*
+	* Return codes:
+	*	- IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+	*	- DoNotHaveFocus (some other app has taken focus)
+	*	- TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+	*	- SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+	*	- TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+	*	- InvalidTexture (usually means bad arguments passed in)
+	*	- AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+	*/
+	virtual EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) = 0;
+
+	/** Clears the frame that was sent with the last call to Submit. This will cause the 
+	* compositor to show the grid until Submit is called again. */
+	virtual void ClearLastSubmittedFrame() = 0;
+
+	/** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+	* This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+	* For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+	* introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+	* eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+	virtual void PostPresentHandoff() = 0;
+
+	/** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+	* Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+	virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) = 0;
+
+	/** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+	* Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+	virtual uint32_t GetFrameTimings( VR_ARRAY_COUNT( nFrames ) Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0;
+
+	/** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+	* Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+	virtual float GetFrameTimeRemaining() = 0;
+
+	/** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+	virtual void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) = 0;
+
+	/** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+	* 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+	* would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+	virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) = 0;
+
+	/** Get current fade color value. */
+	virtual HmdColor_t GetCurrentFadeColor( bool bBackground = false ) = 0;
+
+	/** Fading the Grid in or out in fSeconds */
+	virtual void FadeGrid( float fSeconds, bool bFadeIn ) = 0;
+
+	/** Get current alpha value of grid. */
+	virtual float GetCurrentGridAlpha() = 0;
+
+	/** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+	* Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+	* If two are passed, it is assumed a lat-long stereo pair. */
+	virtual EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) = 0;
+
+	/** Resets compositor skybox back to defaults. */
+	virtual void ClearSkyboxOverride() = 0;
+
+	/** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+	* and is obscuring the compositor window. */
+	virtual void CompositorBringToFront() = 0;
+
+	/** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+	virtual void CompositorGoToBack() = 0;
+
+	/** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+	* circumstances the compositor will manage its own life cycle based on what applications are running. */
+	virtual void CompositorQuit() = 0;
+	
+	/** Return whether the compositor is fullscreen */
+	virtual bool IsFullscreen() = 0;
+
+	/** Returns the process ID of the process that is currently rendering the scene */
+	virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+	/** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+	* Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+	virtual uint32_t GetLastFrameRenderer() = 0;
+
+	/** Returns true if the current process has the scene focus */
+	virtual bool CanRenderScene() = 0;
+
+	/** DEPRECATED: Opens the headset view (as either a window or docked widget depending on user's preferences) that displays what the user
+	* sees in the headset. */
+	virtual void ShowMirrorWindow() = 0;
+
+	/** DEPRECATED: Closes the headset view, either as a window or docked widget. */
+	virtual void HideMirrorWindow() = 0;
+
+	/** DEPRECATED: Returns true if the headset view (either as a window or docked widget) is shown. */
+	virtual bool IsMirrorWindowVisible() = 0;
+
+	/** Writes back buffer and stereo left/right pair from the application to a 'screenshots' folder in the SteamVR runtime root. */
+	virtual void CompositorDumpImages() = 0;
+
+	/** Let an app know it should be rendering with low resources. */
+	virtual bool ShouldAppRenderWithLowResources() = 0;
+
+	/** Override interleaved reprojection logic to force on. */
+	virtual void ForceInterleavedReprojectionOn( bool bOverride ) = 0;
+
+	/** Force reconnecting to the compositor process. */
+	virtual void ForceReconnectProcess() = 0;
+
+	/** Temporarily suspends rendering (useful for finer control over scene transitions). */
+	virtual void SuspendRendering( bool bSuspend ) = 0;
+
+	/** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+	* instead of calling Release on the resource itself. */
+	virtual vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) = 0;
+	virtual void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) = 0;
+
+	/** Access to mirror textures from OpenGL. */
+	virtual vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) = 0;
+	virtual bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+	virtual void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+	virtual void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+
+	/** [Vulkan Only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+	virtual uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	/** [Vulkan only]
+	* return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+	* null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+	virtual uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* There are two purposes for SetExplicitTimingMode:
+	*	1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+	*	2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+	*	another thread while WaitGetPoses is executing.
+	*
+	* More accurate GPU timestamp for the start of the frame is achieved by the application calling
+	* SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+	* This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+	* WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+	* application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+	* Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+	*
+	* Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+	* the application should set the timing mode to Explicit_ApplicationPerformsPostPresentHandoff and *MUST* call PostPresentHandoff
+	* itself. If these conditions are met, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+	* and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+	* thread. */
+	virtual void SetExplicitTimingMode( EVRCompositorTimingMode eTimingMode ) = 0;
+
+	/** [ Vulkan/D3D12 Only ]
+	* Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+	* the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+	* This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+	* will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+	* Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+	virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+
+	/** Indicates whether or not motion smoothing is enabled by the user settings.
+	* If you want to know if motion smoothing actually triggered due to a late frame, check Compositor_FrameTiming
+	* m_nReprojectionFlags & VRCompositor_ReprojectionMotion instead. */
+	virtual bool IsMotionSmoothingEnabled() = 0;
+
+	/** Indicates whether or not motion smoothing is supported by the current hardware. */
+	virtual bool IsMotionSmoothingSupported() = 0;
+
+	/** Indicates whether or not the current scene focus app is currently loading.  This is inferred from its use of FadeGrid to
+	* explicitly fade to the compositor to cover up the fact that it cannot render at a sustained full framerate during this time. */
+	virtual bool IsCurrentSceneFocusAppLoading() = 0;
+};
+
+static const char * const IVRCompositor_Version = "IVRCompositor_022";
+
+} // 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 = 64;
+
+	/** 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, // Analog inputs from tracked controllers are turned into DualAnalog events
+	};
+
+	/** Allows the caller to figure out which overlay transform getter to call. */
+	enum VROverlayTransformType
+	{
+		VROverlayTransform_Absolute					= 0,
+		VROverlayTransform_TrackedDeviceRelative	= 1,
+		VROverlayTransform_SystemOverlay			= 2,
+		VROverlayTransform_TrackedComponent 		= 3,
+	};
+
+	/** 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,
+	};
+
+	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;
+	};
+
+	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;
+
+		/** 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;
+
+		/** Gets render model to draw behind this overlay */
+		virtual uint32_t GetOverlayRenderModel( vr::VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError ) = 0;
+
+		/** Sets render model to draw behind this overlay and the vertex color to use, pass null for pColor to match the overlays vertex color. 
+			The model is scaled by the same amount as the overlay, with a default of 1m. */
+		virtual vr::EVROverlayError SetOverlayRenderModel( vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor ) = 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;
+
+		/** 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 the analog input to Dual Analog coordinate scale for the specified overlay. */
+		virtual EVROverlayError SetOverlayDualAnalogTransform( VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, const HmdVector2_t *pvCenter, float fRadius ) = 0;
+
+		/** Gets the analog input to Dual Analog coordinate scale for the specified overlay. */
+		virtual EVROverlayError GetOverlayDualAnalogTransform( VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t *pvCenter, float *pfRadius ) = 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 unDepth ) = 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 **/
+		virtual EVROverlayError ShowKeyboard( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue ) = 0;
+
+		virtual EVROverlayError ShowKeyboardForOverlay( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, 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;
+
+		// ---------------------------------------------
+		// Overlay input methods
+		// ---------------------------------------------
+
+		/** 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;
+
+		virtual EVROverlayError GetOverlayFlags( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags ) = 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_021";
+
+} // namespace vr
+
+// 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,
+};
+
+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),
+};
+
+/** 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;
+};
+
+/** 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. All textures are RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+};
+#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
+{
+	static const uint32_t k_unMaxActionNameLength = 64;
+	static const uint32_t k_unMaxActionSetNameLength = 64;
+	static const uint32_t k_unMaxActionOriginCount = 16;
+	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];
+	};
+
+	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. */
+		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;
+
+		// ---------------  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;
+
+		// --------------- 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;
+	};
+
+	static const char * const IVRInput_Version = "IVRInput_007";
+
+} // 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;
+		}
+
+		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;
+		IVROverlay			*m_pVROverlay;
+		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 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_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 e67e46e0..61de9bfa 100644
--- a/vrclient_x64/tests/capi_thunks_autogen.c
+++ b/vrclient_x64/tests/capi_thunks_autogen.c
@@ -1,14 +1,14 @@
 /* This file is auto-generated, do not edit. */
 #include "capi_thunks_autogen.h"
 
-void __thiscall IVRSystem_020_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+void __thiscall IVRSystem_021_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pnWidth);
     push_ptr_parameter(pnHeight);
 }
 
-HmdMatrix44_t *__thiscall IVRSystem_020_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
+HmdMatrix44_t *__thiscall IVRSystem_021_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(_r);
@@ -18,7 +18,7 @@ HmdMatrix44_t *__thiscall IVRSystem_020_GetProjectionMatrix(void *_this, HmdMatr
     return 0;
 }
 
-void __thiscall IVRSystem_020_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+void __thiscall IVRSystem_021_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eEye);
@@ -28,7 +28,7 @@ void __thiscall IVRSystem_020_GetProjectionRaw(void *_this, EVREye eEye, float *
     push_ptr_parameter(pfBottom);
 }
 
-bool __thiscall IVRSystem_020_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+bool __thiscall IVRSystem_021_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eEye);
@@ -38,7 +38,7 @@ bool __thiscall IVRSystem_020_ComputeDistortion(void *_this, EVREye eEye, float
     return 0;
 }
 
-HmdMatrix34_t *__thiscall IVRSystem_020_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+HmdMatrix34_t *__thiscall IVRSystem_021_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(_r);
@@ -46,7 +46,7 @@ HmdMatrix34_t *__thiscall IVRSystem_020_GetEyeToHeadTransform(void *_this, HmdMa
     return 0;
 }
 
-bool __thiscall IVRSystem_020_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+bool __thiscall IVRSystem_021_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pfSecondsSinceLastVsync);
@@ -54,19 +54,19 @@ bool __thiscall IVRSystem_020_GetTimeSinceLastVsync(void *_this, float * pfSecon
     return 0;
 }
 
-int32_t __thiscall IVRSystem_020_GetD3D9AdapterIndex(void *_this)
+int32_t __thiscall IVRSystem_021_GetD3D9AdapterIndex(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-void __thiscall IVRSystem_020_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+void __thiscall IVRSystem_021_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pnAdapterIndex);
 }
 
-void __thiscall IVRSystem_020_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
+void __thiscall IVRSystem_021_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pnDevice);
@@ -74,20 +74,20 @@ void __thiscall IVRSystem_020_GetOutputDevice(void *_this, uint64_t * pnDevice,
     push_ptr_parameter(pInstance);
 }
 
-bool __thiscall IVRSystem_020_IsDisplayOnDesktop(void *_this)
+bool __thiscall IVRSystem_021_IsDisplayOnDesktop(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVRSystem_020_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+bool __thiscall IVRSystem_021_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
 {
     push_ptr_parameter(_this);
     push_bool_parameter(bIsVisibleOnDesktop);
     return 0;
 }
 
-void __thiscall IVRSystem_020_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+void __thiscall IVRSystem_021_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eOrigin);
@@ -96,26 +96,26 @@ void __thiscall IVRSystem_020_GetDeviceToAbsoluteTrackingPose(void *_this, ETrac
     push_uint32_parameter(unTrackedDevicePoseArrayCount);
 }
 
-void __thiscall IVRSystem_020_ResetSeatedZeroPose(void *_this)
+void __thiscall IVRSystem_021_ResetSeatedZeroPose(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-HmdMatrix34_t *__thiscall IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+HmdMatrix34_t *__thiscall IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(_r);
     return 0;
 }
 
-HmdMatrix34_t *__thiscall IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+HmdMatrix34_t *__thiscall IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(_r);
     return 0;
 }
 
-uint32_t __thiscall IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+uint32_t __thiscall IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eTrackedDeviceClass);
@@ -125,14 +125,14 @@ uint32_t __thiscall IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(void *_th
     return 0;
 }
 
-EDeviceActivityLevel __thiscall IVRSystem_020_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+EDeviceActivityLevel __thiscall IVRSystem_021_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceId);
     return 0;
 }
 
-void __thiscall IVRSystem_020_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+void __thiscall IVRSystem_021_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pOutputPose);
@@ -140,35 +140,35 @@ void __thiscall IVRSystem_020_ApplyTransform(void *_this, TrackedDevicePose_t *
     push_ptr_parameter(pTransform);
 }
 
-TrackedDeviceIndex_t __thiscall IVRSystem_020_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+TrackedDeviceIndex_t __thiscall IVRSystem_021_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceType);
     return 0;
 }
 
-ETrackedControllerRole __thiscall IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+ETrackedControllerRole __thiscall IVRSystem_021_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
     return 0;
 }
 
-ETrackedDeviceClass __thiscall IVRSystem_020_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+ETrackedDeviceClass __thiscall IVRSystem_021_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
     return 0;
 }
 
-bool __thiscall IVRSystem_020_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+bool __thiscall IVRSystem_021_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
     return 0;
 }
 
-bool __thiscall IVRSystem_020_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+bool __thiscall IVRSystem_021_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
@@ -177,7 +177,7 @@ bool __thiscall IVRSystem_020_GetBoolTrackedDeviceProperty(void *_this, TrackedD
     return 0;
 }
 
-float __thiscall IVRSystem_020_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+float __thiscall IVRSystem_021_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
@@ -186,7 +186,7 @@ float __thiscall IVRSystem_020_GetFloatTrackedDeviceProperty(void *_this, Tracke
     return 0;
 }
 
-int32_t __thiscall IVRSystem_020_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+int32_t __thiscall IVRSystem_021_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
@@ -195,7 +195,7 @@ int32_t __thiscall IVRSystem_020_GetInt32TrackedDeviceProperty(void *_this, Trac
     return 0;
 }
 
-uint64_t __thiscall IVRSystem_020_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+uint64_t __thiscall IVRSystem_021_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
@@ -204,7 +204,7 @@ uint64_t __thiscall IVRSystem_020_GetUint64TrackedDeviceProperty(void *_this, Tr
     return 0;
 }
 
-HmdMatrix34_t *__thiscall IVRSystem_020_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+HmdMatrix34_t *__thiscall IVRSystem_021_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(_r);
@@ -214,7 +214,7 @@ HmdMatrix34_t *__thiscall IVRSystem_020_GetMatrix34TrackedDeviceProperty(void *_
     return 0;
 }
 
-uint32_t __thiscall IVRSystem_020_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
+uint32_t __thiscall IVRSystem_021_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
@@ -226,7 +226,7 @@ uint32_t __thiscall IVRSystem_020_GetArrayTrackedDeviceProperty(void *_this, Tra
     return 0;
 }
 
-uint32_t __thiscall IVRSystem_020_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+uint32_t __thiscall IVRSystem_021_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
@@ -237,14 +237,14 @@ uint32_t __thiscall IVRSystem_020_GetStringTrackedDeviceProperty(void *_this, Tr
     return 0;
 }
 
-const char * __thiscall IVRSystem_020_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+const char * __thiscall IVRSystem_021_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(error);
     return 0;
 }
 
-bool __thiscall IVRSystem_020_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+bool __thiscall IVRSystem_021_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pEvent);
@@ -252,7 +252,7 @@ bool __thiscall IVRSystem_020_PollNextEvent(void *_this, VREvent_t * pEvent, uin
     return 0;
 }
 
-bool __thiscall IVRSystem_020_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall IVRSystem_021_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eOrigin);
@@ -262,14 +262,14 @@ bool __thiscall IVRSystem_020_PollNextEventWithPose(void *_this, ETrackingUniver
     return 0;
 }
 
-const char * __thiscall IVRSystem_020_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+const char * __thiscall IVRSystem_021_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eType);
     return 0;
 }
 
-HiddenAreaMesh_t *__thiscall IVRSystem_020_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
+HiddenAreaMesh_t *__thiscall IVRSystem_021_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(_r);
@@ -278,7 +278,7 @@ HiddenAreaMesh_t *__thiscall IVRSystem_020_GetHiddenAreaMesh(void *_this, Hidden
     return 0;
 }
 
-bool __thiscall IVRSystem_020_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize)
+bool __thiscall IVRSystem_021_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unControllerDeviceIndex);
@@ -287,7 +287,7 @@ bool __thiscall IVRSystem_020_GetControllerState(void *_this, TrackedDeviceIndex
     return 0;
 }
 
-bool __thiscall IVRSystem_020_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+bool __thiscall IVRSystem_021_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eOrigin);
@@ -298,7 +298,7 @@ bool __thiscall IVRSystem_020_GetControllerStateWithPose(void *_this, ETrackingU
     return 0;
 }
 
-void __thiscall IVRSystem_020_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+void __thiscall IVRSystem_021_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unControllerDeviceIndex);
@@ -306,62 +306,57 @@ void __thiscall IVRSystem_020_TriggerHapticPulse(void *_this, TrackedDeviceIndex
     push_uint32_parameter(usDurationMicroSec);
 }
 
-const char * __thiscall IVRSystem_020_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+const char * __thiscall IVRSystem_021_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eButtonId);
     return 0;
 }
 
-const char * __thiscall IVRSystem_020_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+const char * __thiscall IVRSystem_021_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eAxisType);
     return 0;
 }
 
-bool __thiscall IVRSystem_020_IsInputAvailable(void *_this)
+bool __thiscall IVRSystem_021_IsInputAvailable(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVRSystem_020_IsSteamVRDrawingControllers(void *_this)
+bool __thiscall IVRSystem_021_IsSteamVRDrawingControllers(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVRSystem_020_ShouldApplicationPause(void *_this)
+bool __thiscall IVRSystem_021_ShouldApplicationPause(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVRSystem_020_ShouldApplicationReduceRenderingWork(void *_this)
+bool __thiscall IVRSystem_021_ShouldApplicationReduceRenderingWork(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVRFirmwareError __thiscall IVRSystem_020_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+EVRFirmwareError __thiscall IVRSystem_021_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unDeviceIndex);
     return 0;
 }
 
-void __thiscall IVRSystem_020_AcknowledgeQuit_Exiting(void *_this)
-{
-    push_ptr_parameter(_this);
-}
-
-void __thiscall IVRSystem_020_AcknowledgeQuit_UserPrompt(void *_this)
+void __thiscall IVRSystem_021_AcknowledgeQuit_Exiting(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-uint32_t __thiscall IVRSystem_020_GetAppContainerFilePaths(void *_this, char * pchBuffer, uint32_t unBufferSize)
+uint32_t __thiscall IVRSystem_021_GetAppContainerFilePaths(void *_this, char * pchBuffer, uint32_t unBufferSize)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchBuffer);
@@ -369,13 +364,13 @@ uint32_t __thiscall IVRSystem_020_GetAppContainerFilePaths(void *_this, char * p
     return 0;
 }
 
-const char * __thiscall IVRSystem_020_GetRuntimeVersion(void *_this)
+const char * __thiscall IVRSystem_021_GetRuntimeVersion(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+EVRApplicationError __thiscall IVRApplications_007_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchApplicationManifestFullPath);
@@ -383,27 +378,27 @@ EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
+EVRApplicationError __thiscall IVRApplications_007_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchApplicationManifestFullPath);
     return 0;
 }
 
-bool __thiscall IVRApplications_006_IsApplicationInstalled(void *_this, const char * pchAppKey)
+bool __thiscall IVRApplications_007_IsApplicationInstalled(void *_this, const char * pchAppKey)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
     return 0;
 }
 
-uint32_t __thiscall IVRApplications_006_GetApplicationCount(void *_this)
+uint32_t __thiscall IVRApplications_007_GetApplicationCount(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+EVRApplicationError __thiscall IVRApplications_007_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unApplicationIndex);
@@ -412,7 +407,7 @@ EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByIndex(void
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+EVRApplicationError __thiscall IVRApplications_007_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unProcessId);
@@ -421,14 +416,14 @@ EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByProcessId(
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchApplication(void *_this, const char * pchAppKey)
+EVRApplicationError __thiscall IVRApplications_007_LaunchApplication(void *_this, const char * pchAppKey)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys)
+EVRApplicationError __thiscall IVRApplications_007_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchTemplateAppKey);
@@ -438,7 +433,7 @@ EVRApplicationError __thiscall IVRApplications_006_LaunchTemplateApplication(voi
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchApplicationFromMimeType(void *_this, const char * pchMimeType, const char * pchArgs)
+EVRApplicationError __thiscall IVRApplications_007_LaunchApplicationFromMimeType(void *_this, const char * pchMimeType, const char * pchArgs)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchMimeType);
@@ -446,21 +441,21 @@ EVRApplicationError __thiscall IVRApplications_006_LaunchApplicationFromMimeType
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
+EVRApplicationError __thiscall IVRApplications_007_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
     return 0;
 }
 
-bool __thiscall IVRApplications_006_CancelApplicationLaunch(void *_this, const char * pchAppKey)
+bool __thiscall IVRApplications_007_CancelApplicationLaunch(void *_this, const char * pchAppKey)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
+EVRApplicationError __thiscall IVRApplications_007_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unProcessId);
@@ -468,21 +463,21 @@ EVRApplicationError __thiscall IVRApplications_006_IdentifyApplication(void *_th
     return 0;
 }
 
-uint32_t __thiscall IVRApplications_006_GetApplicationProcessId(void *_this, const char * pchAppKey)
+uint32_t __thiscall IVRApplications_007_GetApplicationProcessId(void *_this, const char * pchAppKey)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
     return 0;
 }
 
-const char * __thiscall IVRApplications_006_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
+const char * __thiscall IVRApplications_007_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(error);
     return 0;
 }
 
-uint32_t __thiscall IVRApplications_006_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+uint32_t __thiscall IVRApplications_007_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
@@ -493,7 +488,7 @@ uint32_t __thiscall IVRApplications_006_GetApplicationPropertyString(void *_this
     return 0;
 }
 
-bool __thiscall IVRApplications_006_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+bool __thiscall IVRApplications_007_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
@@ -502,7 +497,7 @@ bool __thiscall IVRApplications_006_GetApplicationPropertyBool(void *_this, cons
     return 0;
 }
 
-uint64_t __thiscall IVRApplications_006_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+uint64_t __thiscall IVRApplications_007_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
@@ -511,7 +506,7 @@ uint64_t __thiscall IVRApplications_006_GetApplicationPropertyUint64(void *_this
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
+EVRApplicationError __thiscall IVRApplications_007_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
@@ -519,14 +514,14 @@ EVRApplicationError __thiscall IVRApplications_006_SetApplicationAutoLaunch(void
     return 0;
 }
 
-bool __thiscall IVRApplications_006_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
+bool __thiscall IVRApplications_007_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_SetDefaultApplicationForMimeType(void *_this, const char * pchAppKey, const char * pchMimeType)
+EVRApplicationError __thiscall IVRApplications_007_SetDefaultApplicationForMimeType(void *_this, const char * pchAppKey, const char * pchMimeType)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
@@ -534,7 +529,7 @@ EVRApplicationError __thiscall IVRApplications_006_SetDefaultApplicationForMimeT
     return 0;
 }
 
-bool __thiscall IVRApplications_006_GetDefaultApplicationForMimeType(void *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+bool __thiscall IVRApplications_007_GetDefaultApplicationForMimeType(void *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchMimeType);
@@ -543,7 +538,7 @@ bool __thiscall IVRApplications_006_GetDefaultApplicationForMimeType(void *_this
     return 0;
 }
 
-bool __thiscall IVRApplications_006_GetApplicationSupportedMimeTypes(void *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer)
+bool __thiscall IVRApplications_007_GetApplicationSupportedMimeTypes(void *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
@@ -552,7 +547,7 @@ bool __thiscall IVRApplications_006_GetApplicationSupportedMimeTypes(void *_this
     return 0;
 }
 
-uint32_t __thiscall IVRApplications_006_GetApplicationsThatSupportMimeType(void *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer)
+uint32_t __thiscall IVRApplications_007_GetApplicationsThatSupportMimeType(void *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchMimeType);
@@ -561,7 +556,7 @@ uint32_t __thiscall IVRApplications_006_GetApplicationsThatSupportMimeType(void
     return 0;
 }
 
-uint32_t __thiscall IVRApplications_006_GetApplicationLaunchArguments(void *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs)
+uint32_t __thiscall IVRApplications_007_GetApplicationLaunchArguments(void *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(unHandle);
@@ -570,7 +565,7 @@ uint32_t __thiscall IVRApplications_006_GetApplicationLaunchArguments(void *_thi
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+EVRApplicationError __thiscall IVRApplications_007_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKeyBuffer);
@@ -578,33 +573,27 @@ EVRApplicationError __thiscall IVRApplications_006_GetStartingApplication(void *
     return 0;
 }
 
-EVRApplicationTransitionState __thiscall IVRApplications_006_GetTransitionState(void *_this)
+EVRSceneApplicationState __thiscall IVRApplications_007_GetSceneApplicationState(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVRApplicationError __thiscall IVRApplications_006_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
+EVRApplicationError __thiscall IVRApplications_007_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchAppKey);
     return 0;
 }
 
-const char * __thiscall IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state)
+const char * __thiscall IVRApplications_007_GetSceneApplicationStateNameFromEnum(void *_this, EVRSceneApplicationState state)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(state);
     return 0;
 }
 
-bool __thiscall IVRApplications_006_IsQuitUserPromptRequested(void *_this)
-{
-    push_ptr_parameter(_this);
-    return 0;
-}
-
-EVRApplicationError __thiscall IVRApplications_006_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
+EVRApplicationError __thiscall IVRApplications_007_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchBinaryPath);
@@ -613,7 +602,7 @@ EVRApplicationError __thiscall IVRApplications_006_LaunchInternalProcess(void *_
     return 0;
 }
 
-uint32_t __thiscall IVRApplications_006_GetCurrentSceneProcessId(void *_this)
+uint32_t __thiscall IVRApplications_007_GetCurrentSceneProcessId(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
@@ -1238,7 +1227,7 @@ EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_t
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+EVROverlayError __thiscall IVROverlay_021_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchOverlayKey);
@@ -1246,7 +1235,7 @@ EVROverlayError __thiscall IVROverlay_020_FindOverlay(void *_this, const char *
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+EVROverlayError __thiscall IVROverlay_021_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchOverlayKey);
@@ -1255,14 +1244,14 @@ EVROverlayError __thiscall IVROverlay_020_CreateOverlay(void *_this, const char
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_021_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_020_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+uint32_t __thiscall IVROverlay_021_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1272,7 +1261,7 @@ uint32_t __thiscall IVROverlay_020_GetOverlayKey(void *_this, VROverlayHandle_t
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_020_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+uint32_t __thiscall IVROverlay_021_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1282,7 +1271,7 @@ uint32_t __thiscall IVROverlay_020_GetOverlayName(void *_this, VROverlayHandle_t
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1290,7 +1279,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayName(void *_this, VROverlayH
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+EVROverlayError __thiscall IVROverlay_021_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);
@@ -1301,14 +1290,14 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayImageData(void *_this, VROve
     return 0;
 }
 
-const char * __thiscall IVROverlay_020_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+const char * __thiscall IVROverlay_021_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(error);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1316,14 +1305,14 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderingPid(void *_this, VR
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_020_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+uint32_t __thiscall IVROverlay_021_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1332,7 +1321,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayFlag(void *_this, VROverlayH
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1341,7 +1330,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayFlag(void *_this, VROverlayH
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1351,7 +1340,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayColor(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1361,7 +1350,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayColor(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1369,7 +1358,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayAlpha(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1377,7 +1366,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayAlpha(void *_this, VROverlay
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1385,7 +1374,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayTexelAspect(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1393,7 +1382,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTexelAspect(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+EVROverlayError __thiscall IVROverlay_021_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1401,7 +1390,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlaySortOrder(void *_this, VROve
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+EVROverlayError __thiscall IVROverlay_021_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1409,7 +1398,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlaySortOrder(void *_this, VROve
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1417,7 +1406,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayWidthInMeters(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1425,25 +1414,23 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayWidthInMeters(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
-    push_float_parameter(fMinDistanceInMeters);
-    push_float_parameter(fMaxDistanceInMeters);
+    push_float_parameter(fCurvature);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
-    push_ptr_parameter(pfMinDistanceInMeters);
-    push_ptr_parameter(pfMaxDistanceInMeters);
+    push_ptr_parameter(pfCurvature);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1451,7 +1438,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayTextureColorSpace(void *_thi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1459,7 +1446,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureColorSpace(void *_thi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1467,7 +1454,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayTextureBounds(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1475,7 +1462,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureBounds(void *_this, V
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_020_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
+uint32_t __thiscall IVROverlay_021_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1486,7 +1473,7 @@ uint32_t __thiscall IVROverlay_020_GetOverlayRenderModel(void *_this, VROverlayH
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1495,7 +1482,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderModel(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1503,7 +1490,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformType(void *_this, V
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1512,7 +1499,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformAbsolute(void *_thi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1521,7 +1508,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformAbsolute(void *_thi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1530,7 +1517,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformTrackedDeviceRelati
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1539,7 +1526,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformTrackedDeviceRelati
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1548,7 +1535,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformTrackedDeviceCompon
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1558,7 +1545,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformTrackedDeviceCompon
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1567,7 +1554,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformOverlayRelative(voi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1576,28 +1563,28 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformOverlayRelative(voi
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_021_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_021_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-bool __thiscall IVROverlay_020_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+bool __thiscall IVROverlay_021_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+EVROverlayError __thiscall IVROverlay_021_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1607,7 +1594,7 @@ EVROverlayError __thiscall IVROverlay_020_GetTransformForOverlayCoordinates(void
     return 0;
 }
 
-bool __thiscall IVROverlay_020_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
+bool __thiscall IVROverlay_021_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1616,7 +1603,7 @@ bool __thiscall IVROverlay_020_PollNextOverlayEvent(void *_this, VROverlayHandle
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1624,7 +1611,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayInputMethod(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1632,7 +1619,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayInputMethod(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1640,7 +1627,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayMouseScale(void *_this, VROv
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1648,7 +1635,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayMouseScale(void *_this, VROv
     return 0;
 }
 
-bool __thiscall IVROverlay_020_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+bool __thiscall IVROverlay_021_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1657,44 +1644,14 @@ bool __thiscall IVROverlay_020_ComputeOverlayIntersection(void *_this, VROverlay
     return 0;
 }
 
-bool __thiscall IVROverlay_020_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+bool __thiscall IVROverlay_021_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-VROverlayHandle_t __thiscall IVROverlay_020_GetGamepadFocusOverlay(void *_this)
-{
-    push_ptr_parameter(_this);
-    return 0;
-}
-
-EVROverlayError __thiscall IVROverlay_020_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
-{
-    push_ptr_parameter(_this);
-    push_uint64_parameter(ulNewFocusOverlay);
-    return 0;
-}
-
-EVROverlayError __thiscall IVROverlay_020_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
-{
-    push_ptr_parameter(_this);
-    push_uint32_parameter(eDirection);
-    push_uint64_parameter(ulFrom);
-    push_uint64_parameter(ulTo);
-    return 0;
-}
-
-EVROverlayError __thiscall IVROverlay_020_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
-{
-    push_ptr_parameter(_this);
-    push_uint32_parameter(eDirection);
-    push_uint64_parameter(ulFrom);
-    return 0;
-}
-
-EVROverlayError __thiscall IVROverlay_020_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlay);
@@ -1704,7 +1661,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayDualAnalogTransform(void *_t
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlay);
@@ -1714,7 +1671,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayDualAnalogTransform(void *_t
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1722,14 +1679,14 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayTexture(void *_this, VROverl
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+EVROverlayError __thiscall IVROverlay_021_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1740,7 +1697,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayRaw(void *_this, VROverlayHa
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1748,7 +1705,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayFromFile(void *_this, VROver
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_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_021_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);
@@ -1763,7 +1720,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTexture(void *_this, VROverl
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+EVROverlayError __thiscall IVROverlay_021_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1771,7 +1728,7 @@ EVROverlayError __thiscall IVROverlay_020_ReleaseNativeOverlayHandle(void *_this
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1780,7 +1737,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureSize(void *_this, VRO
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+EVROverlayError __thiscall IVROverlay_021_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchOverlayKey);
@@ -1790,20 +1747,20 @@ EVROverlayError __thiscall IVROverlay_020_CreateDashboardOverlay(void *_this, co
     return 0;
 }
 
-bool __thiscall IVROverlay_020_IsDashboardVisible(void *_this)
+bool __thiscall IVROverlay_021_IsDashboardVisible(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-bool __thiscall IVROverlay_020_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+bool __thiscall IVROverlay_021_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+EVROverlayError __thiscall IVROverlay_021_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1811,7 +1768,7 @@ EVROverlayError __thiscall IVROverlay_020_SetDashboardOverlaySceneProcess(void *
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+EVROverlayError __thiscall IVROverlay_021_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1819,19 +1776,19 @@ EVROverlayError __thiscall IVROverlay_020_GetDashboardOverlaySceneProcess(void *
     return 0;
 }
 
-void __thiscall IVROverlay_020_ShowDashboard(void *_this, const char * pchOverlayToShow)
+void __thiscall IVROverlay_021_ShowDashboard(void *_this, const char * pchOverlayToShow)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchOverlayToShow);
 }
 
-TrackedDeviceIndex_t __thiscall IVROverlay_020_GetPrimaryDashboardDevice(void *_this)
+TrackedDeviceIndex_t __thiscall IVROverlay_021_GetPrimaryDashboardDevice(void *_this)
 {
     push_ptr_parameter(_this);
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+EVROverlayError __thiscall IVROverlay_021_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eInputMode);
@@ -1844,7 +1801,7 @@ EVROverlayError __thiscall IVROverlay_020_ShowKeyboard(void *_this, EGamepadText
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+EVROverlayError __thiscall IVROverlay_021_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1858,7 +1815,7 @@ EVROverlayError __thiscall IVROverlay_020_ShowKeyboardForOverlay(void *_this, VR
     return 0;
 }
 
-uint32_t __thiscall IVROverlay_020_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
+uint32_t __thiscall IVROverlay_021_GetKeyboardText(void *_this, char * pchText, uint32_t cchText)
 {
     push_ptr_parameter(_this);
     push_ptr_parameter(pchText);
@@ -1866,26 +1823,26 @@ uint32_t __thiscall IVROverlay_020_GetKeyboardText(void *_this, char * pchText,
     return 0;
 }
 
-void __thiscall IVROverlay_020_HideKeyboard(void *_this)
+void __thiscall IVROverlay_021_HideKeyboard(void *_this)
 {
     push_ptr_parameter(_this);
 }
 
-void __thiscall IVROverlay_020_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+void __thiscall IVROverlay_021_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
 {
     push_ptr_parameter(_this);
     push_uint32_parameter(eTrackingOrigin);
     push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
 }
 
-void __thiscall IVROverlay_020_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+void __thiscall IVROverlay_021_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
     push_HmdRect2_parameter(avoidRect);
 }
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+EVROverlayError __thiscall IVROverlay_021_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1895,7 +1852,7 @@ EVROverlayError __thiscall IVROverlay_020_SetOverlayIntersectionMask(void *_this
     return 0;
 }
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+EVROverlayError __thiscall IVROverlay_021_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
 {
     push_ptr_parameter(_this);
     push_uint64_parameter(ulOverlayHandle);
@@ -1903,7 +1860,7 @@ EVROverlayError __thiscall IVROverlay_020_GetOverlayFlags(void *_this, VROverlay
     return 0;
 }
 
-VRMessageOverlayResponse __thiscall IVROverlay_020_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text)
+VRMessageOverlayResponse __thiscall IVROverlay_021_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);
@@ -1915,7 +1872,7 @@ VRMessageOverlayResponse __thiscall IVROverlay_020_ShowMessageOverlay(void *_thi
     return 0;
 }
 
-void __thiscall IVROverlay_020_CloseMessageOverlay(void *_this)
+void __thiscall IVROverlay_021_CloseMessageOverlay(void *_this)
 {
     push_ptr_parameter(_this);
 }
@@ -2602,6 +2559,16 @@ bool __thiscall IVRInput_007_IsUsingLegacyInput(void *_this)
     return 0;
 }
 
+EVRInputError __thiscall IVRInput_007_OpenBindingUI(void *_this, const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint64_parameter(ulActionSetHandle);
+    push_uint64_parameter(ulDeviceHandle);
+    push_bool_parameter(bShowOnDesktop);
+    return 0;
+}
+
 EIOBufferError __thiscall IVRIOBuffer_002_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer)
 {
     push_ptr_parameter(_this);
@@ -2701,6 +2668,1306 @@ const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRIn
     return 0;
 }
 
+void __thiscall IVRSystem_020_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnWidth);
+    push_ptr_parameter(pnHeight);
+}
+
+HmdMatrix44_t *__thiscall IVRSystem_020_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fNearZ);
+    push_float_parameter(fFarZ);
+    return 0;
+}
+
+void __thiscall IVRSystem_020_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_ptr_parameter(pfLeft);
+    push_ptr_parameter(pfRight);
+    push_ptr_parameter(pfTop);
+    push_ptr_parameter(pfBottom);
+}
+
+bool __thiscall IVRSystem_020_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eEye);
+    push_float_parameter(fU);
+    push_float_parameter(fV);
+    push_ptr_parameter(pDistortionCoordinates);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_020_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pfSecondsSinceLastVsync);
+    push_ptr_parameter(pulFrameCounter);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_020_GetD3D9AdapterIndex(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+void __thiscall IVRSystem_020_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnAdapterIndex);
+}
+
+void __thiscall IVRSystem_020_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pnDevice);
+    push_uint32_parameter(textureType);
+    push_ptr_parameter(pInstance);
+}
+
+bool __thiscall IVRSystem_020_IsDisplayOnDesktop(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop)
+{
+    push_ptr_parameter(_this);
+    push_bool_parameter(bIsVisibleOnDesktop);
+    return 0;
+}
+
+void __thiscall IVRSystem_020_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_float_parameter(fPredictedSecondsToPhotonsFromNow);
+    push_ptr_parameter(pTrackedDevicePoseArray);
+    push_uint32_parameter(unTrackedDevicePoseArrayCount);
+}
+
+void __thiscall IVRSystem_020_ResetSeatedZeroPose(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackedDeviceClass);
+    push_ptr_parameter(punTrackedDeviceIndexArray);
+    push_uint32_parameter(unTrackedDeviceIndexArrayCount);
+    push_uint32_parameter(unRelativeToTrackedDeviceIndex);
+    return 0;
+}
+
+EDeviceActivityLevel __thiscall IVRSystem_020_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceId);
+    return 0;
+}
+
+void __thiscall IVRSystem_020_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pOutputPose);
+    push_ptr_parameter(pTrackedDevicePose);
+    push_ptr_parameter(pTransform);
+}
+
+TrackedDeviceIndex_t __thiscall IVRSystem_020_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceType);
+    return 0;
+}
+
+ETrackedControllerRole __thiscall IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+ETrackedDeviceClass __thiscall IVRSystem_020_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+float __thiscall IVRSystem_020_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+int32_t __thiscall IVRSystem_020_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint64_t __thiscall IVRSystem_020_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+HmdMatrix34_t *__thiscall IVRSystem_020_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_020_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_uint32_parameter(propType);
+    push_ptr_parameter(pBuffer);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+uint32_t __thiscall IVRSystem_020_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    push_uint32_parameter(prop);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_020_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_ptr_parameter(pEvent);
+    push_uint32_parameter(uncbVREvent);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_020_GetEventTypeNameFromEnum(void *_this, EVREventType eType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eType);
+    return 0;
+}
+
+HiddenAreaMesh_t *__thiscall IVRSystem_020_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(_r);
+    push_uint32_parameter(eEye);
+    push_uint32_parameter(type);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eOrigin);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_ptr_parameter(pControllerState);
+    push_uint32_parameter(unControllerStateSize);
+    push_ptr_parameter(pTrackedDevicePose);
+    return 0;
+}
+
+void __thiscall IVRSystem_020_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unControllerDeviceIndex);
+    push_uint32_parameter(unAxisId);
+    push_uint32_parameter(usDurationMicroSec);
+}
+
+const char * __thiscall IVRSystem_020_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eButtonId);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_020_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eAxisType);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_IsInputAvailable(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_IsSteamVRDrawingControllers(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_ShouldApplicationPause(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVRSystem_020_ShouldApplicationReduceRenderingWork(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRFirmwareError __thiscall IVRSystem_020_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unDeviceIndex);
+    return 0;
+}
+
+void __thiscall IVRSystem_020_AcknowledgeQuit_Exiting(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVRSystem_020_AcknowledgeQuit_UserPrompt(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+uint32_t __thiscall IVRSystem_020_GetAppContainerFilePaths(void *_this, char * pchBuffer, uint32_t unBufferSize)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBuffer);
+    push_uint32_parameter(unBufferSize);
+    return 0;
+}
+
+const char * __thiscall IVRSystem_020_GetRuntimeVersion(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    push_bool_parameter(bTemporary);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchApplicationManifestFullPath);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_IsApplicationInstalled(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationCount(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unApplicationIndex);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchApplication(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchTemplateAppKey);
+    push_ptr_parameter(pchNewAppKey);
+    push_ptr_parameter(pKeys);
+    push_uint32_parameter(unKeys);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchApplicationFromMimeType(void *_this, const char * pchMimeType, const char * pchArgs)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchMimeType);
+    push_ptr_parameter(pchArgs);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchDashboardOverlay(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_CancelApplicationLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unProcessId);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationProcessId(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_006_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(pchPropertyValueBuffer);
+    push_uint32_parameter(unPropertyValueBufferLen);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+uint64_t __thiscall IVRApplications_006_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_uint32_parameter(eProperty);
+    push_ptr_parameter(peError);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_bool_parameter(bAutoLaunch);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_GetApplicationAutoLaunch(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_SetDefaultApplicationForMimeType(void *_this, const char * pchAppKey, const char * pchMimeType)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_ptr_parameter(pchMimeType);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_GetDefaultApplicationForMimeType(void *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchMimeType);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_GetApplicationSupportedMimeTypes(void *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    push_ptr_parameter(pchMimeTypesBuffer);
+    push_uint32_parameter(unMimeTypesBuffer);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationsThatSupportMimeType(void *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchMimeType);
+    push_ptr_parameter(pchAppKeysThatSupportBuffer);
+    push_uint32_parameter(unAppKeysThatSupportBuffer);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetApplicationLaunchArguments(void *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(unHandle);
+    push_ptr_parameter(pchArgs);
+    push_uint32_parameter(unArgs);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKeyBuffer);
+    push_uint32_parameter(unAppKeyBufferLen);
+    return 0;
+}
+
+EVRApplicationTransitionState __thiscall IVRApplications_006_GetTransitionState(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchAppKey);
+    return 0;
+}
+
+const char * __thiscall IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(state);
+    return 0;
+}
+
+bool __thiscall IVRApplications_006_IsQuitUserPromptRequested(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchBinaryPath);
+    push_ptr_parameter(pchArguments);
+    push_ptr_parameter(pchWorkingDirectory);
+    return 0;
+}
+
+uint32_t __thiscall IVRApplications_006_GetCurrentSceneProcessId(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_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_020_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_020_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_020_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_020_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_020_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_020_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(error);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_float_parameter(fMinDistanceInMeters);
+    push_float_parameter(fMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pfMinDistanceInMeters);
+    push_ptr_parameter(pfMaxDistanceInMeters);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_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_020_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_020_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pOverlayTextureBounds);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_020_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchValue);
+    push_uint32_parameter(unBufferSize);
+    push_ptr_parameter(pColor);
+    push_ptr_parameter(pError);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pchRenderModel);
+    push_ptr_parameter(pColor);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+bool __thiscall IVROverlay_020_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_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_020_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_020_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_020_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_020_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_020_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_020_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+VROverlayHandle_t __thiscall IVROverlay_020_GetGamepadFocusOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulNewFocusOverlay);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    push_uint64_parameter(ulTo);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eDirection);
+    push_uint64_parameter(ulFrom);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlay);
+    push_uint32_parameter(eWhich);
+    push_ptr_parameter(pvCenter);
+    push_float_parameter(fRadius);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlay);
+    push_uint32_parameter(eWhich);
+    push_ptr_parameter(pvCenter);
+    push_ptr_parameter(pfRadius);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pvBuffer);
+    push_uint32_parameter(unWidth);
+    push_uint32_parameter(unHeight);
+    push_uint32_parameter(unDepth);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_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_020_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_020_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_020_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_020_IsDashboardVisible(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+bool __thiscall IVROverlay_020_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_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_020_ShowDashboard(void *_this, const char * pchOverlayToShow)
+{
+    push_ptr_parameter(_this);
+    push_ptr_parameter(pchOverlayToShow);
+}
+
+TrackedDeviceIndex_t __thiscall IVROverlay_020_GetPrimaryDashboardDevice(void *_this)
+{
+    push_ptr_parameter(_this);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+EVROverlayError __thiscall IVROverlay_020_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_uint32_parameter(eInputMode);
+    push_uint32_parameter(eLineInputMode);
+    push_ptr_parameter(pchDescription);
+    push_uint32_parameter(unCharMax);
+    push_ptr_parameter(pchExistingText);
+    push_bool_parameter(bUseMinimalMode);
+    push_uint64_parameter(uUserValue);
+    return 0;
+}
+
+uint32_t __thiscall IVROverlay_020_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_020_HideKeyboard(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
+void __thiscall IVROverlay_020_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    push_ptr_parameter(_this);
+    push_uint32_parameter(eTrackingOrigin);
+    push_ptr_parameter(pmatTrackingOriginToKeyboardTransform);
+}
+
+void __thiscall IVROverlay_020_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_HmdRect2_parameter(avoidRect);
+}
+
+EVROverlayError __thiscall IVROverlay_020_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_020_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    push_ptr_parameter(_this);
+    push_uint64_parameter(ulOverlayHandle);
+    push_ptr_parameter(pFlags);
+    return 0;
+}
+
+VRMessageOverlayResponse __thiscall IVROverlay_020_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_020_CloseMessageOverlay(void *_this)
+{
+    push_ptr_parameter(_this);
+}
+
 EVROverlayError __thiscall IVROverlay_019_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
 {
     push_ptr_parameter(_this);
diff --git a/vrclient_x64/tests/capi_thunks_autogen.h b/vrclient_x64/tests/capi_thunks_autogen.h
index 3f85dd1c..ce505418 100644
--- a/vrclient_x64/tests/capi_thunks_autogen.h
+++ b/vrclient_x64/tests/capi_thunks_autogen.h
@@ -11,167 +11,163 @@
 
 #include "capi_thunks.h"
 
-void test_capi_thunks_IVRSystem_020(void);
+void test_capi_thunks_IVRSystem_021(void);
 
-void __thiscall IVRSystem_020_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+void __thiscall IVRSystem_021_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
 
-HmdMatrix44_t *__thiscall IVRSystem_020_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
+HmdMatrix44_t *__thiscall IVRSystem_021_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
 
-void __thiscall IVRSystem_020_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+void __thiscall IVRSystem_021_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
 
-bool __thiscall IVRSystem_020_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
+bool __thiscall IVRSystem_021_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
 
-HmdMatrix34_t *__thiscall IVRSystem_020_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+HmdMatrix34_t *__thiscall IVRSystem_021_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
 
-bool __thiscall IVRSystem_020_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+bool __thiscall IVRSystem_021_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
 
-int32_t __thiscall IVRSystem_020_GetD3D9AdapterIndex(void *_this);
+int32_t __thiscall IVRSystem_021_GetD3D9AdapterIndex(void *_this);
 
-void __thiscall IVRSystem_020_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+void __thiscall IVRSystem_021_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
 
-void __thiscall IVRSystem_020_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance);
+void __thiscall IVRSystem_021_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance);
 
-bool __thiscall IVRSystem_020_IsDisplayOnDesktop(void *_this);
+bool __thiscall IVRSystem_021_IsDisplayOnDesktop(void *_this);
 
-bool __thiscall IVRSystem_020_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+bool __thiscall IVRSystem_021_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
 
-void __thiscall IVRSystem_020_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+void __thiscall IVRSystem_021_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
 
-void __thiscall IVRSystem_020_ResetSeatedZeroPose(void *_this);
+void __thiscall IVRSystem_021_ResetSeatedZeroPose(void *_this);
 
-HmdMatrix34_t *__thiscall IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+HmdMatrix34_t *__thiscall IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
 
-HmdMatrix34_t *__thiscall IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+HmdMatrix34_t *__thiscall IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
 
-uint32_t __thiscall IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+uint32_t __thiscall IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
 
-EDeviceActivityLevel __thiscall IVRSystem_020_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+EDeviceActivityLevel __thiscall IVRSystem_021_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
 
-void __thiscall IVRSystem_020_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+void __thiscall IVRSystem_021_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
 
-TrackedDeviceIndex_t __thiscall IVRSystem_020_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+TrackedDeviceIndex_t __thiscall IVRSystem_021_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
 
-ETrackedControllerRole __thiscall IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+ETrackedControllerRole __thiscall IVRSystem_021_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
 
-ETrackedDeviceClass __thiscall IVRSystem_020_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+ETrackedDeviceClass __thiscall IVRSystem_021_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
 
-bool __thiscall IVRSystem_020_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+bool __thiscall IVRSystem_021_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
 
-bool __thiscall IVRSystem_020_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+bool __thiscall IVRSystem_021_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
 
-float __thiscall IVRSystem_020_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
-
-int32_t __thiscall IVRSystem_020_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+float __thiscall IVRSystem_021_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
 
-uint64_t __thiscall IVRSystem_020_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+int32_t __thiscall IVRSystem_021_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
 
-HmdMatrix34_t *__thiscall IVRSystem_020_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
-
-uint32_t __thiscall IVRSystem_020_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
+uint64_t __thiscall IVRSystem_021_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
 
-uint32_t __thiscall IVRSystem_020_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+HmdMatrix34_t *__thiscall IVRSystem_021_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
 
-const char * __thiscall IVRSystem_020_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+uint32_t __thiscall IVRSystem_021_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
 
-bool __thiscall IVRSystem_020_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+uint32_t __thiscall IVRSystem_021_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
 
-bool __thiscall IVRSystem_020_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+const char * __thiscall IVRSystem_021_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
 
-const char * __thiscall IVRSystem_020_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+bool __thiscall IVRSystem_021_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
 
-HiddenAreaMesh_t *__thiscall IVRSystem_020_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
+bool __thiscall IVRSystem_021_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
 
-bool __thiscall IVRSystem_020_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+const char * __thiscall IVRSystem_021_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
 
-bool __thiscall IVRSystem_020_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
+HiddenAreaMesh_t *__thiscall IVRSystem_021_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
 
-void __thiscall IVRSystem_020_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+bool __thiscall IVRSystem_021_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
 
-const char * __thiscall IVRSystem_020_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+bool __thiscall IVRSystem_021_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
 
-const char * __thiscall IVRSystem_020_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+void __thiscall IVRSystem_021_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
 
-bool __thiscall IVRSystem_020_IsInputAvailable(void *_this);
+const char * __thiscall IVRSystem_021_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
 
-bool __thiscall IVRSystem_020_IsSteamVRDrawingControllers(void *_this);
+const char * __thiscall IVRSystem_021_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
 
-bool __thiscall IVRSystem_020_ShouldApplicationPause(void *_this);
+bool __thiscall IVRSystem_021_IsInputAvailable(void *_this);
 
-bool __thiscall IVRSystem_020_ShouldApplicationReduceRenderingWork(void *_this);
+bool __thiscall IVRSystem_021_IsSteamVRDrawingControllers(void *_this);
 
-EVRFirmwareError __thiscall IVRSystem_020_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+bool __thiscall IVRSystem_021_ShouldApplicationPause(void *_this);
 
-void __thiscall IVRSystem_020_AcknowledgeQuit_Exiting(void *_this);
+bool __thiscall IVRSystem_021_ShouldApplicationReduceRenderingWork(void *_this);
 
-void __thiscall IVRSystem_020_AcknowledgeQuit_UserPrompt(void *_this);
+EVRFirmwareError __thiscall IVRSystem_021_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
 
-uint32_t __thiscall IVRSystem_020_GetAppContainerFilePaths(void *_this, char * pchBuffer, uint32_t unBufferSize);
+void __thiscall IVRSystem_021_AcknowledgeQuit_Exiting(void *_this);
 
-const char * __thiscall IVRSystem_020_GetRuntimeVersion(void *_this);
+uint32_t __thiscall IVRSystem_021_GetAppContainerFilePaths(void *_this, char * pchBuffer, uint32_t unBufferSize);
 
-void test_capi_thunks_IVRApplications_006(void);
+const char * __thiscall IVRSystem_021_GetRuntimeVersion(void *_this);
 
-EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
+void test_capi_thunks_IVRApplications_007(void);
 
-EVRApplicationError __thiscall IVRApplications_006_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
+EVRApplicationError __thiscall IVRApplications_007_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
 
-bool __thiscall IVRApplications_006_IsApplicationInstalled(void *_this, const char * pchAppKey);
+EVRApplicationError __thiscall IVRApplications_007_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
 
-uint32_t __thiscall IVRApplications_006_GetApplicationCount(void *_this);
+bool __thiscall IVRApplications_007_IsApplicationInstalled(void *_this, const char * pchAppKey);
 
-EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+uint32_t __thiscall IVRApplications_007_GetApplicationCount(void *_this);
 
-EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+EVRApplicationError __thiscall IVRApplications_007_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchApplication(void *_this, const char * pchAppKey);
+EVRApplicationError __thiscall IVRApplications_007_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys);
+EVRApplicationError __thiscall IVRApplications_007_LaunchApplication(void *_this, const char * pchAppKey);
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchApplicationFromMimeType(void *_this, const char * pchMimeType, const char * pchArgs);
+EVRApplicationError __thiscall IVRApplications_007_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys);
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
+EVRApplicationError __thiscall IVRApplications_007_LaunchApplicationFromMimeType(void *_this, const char * pchMimeType, const char * pchArgs);
 
-bool __thiscall IVRApplications_006_CancelApplicationLaunch(void *_this, const char * pchAppKey);
+EVRApplicationError __thiscall IVRApplications_007_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
 
-EVRApplicationError __thiscall IVRApplications_006_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
+bool __thiscall IVRApplications_007_CancelApplicationLaunch(void *_this, const char * pchAppKey);
 
-uint32_t __thiscall IVRApplications_006_GetApplicationProcessId(void *_this, const char * pchAppKey);
+EVRApplicationError __thiscall IVRApplications_007_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
 
-const char * __thiscall IVRApplications_006_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
+uint32_t __thiscall IVRApplications_007_GetApplicationProcessId(void *_this, const char * pchAppKey);
 
-uint32_t __thiscall IVRApplications_006_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+const char * __thiscall IVRApplications_007_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
 
-bool __thiscall IVRApplications_006_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+uint32_t __thiscall IVRApplications_007_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
 
-uint64_t __thiscall IVRApplications_006_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+bool __thiscall IVRApplications_007_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
 
-EVRApplicationError __thiscall IVRApplications_006_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
+uint64_t __thiscall IVRApplications_007_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
 
-bool __thiscall IVRApplications_006_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
+EVRApplicationError __thiscall IVRApplications_007_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
 
-EVRApplicationError __thiscall IVRApplications_006_SetDefaultApplicationForMimeType(void *_this, const char * pchAppKey, const char * pchMimeType);
+bool __thiscall IVRApplications_007_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
 
-bool __thiscall IVRApplications_006_GetDefaultApplicationForMimeType(void *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+EVRApplicationError __thiscall IVRApplications_007_SetDefaultApplicationForMimeType(void *_this, const char * pchAppKey, const char * pchMimeType);
 
-bool __thiscall IVRApplications_006_GetApplicationSupportedMimeTypes(void *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+bool __thiscall IVRApplications_007_GetDefaultApplicationForMimeType(void *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
 
-uint32_t __thiscall IVRApplications_006_GetApplicationsThatSupportMimeType(void *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+bool __thiscall IVRApplications_007_GetApplicationSupportedMimeTypes(void *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
 
-uint32_t __thiscall IVRApplications_006_GetApplicationLaunchArguments(void *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs);
+uint32_t __thiscall IVRApplications_007_GetApplicationsThatSupportMimeType(void *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
 
-EVRApplicationError __thiscall IVRApplications_006_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+uint32_t __thiscall IVRApplications_007_GetApplicationLaunchArguments(void *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs);
 
-EVRApplicationTransitionState __thiscall IVRApplications_006_GetTransitionState(void *_this);
+EVRApplicationError __thiscall IVRApplications_007_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
 
-EVRApplicationError __thiscall IVRApplications_006_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
+EVRSceneApplicationState __thiscall IVRApplications_007_GetSceneApplicationState(void *_this);
 
-const char * __thiscall IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state);
+EVRApplicationError __thiscall IVRApplications_007_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
 
-bool __thiscall IVRApplications_006_IsQuitUserPromptRequested(void *_this);
+const char * __thiscall IVRApplications_007_GetSceneApplicationStateNameFromEnum(void *_this, EVRSceneApplicationState state);
 
-EVRApplicationError __thiscall IVRApplications_006_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory);
+EVRApplicationError __thiscall IVRApplications_007_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory);
 
-uint32_t __thiscall IVRApplications_006_GetCurrentSceneProcessId(void *_this);
+uint32_t __thiscall IVRApplications_007_GetCurrentSceneProcessId(void *_this);
 
 void test_capi_thunks_IVRSettings_002(void);
 
@@ -359,167 +355,159 @@ EVRNotificationError __thiscall IVRNotifications_002_CreateNotification(void *_t
 
 EVRNotificationError __thiscall IVRNotifications_002_RemoveNotification(void *_this, VRNotificationId notificationId);
 
-void test_capi_thunks_IVROverlay_020(void);
+void test_capi_thunks_IVROverlay_021(void);
 
-EVROverlayError __thiscall IVROverlay_020_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+EVROverlayError __thiscall IVROverlay_021_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_020_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+EVROverlayError __thiscall IVROverlay_021_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_020_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_021_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-uint32_t __thiscall IVROverlay_020_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+uint32_t __thiscall IVROverlay_021_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
 
-uint32_t __thiscall IVROverlay_020_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+uint32_t __thiscall IVROverlay_021_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
 
-const char * __thiscall IVROverlay_020_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+const char * __thiscall IVROverlay_021_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
 
-uint32_t __thiscall IVROverlay_020_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+uint32_t __thiscall IVROverlay_021_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+EVROverlayError __thiscall IVROverlay_021_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+EVROverlayError __thiscall IVROverlay_021_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayCurvature(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
 
-uint32_t __thiscall IVROverlay_020_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError);
+uint32_t __thiscall IVROverlay_021_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
 
-EVROverlayError __thiscall IVROverlay_020_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_021_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_020_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_021_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-bool __thiscall IVROverlay_020_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+bool __thiscall IVROverlay_021_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_020_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+EVROverlayError __thiscall IVROverlay_021_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
 
-bool __thiscall IVROverlay_020_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+bool __thiscall IVROverlay_021_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
 
-bool __thiscall IVROverlay_020_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+bool __thiscall IVROverlay_021_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
 
-bool __thiscall IVROverlay_020_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+bool __thiscall IVROverlay_021_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-VROverlayHandle_t __thiscall IVROverlay_020_GetGamepadFocusOverlay(void *_this);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius);
 
-EVROverlayError __thiscall IVROverlay_020_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
 
-EVROverlayError __thiscall IVROverlay_020_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+EVROverlayError __thiscall IVROverlay_021_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
-
-EVROverlayError __thiscall IVROverlay_020_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+EVROverlayError __thiscall IVROverlay_021_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_020_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+EVROverlayError __thiscall IVROverlay_021_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
 
-EVROverlayError __thiscall IVROverlay_020_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_021_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
 
-EVROverlayError __thiscall IVROverlay_020_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+bool __thiscall IVROverlay_021_IsDashboardVisible(void *_this);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+bool __thiscall IVROverlay_021_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
 
-EVROverlayError __thiscall IVROverlay_020_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
-
-bool __thiscall IVROverlay_020_IsDashboardVisible(void *_this);
-
-bool __thiscall IVROverlay_020_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
-
-EVROverlayError __thiscall IVROverlay_020_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+EVROverlayError __thiscall IVROverlay_021_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
 
-EVROverlayError __thiscall IVROverlay_020_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+EVROverlayError __thiscall IVROverlay_021_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
 
-void __thiscall IVROverlay_020_ShowDashboard(void *_this, const char * pchOverlayToShow);
+void __thiscall IVROverlay_021_ShowDashboard(void *_this, const char * pchOverlayToShow);
 
-TrackedDeviceIndex_t __thiscall IVROverlay_020_GetPrimaryDashboardDevice(void *_this);
+TrackedDeviceIndex_t __thiscall IVROverlay_021_GetPrimaryDashboardDevice(void *_this);
 
-EVROverlayError __thiscall IVROverlay_020_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+EVROverlayError __thiscall IVROverlay_021_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
 
-EVROverlayError __thiscall IVROverlay_020_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+EVROverlayError __thiscall IVROverlay_021_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
 
-uint32_t __thiscall IVROverlay_020_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+uint32_t __thiscall IVROverlay_021_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
 
-void __thiscall IVROverlay_020_HideKeyboard(void *_this);
+void __thiscall IVROverlay_021_HideKeyboard(void *_this);
 
-void __thiscall IVROverlay_020_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+void __thiscall IVROverlay_021_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
 
-void __thiscall IVROverlay_020_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+void __thiscall IVROverlay_021_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
 
-EVROverlayError __thiscall IVROverlay_020_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+EVROverlayError __thiscall IVROverlay_021_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
 
-EVROverlayError __thiscall IVROverlay_020_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+EVROverlayError __thiscall IVROverlay_021_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
 
-VRMessageOverlayResponse __thiscall IVROverlay_020_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+VRMessageOverlayResponse __thiscall IVROverlay_021_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
 
-void __thiscall IVROverlay_020_CloseMessageOverlay(void *_this);
+void __thiscall IVROverlay_021_CloseMessageOverlay(void *_this);
 
 void test_capi_thunks_IVRRenderModels_006(void);
 
@@ -687,6 +675,8 @@ EVRInputError __thiscall IVRInput_007_ShowBindingsForActionSet(void *_this, VRAc
 
 bool __thiscall IVRInput_007_IsUsingLegacyInput(void *_this);
 
+EVRInputError __thiscall IVRInput_007_OpenBindingUI(void *_this, const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop);
+
 void test_capi_thunks_IVRIOBuffer_002(void);
 
 EIOBufferError __thiscall IVRIOBuffer_002_Open(void *_this, const char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
@@ -717,6 +707,330 @@ const char * __thiscall IVRClientCore_003_GetEnglishStringForHmdError(void *_thi
 
 const char * __thiscall IVRClientCore_003_GetIDForVRInitError(void *_this, EVRInitError eError);
 
+void test_capi_thunks_IVRSystem_020(void);
+
+void __thiscall IVRSystem_020_GetRecommendedRenderTargetSize(void *_this, uint32_t * pnWidth, uint32_t * pnHeight);
+
+HmdMatrix44_t *__thiscall IVRSystem_020_GetProjectionMatrix(void *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ);
+
+void __thiscall IVRSystem_020_GetProjectionRaw(void *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+
+bool __thiscall IVRSystem_020_ComputeDistortion(void *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates);
+
+HmdMatrix34_t *__thiscall IVRSystem_020_GetEyeToHeadTransform(void *_this, HmdMatrix34_t *_r, EVREye eEye);
+
+bool __thiscall IVRSystem_020_GetTimeSinceLastVsync(void *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+
+int32_t __thiscall IVRSystem_020_GetD3D9AdapterIndex(void *_this);
+
+void __thiscall IVRSystem_020_GetDXGIOutputInfo(void *_this, int32_t * pnAdapterIndex);
+
+void __thiscall IVRSystem_020_GetOutputDevice(void *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance);
+
+bool __thiscall IVRSystem_020_IsDisplayOnDesktop(void *_this);
+
+bool __thiscall IVRSystem_020_SetDisplayVisibility(void *_this, bool bIsVisibleOnDesktop);
+
+void __thiscall IVRSystem_020_GetDeviceToAbsoluteTrackingPose(void *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+
+void __thiscall IVRSystem_020_ResetSeatedZeroPose(void *_this);
+
+HmdMatrix34_t *__thiscall IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+HmdMatrix34_t *__thiscall IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *_this, HmdMatrix34_t *_r);
+
+uint32_t __thiscall IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(void *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+
+EDeviceActivityLevel __thiscall IVRSystem_020_GetTrackedDeviceActivityLevel(void *_this, TrackedDeviceIndex_t unDeviceId);
+
+void __thiscall IVRSystem_020_ApplyTransform(void *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform);
+
+TrackedDeviceIndex_t __thiscall IVRSystem_020_GetTrackedDeviceIndexForControllerRole(void *_this, ETrackedControllerRole unDeviceType);
+
+ETrackedControllerRole __thiscall IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+ETrackedDeviceClass __thiscall IVRSystem_020_GetTrackedDeviceClass(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_020_IsTrackedDeviceConnected(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+bool __thiscall IVRSystem_020_GetBoolTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+float __thiscall IVRSystem_020_GetFloatTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+int32_t __thiscall IVRSystem_020_GetInt32TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint64_t __thiscall IVRSystem_020_GetUint64TrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+HmdMatrix34_t *__thiscall IVRSystem_020_GetMatrix34TrackedDeviceProperty(void *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_020_GetArrayTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+uint32_t __thiscall IVRSystem_020_GetStringTrackedDeviceProperty(void *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+
+const char * __thiscall IVRSystem_020_GetPropErrorNameFromEnum(void *_this, ETrackedPropertyError error);
+
+bool __thiscall IVRSystem_020_PollNextEvent(void *_this, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+bool __thiscall IVRSystem_020_PollNextEventWithPose(void *_this, ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+
+const char * __thiscall IVRSystem_020_GetEventTypeNameFromEnum(void *_this, EVREventType eType);
+
+HiddenAreaMesh_t *__thiscall IVRSystem_020_GetHiddenAreaMesh(void *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type);
+
+bool __thiscall IVRSystem_020_GetControllerState(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+
+bool __thiscall IVRSystem_020_GetControllerStateWithPose(void *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose);
+
+void __thiscall IVRSystem_020_TriggerHapticPulse(void *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+
+const char * __thiscall IVRSystem_020_GetButtonIdNameFromEnum(void *_this, EVRButtonId eButtonId);
+
+const char * __thiscall IVRSystem_020_GetControllerAxisTypeNameFromEnum(void *_this, EVRControllerAxisType eAxisType);
+
+bool __thiscall IVRSystem_020_IsInputAvailable(void *_this);
+
+bool __thiscall IVRSystem_020_IsSteamVRDrawingControllers(void *_this);
+
+bool __thiscall IVRSystem_020_ShouldApplicationPause(void *_this);
+
+bool __thiscall IVRSystem_020_ShouldApplicationReduceRenderingWork(void *_this);
+
+EVRFirmwareError __thiscall IVRSystem_020_PerformFirmwareUpdate(void *_this, TrackedDeviceIndex_t unDeviceIndex);
+
+void __thiscall IVRSystem_020_AcknowledgeQuit_Exiting(void *_this);
+
+void __thiscall IVRSystem_020_AcknowledgeQuit_UserPrompt(void *_this);
+
+uint32_t __thiscall IVRSystem_020_GetAppContainerFilePaths(void *_this, char * pchBuffer, uint32_t unBufferSize);
+
+const char * __thiscall IVRSystem_020_GetRuntimeVersion(void *_this);
+
+void test_capi_thunks_IVRApplications_006(void);
+
+EVRApplicationError __thiscall IVRApplications_006_AddApplicationManifest(void *_this, const char * pchApplicationManifestFullPath, bool bTemporary);
+
+EVRApplicationError __thiscall IVRApplications_006_RemoveApplicationManifest(void *_this, const char * pchApplicationManifestFullPath);
+
+bool __thiscall IVRApplications_006_IsApplicationInstalled(void *_this, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationCount(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByIndex(void *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_006_GetApplicationKeyByProcessId(void *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchApplication(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchTemplateApplication(void *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchApplicationFromMimeType(void *_this, const char * pchMimeType, const char * pchArgs);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchDashboardOverlay(void *_this, const char * pchAppKey);
+
+bool __thiscall IVRApplications_006_CancelApplicationLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_006_IdentifyApplication(void *_this, uint32_t unProcessId, const char * pchAppKey);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationProcessId(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_006_GetApplicationsErrorNameFromEnum(void *_this, EVRApplicationError error);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationPropertyString(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+
+bool __thiscall IVRApplications_006_GetApplicationPropertyBool(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+uint64_t __thiscall IVRApplications_006_GetApplicationPropertyUint64(void *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+
+EVRApplicationError __thiscall IVRApplications_006_SetApplicationAutoLaunch(void *_this, const char * pchAppKey, bool bAutoLaunch);
+
+bool __thiscall IVRApplications_006_GetApplicationAutoLaunch(void *_this, const char * pchAppKey);
+
+EVRApplicationError __thiscall IVRApplications_006_SetDefaultApplicationForMimeType(void *_this, const char * pchAppKey, const char * pchMimeType);
+
+bool __thiscall IVRApplications_006_GetDefaultApplicationForMimeType(void *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+bool __thiscall IVRApplications_006_GetApplicationSupportedMimeTypes(void *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationsThatSupportMimeType(void *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+
+uint32_t __thiscall IVRApplications_006_GetApplicationLaunchArguments(void *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs);
+
+EVRApplicationError __thiscall IVRApplications_006_GetStartingApplication(void *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+
+EVRApplicationTransitionState __thiscall IVRApplications_006_GetTransitionState(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_006_PerformApplicationPrelaunchCheck(void *_this, const char * pchAppKey);
+
+const char * __thiscall IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(void *_this, EVRApplicationTransitionState state);
+
+bool __thiscall IVRApplications_006_IsQuitUserPromptRequested(void *_this);
+
+EVRApplicationError __thiscall IVRApplications_006_LaunchInternalProcess(void *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory);
+
+uint32_t __thiscall IVRApplications_006_GetCurrentSceneProcessId(void *_this);
+
+void test_capi_thunks_IVROverlay_020(void);
+
+EVROverlayError __thiscall IVROverlay_020_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_020_CreateOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_020_DestroyOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+uint32_t __thiscall IVROverlay_020_GetOverlayKey(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+uint32_t __thiscall IVROverlay_020_GetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayName(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayImageData(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+
+const char * __thiscall IVROverlay_020_GetOverlayErrorNameFromEnum(void *_this, EVROverlayError error);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+
+uint32_t __thiscall IVROverlay_020_GetOverlayRenderingPid(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayFlag(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayColor(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayAlpha(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTexelAspect(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlaySortOrder(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayWidthInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters(void *_this, VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureColorSpace(void *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureBounds(void *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds);
+
+uint32_t __thiscall IVROverlay_020_GetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayRenderModel(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformType(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformAbsolute(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformTrackedDeviceRelative(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformTrackedDeviceComponent(void *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayTransformOverlayRelative(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+
+EVROverlayError __thiscall IVROverlay_020_ShowOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_020_HideOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+bool __thiscall IVROverlay_020_IsOverlayVisible(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_020_GetTransformForOverlayCoordinates(void *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform);
+
+bool __thiscall IVROverlay_020_PollNextOverlayEvent(void *_this, VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayInputMethod(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayMouseScale(void *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale);
+
+bool __thiscall IVROverlay_020_ComputeOverlayIntersection(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults);
+
+bool __thiscall IVROverlay_020_IsHoverTargetOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+VROverlayHandle_t __thiscall IVROverlay_020_GetGamepadFocusOverlay(void *_this);
+
+EVROverlayError __thiscall IVROverlay_020_SetGamepadFocusOverlay(void *_this, VROverlayHandle_t ulNewFocusOverlay);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo);
+
+EVROverlayError __thiscall IVROverlay_020_MoveGamepadFocusToNeighbor(void *_this, EOverlayDirection eDirection, VROverlayHandle_t ulFrom);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayDualAnalogTransform(void *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture);
+
+EVROverlayError __thiscall IVROverlay_020_ClearOverlayTexture(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayRaw(void *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayFromFile(void *_this, VROverlayHandle_t ulOverlayHandle, const char * pchFilePath);
+
+EVROverlayError __thiscall IVROverlay_020_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_020_ReleaseNativeOverlayHandle(void *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayTextureSize(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+
+EVROverlayError __thiscall IVROverlay_020_CreateDashboardOverlay(void *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+
+bool __thiscall IVROverlay_020_IsDashboardVisible(void *_this);
+
+bool __thiscall IVROverlay_020_IsActiveDashboardOverlay(void *_this, VROverlayHandle_t ulOverlayHandle);
+
+EVROverlayError __thiscall IVROverlay_020_SetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+
+EVROverlayError __thiscall IVROverlay_020_GetDashboardOverlaySceneProcess(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+
+void __thiscall IVROverlay_020_ShowDashboard(void *_this, const char * pchOverlayToShow);
+
+TrackedDeviceIndex_t __thiscall IVROverlay_020_GetPrimaryDashboardDevice(void *_this);
+
+EVROverlayError __thiscall IVROverlay_020_ShowKeyboard(void *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+EVROverlayError __thiscall IVROverlay_020_ShowKeyboardForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue);
+
+uint32_t __thiscall IVROverlay_020_GetKeyboardText(void *_this, char * pchText, uint32_t cchText);
+
+void __thiscall IVROverlay_020_HideKeyboard(void *_this);
+
+void __thiscall IVROverlay_020_SetKeyboardTransformAbsolute(void *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+
+void __thiscall IVROverlay_020_SetKeyboardPositionForOverlay(void *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect);
+
+EVROverlayError __thiscall IVROverlay_020_SetOverlayIntersectionMask(void *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+
+EVROverlayError __thiscall IVROverlay_020_GetOverlayFlags(void *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+
+VRMessageOverlayResponse __thiscall IVROverlay_020_ShowMessageOverlay(void *_this, const char * pchText, const char * pchCaption, const char * pchButton0Text, const char * pchButton1Text, const char * pchButton2Text, const char * pchButton3Text);
+
+void __thiscall IVROverlay_020_CloseMessageOverlay(void *_this);
+
 void test_capi_thunks_IVROverlay_019(void);
 
 EVROverlayError __thiscall IVROverlay_019_FindOverlay(void *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
diff --git a/vrclient_x64/tests/capi_thunks_tests_autogen.c b/vrclient_x64/tests/capi_thunks_tests_autogen.c
index fe9864cb..440452ab 100644
--- a/vrclient_x64/tests/capi_thunks_tests_autogen.c
+++ b/vrclient_x64/tests/capi_thunks_tests_autogen.c
@@ -1,722 +1,708 @@
 /* This file is auto-generated, do not edit. */
 #include "capi_thunks_autogen.h"
 
-void test_capi_thunks_IVRSystem_020(void)
+void test_capi_thunks_IVRSystem_021(void)
 {
     struct thunk *t = alloc_thunks(1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetRecommendedRenderTargetSize((void *)1, (void *)2);
-    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", (void *)1);
-    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", (void *)2);
+    capi_IVRSystem_021_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_021_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_021_GetRecommendedRenderTargetSize", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetProjectionMatrix, 4, TRUE, TRUE);
-    HmdMatrix44_t *(__stdcall *capi_IVRSystem_020_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetProjectionMatrix, 4, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_021_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
-    check_ptr_parameter("IVRSystem_020_GetProjectionMatrix", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetProjectionMatrix", data_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetProjectionMatrix", 1);
-    check_float_parameter("IVRSystem_020_GetProjectionMatrix", 2.0f);
-    check_float_parameter("IVRSystem_020_GetProjectionMatrix", 3.0f);
+    capi_IVRSystem_021_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_021_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_021_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_021_GetProjectionMatrix", 3.0f);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetProjectionRaw, 5, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
-    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetProjectionRaw", 1);
-    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)2);
-    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)3);
-    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)4);
-    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)5);
+    capi_IVRSystem_021_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_021_GetProjectionRaw", (void *)5);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_ComputeDistortion, 4, TRUE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_ComputeDistortion, 4, TRUE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
-    check_ptr_parameter("IVRSystem_020_ComputeDistortion", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_ComputeDistortion", 1);
-    check_float_parameter("IVRSystem_020_ComputeDistortion", 2.0f);
-    check_float_parameter("IVRSystem_020_ComputeDistortion", 3.0f);
-    check_ptr_parameter("IVRSystem_020_ComputeDistortion", (void *)4);
+    capi_IVRSystem_021_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSystem_021_ComputeDistortion", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_021_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_021_ComputeDistortion", 3.0f);
+    check_ptr_parameter("IVRSystem_021_ComputeDistortion", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetEyeToHeadTransform, 2, FALSE, FALSE);
-    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_021_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetEyeToHeadTransform(data_ptr_value, 1);
-    check_ptr_parameter("IVRSystem_020_GetEyeToHeadTransform", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetEyeToHeadTransform", data_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetEyeToHeadTransform", 1);
+    capi_IVRSystem_021_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_021_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetEyeToHeadTransform", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetTimeSinceLastVsync, 2, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetTimeSinceLastVsync((void *)1, (void *)2);
-    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", (void *)1);
-    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", (void *)2);
+    capi_IVRSystem_021_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_021_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_021_GetTimeSinceLastVsync", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetD3D9AdapterIndex, 0, FALSE, FALSE);
-    int32_t (__stdcall *capi_IVRSystem_020_GetD3D9AdapterIndex)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_021_GetD3D9AdapterIndex)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetD3D9AdapterIndex();
-    check_ptr_parameter("IVRSystem_020_GetD3D9AdapterIndex", this_ptr_value);
+    capi_IVRSystem_021_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_021_GetD3D9AdapterIndex", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetDXGIOutputInfo, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetDXGIOutputInfo((void *)1);
-    check_ptr_parameter("IVRSystem_020_GetDXGIOutputInfo", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetDXGIOutputInfo", (void *)1);
+    capi_IVRSystem_021_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_021_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetDXGIOutputInfo", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetOutputDevice, 3, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetOutputDevice, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetOutputDevice((void *)1, 2, (void *)3);
-    check_ptr_parameter("IVRSystem_020_GetOutputDevice", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetOutputDevice", (void *)1);
-    check_uint32_parameter("IVRSystem_020_GetOutputDevice", 2);
-    check_ptr_parameter("IVRSystem_020_GetOutputDevice", (void *)3);
+    capi_IVRSystem_021_GetOutputDevice((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_021_GetOutputDevice", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetOutputDevice", (void *)1);
+    check_uint32_parameter("IVRSystem_021_GetOutputDevice", 2);
+    check_ptr_parameter("IVRSystem_021_GetOutputDevice", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_IsDisplayOnDesktop, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_IsDisplayOnDesktop)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_IsDisplayOnDesktop)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_IsDisplayOnDesktop();
-    check_ptr_parameter("IVRSystem_020_IsDisplayOnDesktop", this_ptr_value);
+    capi_IVRSystem_021_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_021_IsDisplayOnDesktop", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_SetDisplayVisibility, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_SetDisplayVisibility(1);
-    check_ptr_parameter("IVRSystem_020_SetDisplayVisibility", this_ptr_value);
-    check_bool_parameter("IVRSystem_020_SetDisplayVisibility", 1);
+    capi_IVRSystem_021_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_021_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_021_SetDisplayVisibility", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
-    check_ptr_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 1);
-    check_float_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 2.0f);
-    check_ptr_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", (void *)3);
-    check_uint32_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 4);
+    capi_IVRSystem_021_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_021_GetDeviceToAbsoluteTrackingPose", 4);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_ResetSeatedZeroPose, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_ResetSeatedZeroPose)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_ResetSeatedZeroPose)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_ResetSeatedZeroPose();
-    check_ptr_parameter("IVRSystem_020_ResetSeatedZeroPose", this_ptr_value);
+    capi_IVRSystem_021_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_021_ResetSeatedZeroPose", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
-    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+    capi_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
-    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+    capi_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
-    check_ptr_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 1);
-    check_ptr_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
-    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 3);
-    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 4);
+    capi_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass", 4);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
-    EDeviceActivityLevel (__stdcall *capi_IVRSystem_020_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_021_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetTrackedDeviceActivityLevel(1);
-    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceActivityLevel", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceActivityLevel", 1);
+    capi_IVRSystem_021_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_021_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetTrackedDeviceActivityLevel", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_ApplyTransform, 3, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_ApplyTransform((void *)1, (void *)2, (void *)3);
-    check_ptr_parameter("IVRSystem_020_ApplyTransform", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)1);
-    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)2);
-    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)3);
+    capi_IVRSystem_021_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_021_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_021_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_021_ApplyTransform", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
-    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_020_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_021_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetTrackedDeviceIndexForControllerRole(1);
-    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceIndexForControllerRole", 1);
+    capi_IVRSystem_021_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_021_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetTrackedDeviceIndexForControllerRole", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
-    ETrackedControllerRole (__stdcall *capi_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(1);
-    check_ptr_parameter("IVRSystem_020_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetControllerRoleForTrackedDeviceIndex", 1);
+    capi_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_021_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetControllerRoleForTrackedDeviceIndex", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceClass, 1, FALSE, FALSE);
-    ETrackedDeviceClass (__stdcall *capi_IVRSystem_020_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_021_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetTrackedDeviceClass(1);
-    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceClass", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceClass", 1);
+    capi_IVRSystem_021_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_021_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetTrackedDeviceClass", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_IsTrackedDeviceConnected, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_IsTrackedDeviceConnected(1);
-    check_ptr_parameter("IVRSystem_020_IsTrackedDeviceConnected", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_IsTrackedDeviceConnected", 1);
+    capi_IVRSystem_021_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_021_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_IsTrackedDeviceConnected", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
-    check_ptr_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", 1);
-    check_uint32_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", 2);
-    check_ptr_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", (void *)3);
+    capi_IVRSystem_021_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_021_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_021_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_021_GetBoolTrackedDeviceProperty", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
-    float (__stdcall *capi_IVRSystem_020_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_021_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
-    check_ptr_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", 1);
-    check_uint32_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", 2);
-    check_ptr_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", (void *)3);
+    capi_IVRSystem_021_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_021_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_021_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_021_GetFloatTrackedDeviceProperty", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
-    int32_t (__stdcall *capi_IVRSystem_020_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_021_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
-    check_ptr_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", 1);
-    check_uint32_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", 2);
-    check_ptr_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", (void *)3);
+    capi_IVRSystem_021_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_021_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_021_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_021_GetInt32TrackedDeviceProperty", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
-    uint64_t (__stdcall *capi_IVRSystem_020_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_021_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
-    check_ptr_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", 1);
-    check_uint32_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", 2);
-    check_ptr_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", (void *)3);
+    capi_IVRSystem_021_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_021_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_021_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_021_GetUint64TrackedDeviceProperty", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
-    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_021_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
-    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", data_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", 1);
-    check_uint32_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", 2);
-    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", (void *)3);
+    capi_IVRSystem_021_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_021_GetMatrix34TrackedDeviceProperty", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRSystem_020_GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_021_GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetArrayTrackedDeviceProperty(1, 2, 3, (void *)4, 5, (void *)6);
-    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 1);
-    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 2);
-    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 3);
-    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", (void *)4);
-    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 5);
-    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", (void *)6);
+    capi_IVRSystem_021_GetArrayTrackedDeviceProperty(1, 2, 3, (void *)4, 5, (void *)6);
+    check_ptr_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", 2);
+    check_uint32_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", 3);
+    check_ptr_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", (void *)4);
+    check_uint32_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", 5);
+    check_ptr_parameter("IVRSystem_021_GetArrayTrackedDeviceProperty", (void *)6);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRSystem_020_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_021_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
-    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 1);
-    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 2);
-    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", (void *)3);
-    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 4);
-    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", (void *)5);
+    capi_IVRSystem_021_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_021_GetStringTrackedDeviceProperty", (void *)5);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
-    const char * (__stdcall *capi_IVRSystem_020_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_021_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetPropErrorNameFromEnum(1);
-    check_ptr_parameter("IVRSystem_020_GetPropErrorNameFromEnum", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetPropErrorNameFromEnum", 1);
+    capi_IVRSystem_021_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_021_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetPropErrorNameFromEnum", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_PollNextEvent, 2, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_PollNextEvent((void *)1, 2);
-    check_ptr_parameter("IVRSystem_020_PollNextEvent", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_PollNextEvent", (void *)1);
-    check_uint32_parameter("IVRSystem_020_PollNextEvent", 2);
+    capi_IVRSystem_021_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_021_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_021_PollNextEvent", 2);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_PollNextEventWithPose, 4, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
-    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_PollNextEventWithPose", 1);
-    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", (void *)2);
-    check_uint32_parameter("IVRSystem_020_PollNextEventWithPose", 3);
-    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", (void *)4);
+    capi_IVRSystem_021_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_021_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_021_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_021_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_021_PollNextEventWithPose", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
-    const char * (__stdcall *capi_IVRSystem_020_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_021_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetEventTypeNameFromEnum(1);
-    check_ptr_parameter("IVRSystem_020_GetEventTypeNameFromEnum", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetEventTypeNameFromEnum", 1);
+    capi_IVRSystem_021_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_021_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetEventTypeNameFromEnum", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetHiddenAreaMesh, 3, FALSE, FALSE);
-    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_020_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetHiddenAreaMesh, 3, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_021_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetHiddenAreaMesh(data_ptr_value, 1, 2);
-    check_ptr_parameter("IVRSystem_020_GetHiddenAreaMesh", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetHiddenAreaMesh", data_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetHiddenAreaMesh", 1);
-    check_uint32_parameter("IVRSystem_020_GetHiddenAreaMesh", 2);
+    capi_IVRSystem_021_GetHiddenAreaMesh(data_ptr_value, 1, 2);
+    check_ptr_parameter("IVRSystem_021_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetHiddenAreaMesh", 1);
+    check_uint32_parameter("IVRSystem_021_GetHiddenAreaMesh", 2);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerState, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetControllerState, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetControllerState(1, (void *)2, 3);
-    check_ptr_parameter("IVRSystem_020_GetControllerState", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetControllerState", 1);
-    check_ptr_parameter("IVRSystem_020_GetControllerState", (void *)2);
-    check_uint32_parameter("IVRSystem_020_GetControllerState", 3);
+    capi_IVRSystem_021_GetControllerState(1, (void *)2, 3);
+    check_ptr_parameter("IVRSystem_021_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_021_GetControllerState", (void *)2);
+    check_uint32_parameter("IVRSystem_021_GetControllerState", 3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerStateWithPose, 5, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetControllerStateWithPose, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
-    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 1);
-    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 2);
-    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", (void *)3);
-    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 4);
-    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", (void *)5);
+    capi_IVRSystem_021_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_021_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_021_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_021_GetControllerStateWithPose", (void *)3);
+    check_uint32_parameter("IVRSystem_021_GetControllerStateWithPose", 4);
+    check_ptr_parameter("IVRSystem_021_GetControllerStateWithPose", (void *)5);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_TriggerHapticPulse, 3, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_TriggerHapticPulse(1, 2, 3);
-    check_ptr_parameter("IVRSystem_020_TriggerHapticPulse", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 1);
-    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 2);
-    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 3);
+    capi_IVRSystem_021_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_021_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_021_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_021_TriggerHapticPulse", 3);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
-    const char * (__stdcall *capi_IVRSystem_020_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_021_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetButtonIdNameFromEnum(1);
-    check_ptr_parameter("IVRSystem_020_GetButtonIdNameFromEnum", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetButtonIdNameFromEnum", 1);
+    capi_IVRSystem_021_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_021_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetButtonIdNameFromEnum", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
-    const char * (__stdcall *capi_IVRSystem_020_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_021_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetControllerAxisTypeNameFromEnum(1);
-    check_ptr_parameter("IVRSystem_020_GetControllerAxisTypeNameFromEnum", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_GetControllerAxisTypeNameFromEnum", 1);
+    capi_IVRSystem_021_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_021_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_GetControllerAxisTypeNameFromEnum", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_IsInputAvailable, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_IsInputAvailable)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_IsInputAvailable, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_IsInputAvailable)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_IsInputAvailable();
-    check_ptr_parameter("IVRSystem_020_IsInputAvailable", this_ptr_value);
+    capi_IVRSystem_021_IsInputAvailable();
+    check_ptr_parameter("IVRSystem_021_IsInputAvailable", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_IsSteamVRDrawingControllers)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_IsSteamVRDrawingControllers)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_IsSteamVRDrawingControllers();
-    check_ptr_parameter("IVRSystem_020_IsSteamVRDrawingControllers", this_ptr_value);
+    capi_IVRSystem_021_IsSteamVRDrawingControllers();
+    check_ptr_parameter("IVRSystem_021_IsSteamVRDrawingControllers", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_ShouldApplicationPause, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_ShouldApplicationPause)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_ShouldApplicationPause, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_ShouldApplicationPause)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_ShouldApplicationPause();
-    check_ptr_parameter("IVRSystem_020_ShouldApplicationPause", this_ptr_value);
+    capi_IVRSystem_021_ShouldApplicationPause();
+    check_ptr_parameter("IVRSystem_021_ShouldApplicationPause", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRSystem_020_ShouldApplicationReduceRenderingWork)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_021_ShouldApplicationReduceRenderingWork)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_ShouldApplicationReduceRenderingWork();
-    check_ptr_parameter("IVRSystem_020_ShouldApplicationReduceRenderingWork", this_ptr_value);
+    capi_IVRSystem_021_ShouldApplicationReduceRenderingWork();
+    check_ptr_parameter("IVRSystem_021_ShouldApplicationReduceRenderingWork", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_PerformFirmwareUpdate, 1, FALSE, FALSE);
-    EVRFirmwareError (__stdcall *capi_IVRSystem_020_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
-
-    clear_parameters();
-    capi_IVRSystem_020_PerformFirmwareUpdate(1);
-    check_ptr_parameter("IVRSystem_020_PerformFirmwareUpdate", this_ptr_value);
-    check_uint32_parameter("IVRSystem_020_PerformFirmwareUpdate", 1);
-
-    init_thunk(t, this_ptr_value, IVRSystem_020_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_AcknowledgeQuit_Exiting)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_021_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_AcknowledgeQuit_Exiting();
-    check_ptr_parameter("IVRSystem_020_AcknowledgeQuit_Exiting", this_ptr_value);
+    capi_IVRSystem_021_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_021_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_021_PerformFirmwareUpdate", 1);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVRSystem_020_AcknowledgeQuit_UserPrompt)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_021_AcknowledgeQuit_Exiting)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_AcknowledgeQuit_UserPrompt();
-    check_ptr_parameter("IVRSystem_020_AcknowledgeQuit_UserPrompt", this_ptr_value);
+    capi_IVRSystem_021_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_021_AcknowledgeQuit_Exiting", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetAppContainerFilePaths, 2, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRSystem_020_GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetAppContainerFilePaths, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_021_GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetAppContainerFilePaths((void *)1, 2);
-    check_ptr_parameter("IVRSystem_020_GetAppContainerFilePaths", this_ptr_value);
-    check_ptr_parameter("IVRSystem_020_GetAppContainerFilePaths", (void *)1);
-    check_uint32_parameter("IVRSystem_020_GetAppContainerFilePaths", 2);
+    capi_IVRSystem_021_GetAppContainerFilePaths((void *)1, 2);
+    check_ptr_parameter("IVRSystem_021_GetAppContainerFilePaths", this_ptr_value);
+    check_ptr_parameter("IVRSystem_021_GetAppContainerFilePaths", (void *)1);
+    check_uint32_parameter("IVRSystem_021_GetAppContainerFilePaths", 2);
 
-    init_thunk(t, this_ptr_value, IVRSystem_020_GetRuntimeVersion, 0, FALSE, FALSE);
-    const char * (__stdcall *capi_IVRSystem_020_GetRuntimeVersion)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRSystem_021_GetRuntimeVersion, 0, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_021_GetRuntimeVersion)() = (void *)t;
 
     clear_parameters();
-    capi_IVRSystem_020_GetRuntimeVersion();
-    check_ptr_parameter("IVRSystem_020_GetRuntimeVersion", this_ptr_value);
+    capi_IVRSystem_021_GetRuntimeVersion();
+    check_ptr_parameter("IVRSystem_021_GetRuntimeVersion", this_ptr_value);
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
-void test_capi_thunks_IVRApplications_006(void)
+void test_capi_thunks_IVRApplications_007(void)
 {
     struct thunk *t = alloc_thunks(1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_AddApplicationManifest, 2, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_AddApplicationManifest, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_AddApplicationManifest((void *)1, 1);
-    check_ptr_parameter("IVRApplications_006_AddApplicationManifest", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_AddApplicationManifest", (void *)1);
-    check_bool_parameter("IVRApplications_006_AddApplicationManifest", 1);
+    capi_IVRApplications_007_AddApplicationManifest((void *)1, 1);
+    check_ptr_parameter("IVRApplications_007_AddApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_AddApplicationManifest", (void *)1);
+    check_bool_parameter("IVRApplications_007_AddApplicationManifest", 1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_RemoveApplicationManifest, 1, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_RemoveApplicationManifest, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_RemoveApplicationManifest((void *)1);
-    check_ptr_parameter("IVRApplications_006_RemoveApplicationManifest", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_RemoveApplicationManifest", (void *)1);
+    capi_IVRApplications_007_RemoveApplicationManifest((void *)1);
+    check_ptr_parameter("IVRApplications_007_RemoveApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_RemoveApplicationManifest", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_IsApplicationInstalled, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVRApplications_006_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_IsApplicationInstalled, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_007_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_IsApplicationInstalled((void *)1);
-    check_ptr_parameter("IVRApplications_006_IsApplicationInstalled", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_IsApplicationInstalled", (void *)1);
+    capi_IVRApplications_007_IsApplicationInstalled((void *)1);
+    check_ptr_parameter("IVRApplications_007_IsApplicationInstalled", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_IsApplicationInstalled", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationCount, 0, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationCount)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationCount)() = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationCount();
-    check_ptr_parameter("IVRApplications_006_GetApplicationCount", this_ptr_value);
+    capi_IVRApplications_007_GetApplicationCount();
+    check_ptr_parameter("IVRApplications_007_GetApplicationCount", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationKeyByIndex, 3, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationKeyByIndex(1, (void *)2, 3);
-    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByIndex", this_ptr_value);
-    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByIndex", 1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByIndex", (void *)2);
-    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByIndex", 3);
+    capi_IVRApplications_007_GetApplicationKeyByIndex(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_007_GetApplicationKeyByIndex", this_ptr_value);
+    check_uint32_parameter("IVRApplications_007_GetApplicationKeyByIndex", 1);
+    check_ptr_parameter("IVRApplications_007_GetApplicationKeyByIndex", (void *)2);
+    check_uint32_parameter("IVRApplications_007_GetApplicationKeyByIndex", 3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationKeyByProcessId(1, (void *)2, 3);
-    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByProcessId", this_ptr_value);
-    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByProcessId", 1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByProcessId", (void *)2);
-    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByProcessId", 3);
+    capi_IVRApplications_007_GetApplicationKeyByProcessId(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_007_GetApplicationKeyByProcessId", this_ptr_value);
+    check_uint32_parameter("IVRApplications_007_GetApplicationKeyByProcessId", 1);
+    check_ptr_parameter("IVRApplications_007_GetApplicationKeyByProcessId", (void *)2);
+    check_uint32_parameter("IVRApplications_007_GetApplicationKeyByProcessId", 3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchApplication, 1, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchApplication)(const char * pchAppKey) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchApplication)(const char * pchAppKey) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_LaunchApplication((void *)1);
-    check_ptr_parameter("IVRApplications_006_LaunchApplication", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_LaunchApplication", (void *)1);
+    capi_IVRApplications_007_LaunchApplication((void *)1);
+    check_ptr_parameter("IVRApplications_007_LaunchApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_LaunchApplication", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchTemplateApplication, 4, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchTemplateApplication)(const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchTemplateApplication, 4, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchTemplateApplication)(const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_LaunchTemplateApplication((void *)1, (void *)2, (void *)3, 4);
-    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)1);
-    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)2);
-    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)3);
-    check_uint32_parameter("IVRApplications_006_LaunchTemplateApplication", 4);
+    capi_IVRApplications_007_LaunchTemplateApplication((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRApplications_007_LaunchTemplateApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_LaunchTemplateApplication", (void *)1);
+    check_ptr_parameter("IVRApplications_007_LaunchTemplateApplication", (void *)2);
+    check_ptr_parameter("IVRApplications_007_LaunchTemplateApplication", (void *)3);
+    check_uint32_parameter("IVRApplications_007_LaunchTemplateApplication", 4);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchApplicationFromMimeType, 2, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchApplicationFromMimeType)(const char * pchMimeType, const char * pchArgs) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchApplicationFromMimeType, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchApplicationFromMimeType)(const char * pchMimeType, const char * pchArgs) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_LaunchApplicationFromMimeType((void *)1, (void *)2);
-    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", (void *)1);
-    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", (void *)2);
+    capi_IVRApplications_007_LaunchApplicationFromMimeType((void *)1, (void *)2);
+    check_ptr_parameter("IVRApplications_007_LaunchApplicationFromMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_LaunchApplicationFromMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_007_LaunchApplicationFromMimeType", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchDashboardOverlay, 1, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_LaunchDashboardOverlay((void *)1);
-    check_ptr_parameter("IVRApplications_006_LaunchDashboardOverlay", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_LaunchDashboardOverlay", (void *)1);
+    capi_IVRApplications_007_LaunchDashboardOverlay((void *)1);
+    check_ptr_parameter("IVRApplications_007_LaunchDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_LaunchDashboardOverlay", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_CancelApplicationLaunch, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVRApplications_006_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_CancelApplicationLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_007_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_CancelApplicationLaunch((void *)1);
-    check_ptr_parameter("IVRApplications_006_CancelApplicationLaunch", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_CancelApplicationLaunch", (void *)1);
+    capi_IVRApplications_007_CancelApplicationLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_007_CancelApplicationLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_CancelApplicationLaunch", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_IdentifyApplication, 2, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_IdentifyApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_IdentifyApplication(1, (void *)2);
-    check_ptr_parameter("IVRApplications_006_IdentifyApplication", this_ptr_value);
-    check_uint32_parameter("IVRApplications_006_IdentifyApplication", 1);
-    check_ptr_parameter("IVRApplications_006_IdentifyApplication", (void *)2);
+    capi_IVRApplications_007_IdentifyApplication(1, (void *)2);
+    check_ptr_parameter("IVRApplications_007_IdentifyApplication", this_ptr_value);
+    check_uint32_parameter("IVRApplications_007_IdentifyApplication", 1);
+    check_ptr_parameter("IVRApplications_007_IdentifyApplication", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationProcessId, 1, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationProcessId, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationProcessId((void *)1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationProcessId", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetApplicationProcessId", (void *)1);
+    capi_IVRApplications_007_GetApplicationProcessId((void *)1);
+    check_ptr_parameter("IVRApplications_007_GetApplicationProcessId", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetApplicationProcessId", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
-    const char * (__stdcall *capi_IVRApplications_006_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_007_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationsErrorNameFromEnum(1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationsErrorNameFromEnum", this_ptr_value);
-    check_uint32_parameter("IVRApplications_006_GetApplicationsErrorNameFromEnum", 1);
+    capi_IVRApplications_007_GetApplicationsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_007_GetApplicationsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_007_GetApplicationsErrorNameFromEnum", 1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyString, 5, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationPropertyString, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)1);
-    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyString", 2);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)3);
-    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyString", 4);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)5);
+    capi_IVRApplications_007_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyString", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyString", (void *)1);
+    check_uint32_parameter("IVRApplications_007_GetApplicationPropertyString", 2);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyString", (void *)3);
+    check_uint32_parameter("IVRApplications_007_GetApplicationPropertyString", 4);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyString", (void *)5);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyBool, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVRApplications_006_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_007_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationPropertyBool((void *)1, 2, (void *)3);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", (void *)1);
-    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyBool", 2);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", (void *)3);
+    capi_IVRApplications_007_GetApplicationPropertyBool((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyBool", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyBool", (void *)1);
+    check_uint32_parameter("IVRApplications_007_GetApplicationPropertyBool", 2);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyBool", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyUint64, 3, FALSE, FALSE);
-    uint64_t (__stdcall *capi_IVRApplications_006_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationPropertyUint64, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRApplications_007_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", (void *)1);
-    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyUint64", 2);
-    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", (void *)3);
+    capi_IVRApplications_007_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyUint64", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyUint64", (void *)1);
+    check_uint32_parameter("IVRApplications_007_GetApplicationPropertyUint64", 2);
+    check_ptr_parameter("IVRApplications_007_GetApplicationPropertyUint64", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_SetApplicationAutoLaunch, 2, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_SetApplicationAutoLaunch((void *)1, 1);
-    check_ptr_parameter("IVRApplications_006_SetApplicationAutoLaunch", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_SetApplicationAutoLaunch", (void *)1);
-    check_bool_parameter("IVRApplications_006_SetApplicationAutoLaunch", 1);
+    capi_IVRApplications_007_SetApplicationAutoLaunch((void *)1, 1);
+    check_ptr_parameter("IVRApplications_007_SetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_SetApplicationAutoLaunch", (void *)1);
+    check_bool_parameter("IVRApplications_007_SetApplicationAutoLaunch", 1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationAutoLaunch, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVRApplications_006_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_007_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationAutoLaunch((void *)1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationAutoLaunch", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetApplicationAutoLaunch", (void *)1);
+    capi_IVRApplications_007_GetApplicationAutoLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_007_GetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetApplicationAutoLaunch", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_SetDefaultApplicationForMimeType, 2, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_SetDefaultApplicationForMimeType)(const char * pchAppKey, const char * pchMimeType) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_SetDefaultApplicationForMimeType, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_SetDefaultApplicationForMimeType)(const char * pchAppKey, const char * pchMimeType) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_SetDefaultApplicationForMimeType((void *)1, (void *)2);
-    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", (void *)1);
-    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", (void *)2);
+    capi_IVRApplications_007_SetDefaultApplicationForMimeType((void *)1, (void *)2);
+    check_ptr_parameter("IVRApplications_007_SetDefaultApplicationForMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_SetDefaultApplicationForMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_007_SetDefaultApplicationForMimeType", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetDefaultApplicationForMimeType, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVRApplications_006_GetDefaultApplicationForMimeType)(const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetDefaultApplicationForMimeType, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_007_GetDefaultApplicationForMimeType)(const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetDefaultApplicationForMimeType((void *)1, (void *)2, 3);
-    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", (void *)1);
-    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", (void *)2);
-    check_uint32_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", 3);
+    capi_IVRApplications_007_GetDefaultApplicationForMimeType((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_007_GetDefaultApplicationForMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetDefaultApplicationForMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_007_GetDefaultApplicationForMimeType", (void *)2);
+    check_uint32_parameter("IVRApplications_007_GetDefaultApplicationForMimeType", 3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationSupportedMimeTypes, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVRApplications_006_GetApplicationSupportedMimeTypes)(const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationSupportedMimeTypes, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_007_GetApplicationSupportedMimeTypes)(const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationSupportedMimeTypes((void *)1, (void *)2, 3);
-    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", (void *)1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", (void *)2);
-    check_uint32_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", 3);
-
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsThatSupportMimeType, 3, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationsThatSupportMimeType)(const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = (void *)t;
-
-    clear_parameters();
-    capi_IVRApplications_006_GetApplicationsThatSupportMimeType((void *)1, (void *)2, 3);
-    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", (void *)1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", (void *)2);
-    check_uint32_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", 3);
+    capi_IVRApplications_007_GetApplicationSupportedMimeTypes((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_007_GetApplicationSupportedMimeTypes", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetApplicationSupportedMimeTypes", (void *)1);
+    check_ptr_parameter("IVRApplications_007_GetApplicationSupportedMimeTypes", (void *)2);
+    check_uint32_parameter("IVRApplications_007_GetApplicationSupportedMimeTypes", 3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationLaunchArguments, 3, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationLaunchArguments)(uint32_t unHandle, char * pchArgs, uint32_t unArgs) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationsThatSupportMimeType, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationsThatSupportMimeType)(const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationLaunchArguments(1, (void *)2, 3);
-    check_ptr_parameter("IVRApplications_006_GetApplicationLaunchArguments", this_ptr_value);
-    check_uint32_parameter("IVRApplications_006_GetApplicationLaunchArguments", 1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationLaunchArguments", (void *)2);
-    check_uint32_parameter("IVRApplications_006_GetApplicationLaunchArguments", 3);
+    capi_IVRApplications_007_GetApplicationsThatSupportMimeType((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_007_GetApplicationsThatSupportMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetApplicationsThatSupportMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_007_GetApplicationsThatSupportMimeType", (void *)2);
+    check_uint32_parameter("IVRApplications_007_GetApplicationsThatSupportMimeType", 3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetStartingApplication, 2, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetApplicationLaunchArguments, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_007_GetApplicationLaunchArguments)(uint32_t unHandle, char * pchArgs, uint32_t unArgs) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetStartingApplication((void *)1, 2);
-    check_ptr_parameter("IVRApplications_006_GetStartingApplication", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_GetStartingApplication", (void *)1);
-    check_uint32_parameter("IVRApplications_006_GetStartingApplication", 2);
+    capi_IVRApplications_007_GetApplicationLaunchArguments(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_007_GetApplicationLaunchArguments", this_ptr_value);
+    check_uint32_parameter("IVRApplications_007_GetApplicationLaunchArguments", 1);
+    check_ptr_parameter("IVRApplications_007_GetApplicationLaunchArguments", (void *)2);
+    check_uint32_parameter("IVRApplications_007_GetApplicationLaunchArguments", 3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetTransitionState, 0, FALSE, FALSE);
-    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_006_GetTransitionState)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetStartingApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetTransitionState();
-    check_ptr_parameter("IVRApplications_006_GetTransitionState", this_ptr_value);
+    capi_IVRApplications_007_GetStartingApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_007_GetStartingApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_GetStartingApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_007_GetStartingApplication", 2);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetSceneApplicationState, 0, FALSE, FALSE);
+    EVRSceneApplicationState (__stdcall *capi_IVRApplications_007_GetSceneApplicationState)() = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_PerformApplicationPrelaunchCheck((void *)1);
-    check_ptr_parameter("IVRApplications_006_PerformApplicationPrelaunchCheck", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_PerformApplicationPrelaunchCheck", (void *)1);
+    capi_IVRApplications_007_GetSceneApplicationState();
+    check_ptr_parameter("IVRApplications_007_GetSceneApplicationState", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
-    const char * (__stdcall *capi_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(1);
-    check_ptr_parameter("IVRApplications_006_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
-    check_uint32_parameter("IVRApplications_006_GetApplicationsTransitionStateNameFromEnum", 1);
+    capi_IVRApplications_007_PerformApplicationPrelaunchCheck((void *)1);
+    check_ptr_parameter("IVRApplications_007_PerformApplicationPrelaunchCheck", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_PerformApplicationPrelaunchCheck", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_IsQuitUserPromptRequested, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVRApplications_006_IsQuitUserPromptRequested)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetSceneApplicationStateNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_007_GetSceneApplicationStateNameFromEnum)(EVRSceneApplicationState state) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_IsQuitUserPromptRequested();
-    check_ptr_parameter("IVRApplications_006_IsQuitUserPromptRequested", this_ptr_value);
+    capi_IVRApplications_007_GetSceneApplicationStateNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_007_GetSceneApplicationStateNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_007_GetSceneApplicationStateNameFromEnum", 1);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchInternalProcess, 3, FALSE, FALSE);
-    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_LaunchInternalProcess, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_007_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
-    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", this_ptr_value);
-    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)1);
-    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)2);
-    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)3);
+    capi_IVRApplications_007_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRApplications_007_LaunchInternalProcess", this_ptr_value);
+    check_ptr_parameter("IVRApplications_007_LaunchInternalProcess", (void *)1);
+    check_ptr_parameter("IVRApplications_007_LaunchInternalProcess", (void *)2);
+    check_ptr_parameter("IVRApplications_007_LaunchInternalProcess", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVRApplications_006_GetCurrentSceneProcessId, 0, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVRApplications_006_GetCurrentSceneProcessId)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVRApplications_007_GetCurrentSceneProcessId, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_007_GetCurrentSceneProcessId)() = (void *)t;
 
     clear_parameters();
-    capi_IVRApplications_006_GetCurrentSceneProcessId();
-    check_ptr_parameter("IVRApplications_006_GetCurrentSceneProcessId", this_ptr_value);
+    capi_IVRApplications_007_GetCurrentSceneProcessId();
+    check_ptr_parameter("IVRApplications_007_GetCurrentSceneProcessId", this_ptr_value);
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
@@ -1498,776 +1484,740 @@ void test_capi_thunks_IVRNotifications_002(void)
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
-void test_capi_thunks_IVROverlay_020(void)
+void test_capi_thunks_IVROverlay_021(void)
 {
     struct thunk *t = alloc_thunks(1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_FindOverlay, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_FindOverlay((void *)1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_FindOverlay", this_ptr_value);
-    check_ptr_parameter("IVROverlay_020_FindOverlay", (void *)1);
-    check_ptr_parameter("IVROverlay_020_FindOverlay", (void *)2);
+    capi_IVROverlay_021_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_021_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_021_FindOverlay", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_CreateOverlay, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_CreateOverlay((void *)1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_CreateOverlay", this_ptr_value);
-    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)1);
-    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)2);
-    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)3);
+    capi_IVROverlay_021_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_021_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_021_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_021_CreateOverlay", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_DestroyOverlay, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_DestroyOverlay(1);
-    check_ptr_parameter("IVROverlay_020_DestroyOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_DestroyOverlay", 1);
+    capi_IVROverlay_021_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_021_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_DestroyOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayKey, 4, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_021_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayKey(1, (void *)2, 3, (void *)4);
-    check_ptr_parameter("IVROverlay_020_GetOverlayKey", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayKey", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayKey", (void *)2);
-    check_uint32_parameter("IVROverlay_020_GetOverlayKey", 3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayKey", (void *)4);
+    capi_IVROverlay_021_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_021_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_021_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayKey", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayName, 4, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_021_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayName(1, (void *)2, 3, (void *)4);
-    check_ptr_parameter("IVROverlay_020_GetOverlayName", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayName", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayName", (void *)2);
-    check_uint32_parameter("IVROverlay_020_GetOverlayName", 3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayName", (void *)4);
+    capi_IVROverlay_021_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_021_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_021_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayName", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayName, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayName, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayName(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayName", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayName", 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayName", (void *)2);
+    capi_IVROverlay_021_SetOverlayName(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayName", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayImageData, 5, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
-    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayImageData", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)2);
-    check_uint32_parameter("IVROverlay_020_GetOverlayImageData", 3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)4);
-    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)5);
+    capi_IVROverlay_021_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_021_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_021_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_021_GetOverlayImageData", (void *)5);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
-    const char * (__stdcall *capi_IVROverlay_020_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_021_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayErrorNameFromEnum(1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayErrorNameFromEnum", this_ptr_value);
-    check_uint32_parameter("IVROverlay_020_GetOverlayErrorNameFromEnum", 1);
+    capi_IVROverlay_021_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_021_GetOverlayErrorNameFromEnum", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRenderingPid, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayRenderingPid(1, 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayRenderingPid", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayRenderingPid", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlayRenderingPid", 2);
+    capi_IVROverlay_021_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlayRenderingPid", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayRenderingPid, 1, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_021_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayRenderingPid(1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayRenderingPid", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayRenderingPid", 1);
+    capi_IVROverlay_021_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayRenderingPid", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayFlag, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayFlag(1, 2, 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayFlag", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayFlag", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlayFlag", 2);
-    check_bool_parameter("IVROverlay_020_SetOverlayFlag", 1);
+    capi_IVROverlay_021_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_021_SetOverlayFlag", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayFlag, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayFlag(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayFlag", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayFlag", 1);
-    check_uint32_parameter("IVROverlay_020_GetOverlayFlag", 2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayFlag", (void *)3);
+    capi_IVROverlay_021_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_021_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayFlag", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayColor, 4, TRUE, TRUE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
-    check_ptr_parameter("IVROverlay_020_SetOverlayColor", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayColor", 1);
-    check_float_parameter("IVROverlay_020_SetOverlayColor", 2.0f);
-    check_float_parameter("IVROverlay_020_SetOverlayColor", 3.0f);
-    check_float_parameter("IVROverlay_020_SetOverlayColor", 4.0f);
+    capi_IVROverlay_021_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_021_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_021_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_021_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_021_SetOverlayColor", 4.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayColor, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
-    check_ptr_parameter("IVROverlay_020_GetOverlayColor", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayColor", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)4);
+    capi_IVROverlay_021_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_021_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayColor", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayAlpha, 2, TRUE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayAlpha(1, 2.0f);
-    check_ptr_parameter("IVROverlay_020_SetOverlayAlpha", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayAlpha", 1);
-    check_float_parameter("IVROverlay_020_SetOverlayAlpha", 2.0f);
+    capi_IVROverlay_021_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_021_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_021_SetOverlayAlpha", 2.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayAlpha, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayAlpha(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayAlpha", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayAlpha", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayAlpha", (void *)2);
+    capi_IVROverlay_021_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayAlpha", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTexelAspect, 2, TRUE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayTexelAspect(1, 2.0f);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTexelAspect", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTexelAspect", 1);
-    check_float_parameter("IVROverlay_020_SetOverlayTexelAspect", 2.0f);
+    capi_IVROverlay_021_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_021_SetOverlayTexelAspect", 2.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTexelAspect, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayTexelAspect(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexelAspect", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTexelAspect", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexelAspect", (void *)2);
+    capi_IVROverlay_021_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexelAspect", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlaySortOrder, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlaySortOrder(1, 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlaySortOrder", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlaySortOrder", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlaySortOrder", 2);
+    capi_IVROverlay_021_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlaySortOrder", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlaySortOrder, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlaySortOrder(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlaySortOrder", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlaySortOrder", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlaySortOrder", (void *)2);
+    capi_IVROverlay_021_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlaySortOrder", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayWidthInMeters, 2, TRUE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayWidthInMeters(1, 2.0f);
-    check_ptr_parameter("IVROverlay_020_SetOverlayWidthInMeters", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayWidthInMeters", 1);
-    check_float_parameter("IVROverlay_020_SetOverlayWidthInMeters", 2.0f);
+    capi_IVROverlay_021_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_021_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_021_SetOverlayWidthInMeters", 2.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayWidthInMeters, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayWidthInMeters(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayWidthInMeters", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayWidthInMeters", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayWidthInMeters", (void *)2);
+    capi_IVROverlay_021_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayWidthInMeters", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayCurvature, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
-    check_ptr_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 1);
-    check_float_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
-    check_float_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+    capi_IVROverlay_021_SetOverlayCurvature(1, 2.0f);
+    check_ptr_parameter("IVROverlay_021_SetOverlayCurvature", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayCurvature", 1);
+    check_float_parameter("IVROverlay_021_SetOverlayCurvature", 2.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayCurvature, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+    capi_IVROverlay_021_GetOverlayCurvature(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayCurvature", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayCurvature", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayCurvature", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayTextureColorSpace(1, 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTextureColorSpace", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTextureColorSpace", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlayTextureColorSpace", 2);
+    capi_IVROverlay_021_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlayTextureColorSpace", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayTextureColorSpace(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTextureColorSpace", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTextureColorSpace", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTextureColorSpace", (void *)2);
+    capi_IVROverlay_021_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTextureColorSpace", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTextureBounds, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayTextureBounds(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTextureBounds", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTextureBounds", 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTextureBounds", (void *)2);
+    capi_IVROverlay_021_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTextureBounds", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureBounds, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayTextureBounds(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTextureBounds", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTextureBounds", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTextureBounds", (void *)2);
+    capi_IVROverlay_021_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTextureBounds", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayRenderModel, 5, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayRenderModel, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_021_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
-    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayRenderModel", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)2);
-    check_uint32_parameter("IVROverlay_020_GetOverlayRenderModel", 3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)4);
-    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)5);
+    capi_IVROverlay_021_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_021_GetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayRenderModel", (void *)2);
+    check_uint32_parameter("IVROverlay_021_GetOverlayRenderModel", 3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayRenderModel", (void *)4);
+    check_ptr_parameter("IVROverlay_021_GetOverlayRenderModel", (void *)5);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRenderModel, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayRenderModel, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayRenderModel(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayRenderModel", 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", (void *)2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", (void *)3);
+    capi_IVROverlay_021_SetOverlayRenderModel(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_SetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayRenderModel", (void *)2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayRenderModel", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformType, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayTransformType(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformType", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTransformType", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformType", (void *)2);
+    capi_IVROverlay_021_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformType", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayTransformAbsolute(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTransformAbsolute", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTransformAbsolute", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlayTransformAbsolute", 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTransformAbsolute", (void *)3);
+    capi_IVROverlay_021_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTransformAbsolute", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTransformAbsolute", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", (void *)3);
+    capi_IVROverlay_021_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformAbsolute", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+    capi_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceRelative", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", (void *)3);
-
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
-
-    clear_parameters();
-    capi_IVROverlay_020_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", (void *)3);
-
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
-
-    clear_parameters();
-    capi_IVROverlay_020_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", (void *)3);
-    check_uint32_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", 4);
-
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
-
-    clear_parameters();
-    capi_IVROverlay_020_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", (void *)3);
-
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
-
-    clear_parameters();
-    capi_IVROverlay_020_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", 1);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", (void *)3);
+    capi_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceRelative", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_ShowOverlay, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_ShowOverlay(1);
-    check_ptr_parameter("IVROverlay_020_ShowOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_ShowOverlay", 1);
+    capi_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTransformTrackedDeviceComponent", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_HideOverlay, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_HideOverlay(1);
-    check_ptr_parameter("IVROverlay_020_HideOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_HideOverlay", 1);
+    capi_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_021_GetOverlayTransformTrackedDeviceComponent", 4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_IsOverlayVisible, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_020_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_IsOverlayVisible(1);
-    check_ptr_parameter("IVROverlay_020_IsOverlayVisible", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_IsOverlayVisible", 1);
+    capi_IVROverlay_021_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTransformOverlayRelative", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformOverlayRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTransformOverlayRelative", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
-    check_ptr_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", 1);
-    check_uint32_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", 2);
-    check_HmdVector2_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
-    check_ptr_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", (void *)4);
+    capi_IVROverlay_021_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTransformOverlayRelative", 1);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTransformOverlayRelative", 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTransformOverlayRelative", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_PollNextOverlayEvent, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_020_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_PollNextOverlayEvent(1, (void *)2, 3);
-    check_ptr_parameter("IVROverlay_020_PollNextOverlayEvent", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_PollNextOverlayEvent", 1);
-    check_ptr_parameter("IVROverlay_020_PollNextOverlayEvent", (void *)2);
-    check_uint32_parameter("IVROverlay_020_PollNextOverlayEvent", 3);
+    capi_IVROverlay_021_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_021_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_ShowOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayInputMethod, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayInputMethod(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayInputMethod", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayInputMethod", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayInputMethod", (void *)2);
+    capi_IVROverlay_021_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_021_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_HideOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayInputMethod, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_021_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayInputMethod(1, 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayInputMethod", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayInputMethod", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlayInputMethod", 2);
+    capi_IVROverlay_021_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_021_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_IsOverlayVisible", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayMouseScale, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayMouseScale(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayMouseScale", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayMouseScale", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayMouseScale", (void *)2);
+    capi_IVROverlay_021_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_021_GetTransformForOverlayCoordinates", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayMouseScale, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_021_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayMouseScale(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayMouseScale", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayMouseScale", 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayMouseScale", (void *)2);
+    capi_IVROverlay_021_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_021_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_021_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_021_PollNextOverlayEvent", 3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_ComputeOverlayIntersection, 3, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_020_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_ComputeOverlayIntersection(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_ComputeOverlayIntersection", 1);
-    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", (void *)2);
-    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", (void *)3);
+    capi_IVROverlay_021_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayInputMethod", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_IsHoverTargetOverlay, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_020_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_IsHoverTargetOverlay(1);
-    check_ptr_parameter("IVROverlay_020_IsHoverTargetOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_IsHoverTargetOverlay", 1);
+    capi_IVROverlay_021_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlayInputMethod", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetGamepadFocusOverlay, 0, FALSE, FALSE);
-    VROverlayHandle_t (__stdcall *capi_IVROverlay_020_GetGamepadFocusOverlay)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetGamepadFocusOverlay();
-    check_ptr_parameter("IVROverlay_020_GetGamepadFocusOverlay", this_ptr_value);
+    capi_IVROverlay_021_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayMouseScale", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetGamepadFocusOverlay, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetGamepadFocusOverlay(1);
-    check_ptr_parameter("IVROverlay_020_SetGamepadFocusOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetGamepadFocusOverlay", 1);
+    capi_IVROverlay_021_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayMouseScale", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayNeighbor, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_021_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayNeighbor(1, 2, 3);
-    check_ptr_parameter("IVROverlay_020_SetOverlayNeighbor", this_ptr_value);
-    check_uint32_parameter("IVROverlay_020_SetOverlayNeighbor", 1);
-    check_uint64_parameter("IVROverlay_020_SetOverlayNeighbor", 2);
-    check_uint64_parameter("IVROverlay_020_SetOverlayNeighbor", 3);
+    capi_IVROverlay_021_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_021_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_021_ComputeOverlayIntersection", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_021_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_MoveGamepadFocusToNeighbor(1, 2);
-    check_ptr_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", this_ptr_value);
-    check_uint32_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", 1);
-    check_uint64_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", 2);
+    capi_IVROverlay_021_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_021_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_IsHoverTargetOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
-    check_ptr_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 1);
-    check_uint32_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", (void *)3);
-    check_float_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 4.0f);
+    capi_IVROverlay_021_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
+    check_ptr_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", 1);
+    check_uint32_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", 2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", (void *)3);
+    check_float_parameter("IVROverlay_021_SetOverlayDualAnalogTransform", 4.0f);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
-    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", 1);
-    check_uint32_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", 2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", (void *)4);
+    capi_IVROverlay_021_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", 1);
+    check_uint32_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", 2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", (void *)3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayDualAnalogTransform", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTexture, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayTexture(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTexture", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayTexture", 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayTexture", (void *)2);
+    capi_IVROverlay_021_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayTexture", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_ClearOverlayTexture, 1, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_ClearOverlayTexture(1);
-    check_ptr_parameter("IVROverlay_020_ClearOverlayTexture", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_ClearOverlayTexture", 1);
+    capi_IVROverlay_021_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_021_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_ClearOverlayTexture", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRaw, 5, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayRaw(1, (void *)2, 3, 4, 5);
-    check_ptr_parameter("IVROverlay_020_SetOverlayRaw", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayRaw", 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayRaw", (void *)2);
-    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 3);
-    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 4);
-    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 5);
+    capi_IVROverlay_021_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_021_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_021_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_021_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_021_SetOverlayRaw", 5);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayFromFile, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayFromFile(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_SetOverlayFromFile", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayFromFile", 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayFromFile", (void *)2);
+    capi_IVROverlay_021_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayFromFile", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTexture, 9, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_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_021_GetOverlayTexture, 9, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_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_020_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTexture", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)4);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)5);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)6);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)7);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)8);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)9);
+    capi_IVROverlay_021_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)8);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTexture", (void *)9);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_ReleaseNativeOverlayHandle(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", 1);
-    check_ptr_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", (void *)2);
+    capi_IVROverlay_021_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_021_ReleaseNativeOverlayHandle", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureSize, 3, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayTextureSize(1, (void *)2, (void *)3);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayTextureSize", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", (void *)3);
+    capi_IVROverlay_021_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayTextureSize", (void *)3);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_CreateDashboardOverlay, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
-    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", this_ptr_value);
-    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)1);
-    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)2);
-    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)3);
-    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)4);
+    capi_IVROverlay_021_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_021_CreateDashboardOverlay", (void *)4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_IsDashboardVisible, 0, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_020_IsDashboardVisible)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_021_IsDashboardVisible)() = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_IsDashboardVisible();
-    check_ptr_parameter("IVROverlay_020_IsDashboardVisible", this_ptr_value);
+    capi_IVROverlay_021_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_021_IsDashboardVisible", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_IsActiveDashboardOverlay, 1, FALSE, FALSE);
-    bool (__stdcall *capi_IVROverlay_020_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_021_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_IsActiveDashboardOverlay(1);
-    check_ptr_parameter("IVROverlay_020_IsActiveDashboardOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_IsActiveDashboardOverlay", 1);
+    capi_IVROverlay_021_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_021_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_IsActiveDashboardOverlay", 1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetDashboardOverlaySceneProcess(1, 2);
-    check_ptr_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", 1);
-    check_uint32_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", 2);
+    capi_IVROverlay_021_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_021_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_021_SetDashboardOverlaySceneProcess", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetDashboardOverlaySceneProcess(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", 1);
-    check_ptr_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", (void *)2);
+    capi_IVROverlay_021_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_021_GetDashboardOverlaySceneProcess", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_ShowDashboard, 1, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_020_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_021_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_ShowDashboard((void *)1);
-    check_ptr_parameter("IVROverlay_020_ShowDashboard", this_ptr_value);
-    check_ptr_parameter("IVROverlay_020_ShowDashboard", (void *)1);
+    capi_IVROverlay_021_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_021_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_021_ShowDashboard", (void *)1);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
-    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_020_GetPrimaryDashboardDevice)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_021_GetPrimaryDashboardDevice)() = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetPrimaryDashboardDevice();
-    check_ptr_parameter("IVROverlay_020_GetPrimaryDashboardDevice", this_ptr_value);
+    capi_IVROverlay_021_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_021_GetPrimaryDashboardDevice", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_ShowKeyboard, 7, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
-    check_ptr_parameter("IVROverlay_020_ShowKeyboard", this_ptr_value);
-    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 1);
-    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 2);
-    check_ptr_parameter("IVROverlay_020_ShowKeyboard", (void *)3);
-    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 4);
-    check_ptr_parameter("IVROverlay_020_ShowKeyboard", (void *)5);
-    check_bool_parameter("IVROverlay_020_ShowKeyboard", 1);
-    check_uint64_parameter("IVROverlay_020_ShowKeyboard", 7);
+    capi_IVROverlay_021_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_021_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_021_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_021_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_021_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_021_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_021_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_021_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_021_ShowKeyboard", 7);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_ShowKeyboardForOverlay, 8, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
-    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_ShowKeyboardForOverlay", 1);
-    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 2);
-    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 3);
-    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", (void *)4);
-    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 5);
-    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", (void *)6);
-    check_bool_parameter("IVROverlay_020_ShowKeyboardForOverlay", 1);
-    check_uint64_parameter("IVROverlay_020_ShowKeyboardForOverlay", 8);
+    capi_IVROverlay_021_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_021_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_021_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_021_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_021_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_021_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_021_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_021_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_021_ShowKeyboardForOverlay", 8);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetKeyboardText, 2, FALSE, FALSE);
-    uint32_t (__stdcall *capi_IVROverlay_020_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_021_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetKeyboardText((void *)1, 2);
-    check_ptr_parameter("IVROverlay_020_GetKeyboardText", this_ptr_value);
-    check_ptr_parameter("IVROverlay_020_GetKeyboardText", (void *)1);
-    check_uint32_parameter("IVROverlay_020_GetKeyboardText", 2);
+    capi_IVROverlay_021_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_021_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_021_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_021_GetKeyboardText", 2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_HideKeyboard, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_020_HideKeyboard)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_021_HideKeyboard)() = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_HideKeyboard();
-    check_ptr_parameter("IVROverlay_020_HideKeyboard", this_ptr_value);
+    capi_IVROverlay_021_HideKeyboard();
+    check_ptr_parameter("IVROverlay_021_HideKeyboard", this_ptr_value);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_020_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_021_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetKeyboardTransformAbsolute(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", this_ptr_value);
-    check_uint32_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", 1);
-    check_ptr_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", (void *)2);
+    capi_IVROverlay_021_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_021_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_021_SetKeyboardTransformAbsolute", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_020_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_021_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
-    check_ptr_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", 1);
-    check_HmdRect2_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+    capi_IVROverlay_021_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_021_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_021_SetKeyboardPositionForOverlay", DEFAULT_RECT);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayIntersectionMask, 4, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
-    check_ptr_parameter("IVROverlay_020_SetOverlayIntersectionMask", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_SetOverlayIntersectionMask", 1);
-    check_ptr_parameter("IVROverlay_020_SetOverlayIntersectionMask", (void *)2);
-    check_uint32_parameter("IVROverlay_020_SetOverlayIntersectionMask", 3);
-    check_uint32_parameter("IVROverlay_020_SetOverlayIntersectionMask", 4);
+    capi_IVROverlay_021_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_021_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_021_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_021_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_021_SetOverlayIntersectionMask", 4);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayFlags, 2, FALSE, FALSE);
-    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_GetOverlayFlags, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_021_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_GetOverlayFlags(1, (void *)2);
-    check_ptr_parameter("IVROverlay_020_GetOverlayFlags", this_ptr_value);
-    check_uint64_parameter("IVROverlay_020_GetOverlayFlags", 1);
-    check_ptr_parameter("IVROverlay_020_GetOverlayFlags", (void *)2);
+    capi_IVROverlay_021_GetOverlayFlags(1, (void *)2);
+    check_ptr_parameter("IVROverlay_021_GetOverlayFlags", this_ptr_value);
+    check_uint64_parameter("IVROverlay_021_GetOverlayFlags", 1);
+    check_ptr_parameter("IVROverlay_021_GetOverlayFlags", (void *)2);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_ShowMessageOverlay, 6, FALSE, FALSE);
-    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_020_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_021_ShowMessageOverlay, 6, FALSE, FALSE);
+    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_021_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_020_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
-    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", this_ptr_value);
-    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)1);
-    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)2);
-    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)3);
-    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)4);
-    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)5);
-    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)6);
+    capi_IVROverlay_021_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
+    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)4);
+    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)5);
+    check_ptr_parameter("IVROverlay_021_ShowMessageOverlay", (void *)6);
 
-    init_thunk(t, this_ptr_value, IVROverlay_020_CloseMessageOverlay, 0, FALSE, FALSE);
-    void (__stdcall *capi_IVROverlay_020_CloseMessageOverlay)() = (void *)t;
+    init_thunk(t, this_ptr_value, IVROverlay_021_CloseMessageOverlay, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_021_CloseMessageOverlay)() = (void *)t;
 
     clear_parameters();
-    capi_IVROverlay_020_CloseMessageOverlay();
-    check_ptr_parameter("IVROverlay_020_CloseMessageOverlay", this_ptr_value);
+    capi_IVROverlay_021_CloseMessageOverlay();
+    check_ptr_parameter("IVROverlay_021_CloseMessageOverlay", this_ptr_value);
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
@@ -3075,6 +3025,17 @@ void test_capi_thunks_IVRInput_007(void)
     clear_parameters();
     capi_IVRInput_007_IsUsingLegacyInput();
     check_ptr_parameter("IVRInput_007_IsUsingLegacyInput", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRInput_007_OpenBindingUI, 4, FALSE, FALSE);
+    EVRInputError (__stdcall *capi_IVRInput_007_OpenBindingUI)(const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRInput_007_OpenBindingUI((void *)1, 2, 3, 1);
+    check_ptr_parameter("IVRInput_007_OpenBindingUI", this_ptr_value);
+    check_ptr_parameter("IVRInput_007_OpenBindingUI", (void *)1);
+    check_uint64_parameter("IVRInput_007_OpenBindingUI", 2);
+    check_uint64_parameter("IVRInput_007_OpenBindingUI", 3);
+    check_bool_parameter("IVRInput_007_OpenBindingUI", 1);
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
@@ -3203,6 +3164,1498 @@ void test_capi_thunks_IVRClientCore_003(void)
     VirtualFree(t, 0, MEM_RELEASE);
 }
 
+void test_capi_thunks_IVRSystem_020(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetRecommendedRenderTargetSize((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", (void *)1);
+    check_ptr_parameter("IVRSystem_020_GetRecommendedRenderTargetSize", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetProjectionMatrix, 4, TRUE, TRUE);
+    HmdMatrix44_t *(__stdcall *capi_IVRSystem_020_GetProjectionMatrix)(HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetProjectionMatrix(data_ptr_value, 1, 2.0f, 3.0f);
+    check_ptr_parameter("IVRSystem_020_GetProjectionMatrix", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetProjectionMatrix", data_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetProjectionMatrix", 1);
+    check_float_parameter("IVRSystem_020_GetProjectionMatrix", 2.0f);
+    check_float_parameter("IVRSystem_020_GetProjectionMatrix", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetProjectionRaw, 5, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetProjectionRaw(1, (void *)2, (void *)3, (void *)4, (void *)5);
+    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetProjectionRaw", 1);
+    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)2);
+    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)3);
+    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)4);
+    check_ptr_parameter("IVRSystem_020_GetProjectionRaw", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_ComputeDistortion, 4, TRUE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_ComputeDistortion)(EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_ComputeDistortion(1, 2.0f, 3.0f, (void *)4);
+    check_ptr_parameter("IVRSystem_020_ComputeDistortion", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_ComputeDistortion", 1);
+    check_float_parameter("IVRSystem_020_ComputeDistortion", 2.0f);
+    check_float_parameter("IVRSystem_020_ComputeDistortion", 3.0f);
+    check_ptr_parameter("IVRSystem_020_ComputeDistortion", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetEyeToHeadTransform)(HmdMatrix34_t *_r, EVREye eEye) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetEyeToHeadTransform(data_ptr_value, 1);
+    check_ptr_parameter("IVRSystem_020_GetEyeToHeadTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetEyeToHeadTransform", data_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetEyeToHeadTransform", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetTimeSinceLastVsync((void *)1, (void *)2);
+    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", (void *)1);
+    check_ptr_parameter("IVRSystem_020_GetTimeSinceLastVsync", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_020_GetD3D9AdapterIndex)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetD3D9AdapterIndex();
+    check_ptr_parameter("IVRSystem_020_GetD3D9AdapterIndex", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_GetDXGIOutputInfo)(int32_t * pnAdapterIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetDXGIOutputInfo((void *)1);
+    check_ptr_parameter("IVRSystem_020_GetDXGIOutputInfo", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetDXGIOutputInfo", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetOutputDevice, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetOutputDevice((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_020_GetOutputDevice", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetOutputDevice", (void *)1);
+    check_uint32_parameter("IVRSystem_020_GetOutputDevice", 2);
+    check_ptr_parameter("IVRSystem_020_GetOutputDevice", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_IsDisplayOnDesktop)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_IsDisplayOnDesktop();
+    check_ptr_parameter("IVRSystem_020_IsDisplayOnDesktop", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_SetDisplayVisibility, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_SetDisplayVisibility)(bool bIsVisibleOnDesktop) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_SetDisplayVisibility(1);
+    check_ptr_parameter("IVRSystem_020_SetDisplayVisibility", this_ptr_value);
+    check_bool_parameter("IVRSystem_020_SetDisplayVisibility", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetDeviceToAbsoluteTrackingPose(1, 2.0f, (void *)3, 4);
+    check_ptr_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 1);
+    check_float_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 2.0f);
+    check_ptr_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", (void *)3);
+    check_uint32_parameter("IVRSystem_020_GetDeviceToAbsoluteTrackingPose", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_ResetSeatedZeroPose)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_ResetSeatedZeroPose();
+    check_ptr_parameter("IVRSystem_020_ResetSeatedZeroPose", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetSeatedZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose)(HmdMatrix34_t *_r) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose(data_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetRawZeroPoseToStandingAbsoluteTrackingPose", data_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 1);
+    check_ptr_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", (void *)2);
+    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 3);
+    check_uint32_parameter("IVRSystem_020_GetSortedTrackedDeviceIndicesOfClass", 4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    EDeviceActivityLevel (__stdcall *capi_IVRSystem_020_GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetTrackedDeviceActivityLevel(1);
+    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceActivityLevel", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceActivityLevel", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_ApplyTransform, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_ApplyTransform)(TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_ApplyTransform((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRSystem_020_ApplyTransform", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)1);
+    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)2);
+    check_ptr_parameter("IVRSystem_020_ApplyTransform", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVRSystem_020_GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetTrackedDeviceIndexForControllerRole(1);
+    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceIndexForControllerRole", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceIndexForControllerRole", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    ETrackedControllerRole (__stdcall *capi_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetControllerRoleForTrackedDeviceIndex(1);
+    check_ptr_parameter("IVRSystem_020_GetControllerRoleForTrackedDeviceIndex", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetControllerRoleForTrackedDeviceIndex", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    ETrackedDeviceClass (__stdcall *capi_IVRSystem_020_GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetTrackedDeviceClass(1);
+    check_ptr_parameter("IVRSystem_020_GetTrackedDeviceClass", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetTrackedDeviceClass", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_IsTrackedDeviceConnected(1);
+    check_ptr_parameter("IVRSystem_020_IsTrackedDeviceConnected", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_IsTrackedDeviceConnected", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetBoolTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_020_GetBoolTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    float (__stdcall *capi_IVRSystem_020_GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetFloatTrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_020_GetFloatTrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    int32_t (__stdcall *capi_IVRSystem_020_GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetInt32TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_020_GetInt32TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRSystem_020_GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetUint64TrackedDeviceProperty(1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_020_GetUint64TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    HmdMatrix34_t *(__stdcall *capi_IVRSystem_020_GetMatrix34TrackedDeviceProperty)(HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetMatrix34TrackedDeviceProperty(data_ptr_value, 1, 2, (void *)3);
+    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", data_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_020_GetMatrix34TrackedDeviceProperty", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_020_GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetArrayTrackedDeviceProperty(1, 2, 3, (void *)4, 5, (void *)6);
+    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 2);
+    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 3);
+    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", (void *)4);
+    check_uint32_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", 5);
+    check_ptr_parameter("IVRSystem_020_GetArrayTrackedDeviceProperty", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_020_GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetStringTrackedDeviceProperty(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 1);
+    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 2);
+    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", (void *)3);
+    check_uint32_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", 4);
+    check_ptr_parameter("IVRSystem_020_GetStringTrackedDeviceProperty", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_020_GetPropErrorNameFromEnum)(ETrackedPropertyError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetPropErrorNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_020_GetPropErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetPropErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_PollNextEvent, 2, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_PollNextEvent)(VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_PollNextEvent((void *)1, 2);
+    check_ptr_parameter("IVRSystem_020_PollNextEvent", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_PollNextEvent", (void *)1);
+    check_uint32_parameter("IVRSystem_020_PollNextEvent", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_PollNextEventWithPose, 4, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_PollNextEventWithPose(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_PollNextEventWithPose", 1);
+    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", (void *)2);
+    check_uint32_parameter("IVRSystem_020_PollNextEventWithPose", 3);
+    check_ptr_parameter("IVRSystem_020_PollNextEventWithPose", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_020_GetEventTypeNameFromEnum)(EVREventType eType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetEventTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_020_GetEventTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetEventTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetHiddenAreaMesh, 3, FALSE, FALSE);
+    HiddenAreaMesh_t *(__stdcall *capi_IVRSystem_020_GetHiddenAreaMesh)(HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetHiddenAreaMesh(data_ptr_value, 1, 2);
+    check_ptr_parameter("IVRSystem_020_GetHiddenAreaMesh", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetHiddenAreaMesh", data_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetHiddenAreaMesh", 1);
+    check_uint32_parameter("IVRSystem_020_GetHiddenAreaMesh", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerState, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetControllerState(1, (void *)2, 3);
+    check_ptr_parameter("IVRSystem_020_GetControllerState", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetControllerState", 1);
+    check_ptr_parameter("IVRSystem_020_GetControllerState", (void *)2);
+    check_uint32_parameter("IVRSystem_020_GetControllerState", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerStateWithPose, 5, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetControllerStateWithPose(1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 1);
+    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 2);
+    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", (void *)3);
+    check_uint32_parameter("IVRSystem_020_GetControllerStateWithPose", 4);
+    check_ptr_parameter("IVRSystem_020_GetControllerStateWithPose", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_TriggerHapticPulse, 3, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_TriggerHapticPulse(1, 2, 3);
+    check_ptr_parameter("IVRSystem_020_TriggerHapticPulse", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 1);
+    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 2);
+    check_uint32_parameter("IVRSystem_020_TriggerHapticPulse", 3);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_020_GetButtonIdNameFromEnum)(EVRButtonId eButtonId) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetButtonIdNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_020_GetButtonIdNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetButtonIdNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_020_GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetControllerAxisTypeNameFromEnum(1);
+    check_ptr_parameter("IVRSystem_020_GetControllerAxisTypeNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_GetControllerAxisTypeNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_IsInputAvailable, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_IsInputAvailable)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_IsInputAvailable();
+    check_ptr_parameter("IVRSystem_020_IsInputAvailable", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_IsSteamVRDrawingControllers)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_IsSteamVRDrawingControllers();
+    check_ptr_parameter("IVRSystem_020_IsSteamVRDrawingControllers", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_ShouldApplicationPause, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_ShouldApplicationPause)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_ShouldApplicationPause();
+    check_ptr_parameter("IVRSystem_020_ShouldApplicationPause", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRSystem_020_ShouldApplicationReduceRenderingWork)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_ShouldApplicationReduceRenderingWork();
+    check_ptr_parameter("IVRSystem_020_ShouldApplicationReduceRenderingWork", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    EVRFirmwareError (__stdcall *capi_IVRSystem_020_PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_PerformFirmwareUpdate(1);
+    check_ptr_parameter("IVRSystem_020_PerformFirmwareUpdate", this_ptr_value);
+    check_uint32_parameter("IVRSystem_020_PerformFirmwareUpdate", 1);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_AcknowledgeQuit_Exiting)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_AcknowledgeQuit_Exiting();
+    check_ptr_parameter("IVRSystem_020_AcknowledgeQuit_Exiting", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_AcknowledgeQuit_UserPrompt, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVRSystem_020_AcknowledgeQuit_UserPrompt)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_AcknowledgeQuit_UserPrompt();
+    check_ptr_parameter("IVRSystem_020_AcknowledgeQuit_UserPrompt", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetAppContainerFilePaths, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRSystem_020_GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetAppContainerFilePaths((void *)1, 2);
+    check_ptr_parameter("IVRSystem_020_GetAppContainerFilePaths", this_ptr_value);
+    check_ptr_parameter("IVRSystem_020_GetAppContainerFilePaths", (void *)1);
+    check_uint32_parameter("IVRSystem_020_GetAppContainerFilePaths", 2);
+
+    init_thunk(t, this_ptr_value, IVRSystem_020_GetRuntimeVersion, 0, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRSystem_020_GetRuntimeVersion)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRSystem_020_GetRuntimeVersion();
+    check_ptr_parameter("IVRSystem_020_GetRuntimeVersion", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVRApplications_006(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_AddApplicationManifest, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_AddApplicationManifest)(const char * pchApplicationManifestFullPath, bool bTemporary) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_AddApplicationManifest((void *)1, 1);
+    check_ptr_parameter("IVRApplications_006_AddApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_AddApplicationManifest", (void *)1);
+    check_bool_parameter("IVRApplications_006_AddApplicationManifest", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_RemoveApplicationManifest, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_RemoveApplicationManifest)(const char * pchApplicationManifestFullPath) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_RemoveApplicationManifest((void *)1);
+    check_ptr_parameter("IVRApplications_006_RemoveApplicationManifest", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_RemoveApplicationManifest", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_IsApplicationInstalled, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_IsApplicationInstalled)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_IsApplicationInstalled((void *)1);
+    check_ptr_parameter("IVRApplications_006_IsApplicationInstalled", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_IsApplicationInstalled", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationCount, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationCount)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationCount();
+    check_ptr_parameter("IVRApplications_006_GetApplicationCount", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationKeyByIndex(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByIndex", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByIndex", 1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByIndex", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByIndex", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationKeyByProcessId(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByProcessId", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByProcessId", 1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationKeyByProcessId", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationKeyByProcessId", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchApplication, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchApplication)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchApplication((void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchApplication", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchTemplateApplication, 4, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchTemplateApplication)(const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchTemplateApplication((void *)1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)2);
+    check_ptr_parameter("IVRApplications_006_LaunchTemplateApplication", (void *)3);
+    check_uint32_parameter("IVRApplications_006_LaunchTemplateApplication", 4);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchApplicationFromMimeType, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchApplicationFromMimeType)(const char * pchMimeType, const char * pchArgs) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchApplicationFromMimeType((void *)1, (void *)2);
+    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchApplicationFromMimeType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchDashboardOverlay)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchDashboardOverlay((void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchDashboardOverlay", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_CancelApplicationLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_CancelApplicationLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_CancelApplicationLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_006_CancelApplicationLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_CancelApplicationLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_IdentifyApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_IdentifyApplication)(uint32_t unProcessId, const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_IdentifyApplication(1, (void *)2);
+    check_ptr_parameter("IVRApplications_006_IdentifyApplication", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_IdentifyApplication", 1);
+    check_ptr_parameter("IVRApplications_006_IdentifyApplication", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationProcessId, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationProcessId)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationProcessId((void *)1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationProcessId", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationProcessId", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_006_GetApplicationsErrorNameFromEnum)(EVRApplicationError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationsErrorNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationsErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyString, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationPropertyString)(const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationPropertyString((void *)1, 2, (void *)3, 4, (void *)5);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)1);
+    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyString", 2);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)3);
+    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyString", 4);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyString", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_GetApplicationPropertyBool)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationPropertyBool((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", (void *)1);
+    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyBool", 2);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyBool", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationPropertyUint64, 3, FALSE, FALSE);
+    uint64_t (__stdcall *capi_IVRApplications_006_GetApplicationPropertyUint64)(const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationPropertyUint64((void *)1, 2, (void *)3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", (void *)1);
+    check_uint32_parameter("IVRApplications_006_GetApplicationPropertyUint64", 2);
+    check_ptr_parameter("IVRApplications_006_GetApplicationPropertyUint64", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_SetApplicationAutoLaunch)(const char * pchAppKey, bool bAutoLaunch) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_SetApplicationAutoLaunch((void *)1, 1);
+    check_ptr_parameter("IVRApplications_006_SetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_SetApplicationAutoLaunch", (void *)1);
+    check_bool_parameter("IVRApplications_006_SetApplicationAutoLaunch", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_GetApplicationAutoLaunch)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationAutoLaunch((void *)1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationAutoLaunch", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationAutoLaunch", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_SetDefaultApplicationForMimeType, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_SetDefaultApplicationForMimeType)(const char * pchAppKey, const char * pchMimeType) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_SetDefaultApplicationForMimeType((void *)1, (void *)2);
+    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_006_SetDefaultApplicationForMimeType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetDefaultApplicationForMimeType, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_GetDefaultApplicationForMimeType)(const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetDefaultApplicationForMimeType((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetDefaultApplicationForMimeType", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationSupportedMimeTypes, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_GetApplicationSupportedMimeTypes)(const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationSupportedMimeTypes((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", (void *)1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationSupportedMimeTypes", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsThatSupportMimeType, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationsThatSupportMimeType)(const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationsThatSupportMimeType((void *)1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", (void *)1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationsThatSupportMimeType", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationLaunchArguments, 3, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetApplicationLaunchArguments)(uint32_t unHandle, char * pchArgs, uint32_t unArgs) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationLaunchArguments(1, (void *)2, 3);
+    check_ptr_parameter("IVRApplications_006_GetApplicationLaunchArguments", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationLaunchArguments", 1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationLaunchArguments", (void *)2);
+    check_uint32_parameter("IVRApplications_006_GetApplicationLaunchArguments", 3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetStartingApplication, 2, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetStartingApplication((void *)1, 2);
+    check_ptr_parameter("IVRApplications_006_GetStartingApplication", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_GetStartingApplication", (void *)1);
+    check_uint32_parameter("IVRApplications_006_GetStartingApplication", 2);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetTransitionState, 0, FALSE, FALSE);
+    EVRApplicationTransitionState (__stdcall *capi_IVRApplications_006_GetTransitionState)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetTransitionState();
+    check_ptr_parameter("IVRApplications_006_GetTransitionState", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_PerformApplicationPrelaunchCheck)(const char * pchAppKey) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_PerformApplicationPrelaunchCheck((void *)1);
+    check_ptr_parameter("IVRApplications_006_PerformApplicationPrelaunchCheck", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_PerformApplicationPrelaunchCheck", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetApplicationsTransitionStateNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum)(EVRApplicationTransitionState state) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetApplicationsTransitionStateNameFromEnum(1);
+    check_ptr_parameter("IVRApplications_006_GetApplicationsTransitionStateNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVRApplications_006_GetApplicationsTransitionStateNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_IsQuitUserPromptRequested, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVRApplications_006_IsQuitUserPromptRequested)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_IsQuitUserPromptRequested();
+    check_ptr_parameter("IVRApplications_006_IsQuitUserPromptRequested", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_LaunchInternalProcess, 3, FALSE, FALSE);
+    EVRApplicationError (__stdcall *capi_IVRApplications_006_LaunchInternalProcess)(const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory) = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_LaunchInternalProcess((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", this_ptr_value);
+    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)1);
+    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)2);
+    check_ptr_parameter("IVRApplications_006_LaunchInternalProcess", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVRApplications_006_GetCurrentSceneProcessId, 0, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVRApplications_006_GetCurrentSceneProcessId)() = (void *)t;
+
+    clear_parameters();
+    capi_IVRApplications_006_GetCurrentSceneProcessId();
+    check_ptr_parameter("IVRApplications_006_GetCurrentSceneProcessId", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
+void test_capi_thunks_IVROverlay_020(void)
+{
+    struct thunk *t = alloc_thunks(1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_FindOverlay, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_FindOverlay)(const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_FindOverlay((void *)1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_FindOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_020_FindOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_020_FindOverlay", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_CreateOverlay, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_CreateOverlay)(const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_CreateOverlay((void *)1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_CreateOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_020_CreateOverlay", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_DestroyOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_DestroyOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_DestroyOverlay(1);
+    check_ptr_parameter("IVROverlay_020_DestroyOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_DestroyOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayKey, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayKey(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_020_GetOverlayKey", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayKey", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayKey", (void *)2);
+    check_uint32_parameter("IVROverlay_020_GetOverlayKey", 3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayKey", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayName, 4, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayName(1, (void *)2, 3, (void *)4);
+    check_ptr_parameter("IVROverlay_020_GetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayName", (void *)2);
+    check_uint32_parameter("IVROverlay_020_GetOverlayName", 3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayName", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayName, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayName)(VROverlayHandle_t ulOverlayHandle, const char * pchName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayName(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayName", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayName", 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayName", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayImageData, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayImageData(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayImageData", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)2);
+    check_uint32_parameter("IVROverlay_020_GetOverlayImageData", 3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)4);
+    check_ptr_parameter("IVROverlay_020_GetOverlayImageData", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    const char * (__stdcall *capi_IVROverlay_020_GetOverlayErrorNameFromEnum)(EVROverlayError error) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayErrorNameFromEnum(1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayErrorNameFromEnum", this_ptr_value);
+    check_uint32_parameter("IVROverlay_020_GetOverlayErrorNameFromEnum", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayRenderingPid(1, 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayRenderingPid", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlayRenderingPid", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayRenderingPid(1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayRenderingPid", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayRenderingPid", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayFlag(1, 2, 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlayFlag", 2);
+    check_bool_parameter("IVROverlay_020_SetOverlayFlag", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayFlag, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayFlag(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayFlag", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayFlag", 1);
+    check_uint32_parameter("IVROverlay_020_GetOverlayFlag", 2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayFlag", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayColor, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayColor(1, 2.0f, 3.0f, 4.0f);
+    check_ptr_parameter("IVROverlay_020_SetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayColor", 1);
+    check_float_parameter("IVROverlay_020_SetOverlayColor", 2.0f);
+    check_float_parameter("IVROverlay_020_SetOverlayColor", 3.0f);
+    check_float_parameter("IVROverlay_020_SetOverlayColor", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayColor, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayColor(1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_020_GetOverlayColor", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayColor", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayColor", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayAlpha, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayAlpha(1, 2.0f);
+    check_ptr_parameter("IVROverlay_020_SetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayAlpha", 1);
+    check_float_parameter("IVROverlay_020_SetOverlayAlpha", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayAlpha, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayAlpha(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayAlpha", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayAlpha", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayAlpha", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayTexelAspect(1, 2.0f);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTexelAspect", 1);
+    check_float_parameter("IVROverlay_020_SetOverlayTexelAspect", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTexelAspect(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexelAspect", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTexelAspect", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexelAspect", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlaySortOrder(1, 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlaySortOrder", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlaySortOrder", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlaySortOrder, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlaySortOrder(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlaySortOrder", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlaySortOrder", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlaySortOrder", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayWidthInMeters(1, 2.0f);
+    check_ptr_parameter("IVROverlay_020_SetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayWidthInMeters", 1);
+    check_float_parameter("IVROverlay_020_SetOverlayWidthInMeters", 2.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayWidthInMeters(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayWidthInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayWidthInMeters", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayWidthInMeters", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters, 3, TRUE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters(1, 2.0f, 3.0f);
+    check_ptr_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_float_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 2.0f);
+    check_float_parameter("IVROverlay_020_SetOverlayAutoCurveDistanceRangeInMeters", 3.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfMinDistanceInMeters, float * pfMaxDistanceInMeters) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayAutoCurveDistanceRangeInMeters", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayTextureColorSpace(1, 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTextureColorSpace", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlayTextureColorSpace", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTextureColorSpace(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTextureColorSpace", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTextureColorSpace", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTextureColorSpace", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTextureBounds(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTextureBounds", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTextureBounds", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTextureBounds", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayRenderModel, 5, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_020_GetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayRenderModel(1, (void *)2, 3, (void *)4, (void *)5);
+    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)2);
+    check_uint32_parameter("IVROverlay_020_GetOverlayRenderModel", 3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)4);
+    check_ptr_parameter("IVROverlay_020_GetOverlayRenderModel", (void *)5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRenderModel, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRenderModel)(VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayRenderModel(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayRenderModel", 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", (void *)2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayRenderModel", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformType, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTransformType(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformType", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTransformType", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformType", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayTransformAbsolute(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTransformAbsolute", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlayTransformAbsolute", 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTransformAbsolute(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformAbsolute", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayTransformTrackedDeviceRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTransformTrackedDeviceRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayTransformTrackedDeviceComponent(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTransformTrackedDeviceComponent", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTransformTrackedDeviceComponent(1, (void *)2, (void *)3, 4);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", (void *)3);
+    check_uint32_parameter("IVROverlay_020_GetOverlayTransformTrackedDeviceComponent", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTransformOverlayRelative(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayTransformOverlayRelative(1, 2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", 1);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTransformOverlayRelative", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_ShowOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_ShowOverlay(1);
+    check_ptr_parameter("IVROverlay_020_ShowOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_ShowOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_HideOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_HideOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_HideOverlay(1);
+    check_ptr_parameter("IVROverlay_020_HideOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_HideOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_IsOverlayVisible, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_020_IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_IsOverlayVisible(1);
+    check_ptr_parameter("IVROverlay_020_IsOverlayVisible", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_IsOverlayVisible", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetTransformForOverlayCoordinates(1, 2, DEFAULT_VECTOR2, (void *)4);
+    check_ptr_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", 1);
+    check_uint32_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", 2);
+    check_HmdVector2_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", DEFAULT_VECTOR2);
+    check_ptr_parameter("IVROverlay_020_GetTransformForOverlayCoordinates", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_PollNextOverlayEvent, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_020_PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, VREvent_t * pEvent, uint32_t uncbVREvent) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_PollNextOverlayEvent(1, (void *)2, 3);
+    check_ptr_parameter("IVROverlay_020_PollNextOverlayEvent", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_PollNextOverlayEvent", 1);
+    check_ptr_parameter("IVROverlay_020_PollNextOverlayEvent", (void *)2);
+    check_uint32_parameter("IVROverlay_020_PollNextOverlayEvent", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayInputMethod(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayInputMethod", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayInputMethod", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayInputMethod, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayInputMethod(1, 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayInputMethod", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayInputMethod", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlayInputMethod", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayMouseScale, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayMouseScale(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayMouseScale", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayMouseScale", 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayMouseScale", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_020_ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_ComputeOverlayIntersection(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_ComputeOverlayIntersection", 1);
+    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", (void *)2);
+    check_ptr_parameter("IVROverlay_020_ComputeOverlayIntersection", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_020_IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_IsHoverTargetOverlay(1);
+    check_ptr_parameter("IVROverlay_020_IsHoverTargetOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_IsHoverTargetOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetGamepadFocusOverlay, 0, FALSE, FALSE);
+    VROverlayHandle_t (__stdcall *capi_IVROverlay_020_GetGamepadFocusOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetGamepadFocusOverlay();
+    check_ptr_parameter("IVROverlay_020_GetGamepadFocusOverlay", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetGamepadFocusOverlay, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetGamepadFocusOverlay)(VROverlayHandle_t ulNewFocusOverlay) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetGamepadFocusOverlay(1);
+    check_ptr_parameter("IVROverlay_020_SetGamepadFocusOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetGamepadFocusOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayNeighbor, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayNeighbor(1, 2, 3);
+    check_ptr_parameter("IVROverlay_020_SetOverlayNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_020_SetOverlayNeighbor", 1);
+    check_uint64_parameter("IVROverlay_020_SetOverlayNeighbor", 2);
+    check_uint64_parameter("IVROverlay_020_SetOverlayNeighbor", 3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_MoveGamepadFocusToNeighbor, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_MoveGamepadFocusToNeighbor)(EOverlayDirection eDirection, VROverlayHandle_t ulFrom) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_MoveGamepadFocusToNeighbor(1, 2);
+    check_ptr_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", this_ptr_value);
+    check_uint32_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", 1);
+    check_uint64_parameter("IVROverlay_020_MoveGamepadFocusToNeighbor", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayDualAnalogTransform(1, 2, (void *)3, 4.0f);
+    check_ptr_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 1);
+    check_uint32_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", (void *)3);
+    check_float_parameter("IVROverlay_020_SetOverlayDualAnalogTransform", 4.0f);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayDualAnalogTransform)(VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayDualAnalogTransform(1, 2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", 1);
+    check_uint32_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", 2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayDualAnalogTransform", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayTexture, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayTexture(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayTexture", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_ClearOverlayTexture, 1, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_ClearOverlayTexture(1);
+    check_ptr_parameter("IVROverlay_020_ClearOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_ClearOverlayTexture", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayRaw, 5, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayRaw(1, (void *)2, 3, 4, 5);
+    check_ptr_parameter("IVROverlay_020_SetOverlayRaw", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayRaw", 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayRaw", (void *)2);
+    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 3);
+    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 4);
+    check_uint32_parameter("IVROverlay_020_SetOverlayRaw", 5);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayFromFile, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, const char * pchFilePath) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayFromFile(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_SetOverlayFromFile", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayFromFile", 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayFromFile", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTexture, 9, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_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_020_GetOverlayTexture(1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6, (void *)7, (void *)8, (void *)9);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTexture", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)4);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)5);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)6);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)7);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)8);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTexture", (void *)9);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_ReleaseNativeOverlayHandle(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", 1);
+    check_ptr_parameter("IVROverlay_020_ReleaseNativeOverlayHandle", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayTextureSize, 3, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayTextureSize(1, (void *)2, (void *)3);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayTextureSize", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayTextureSize", (void *)3);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_CreateDashboardOverlay, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_CreateDashboardOverlay)(const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_CreateDashboardOverlay((void *)1, (void *)2, (void *)3, (void *)4);
+    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_020_CreateDashboardOverlay", (void *)4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_IsDashboardVisible, 0, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_020_IsDashboardVisible)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_IsDashboardVisible();
+    check_ptr_parameter("IVROverlay_020_IsDashboardVisible", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    bool (__stdcall *capi_IVROverlay_020_IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_IsActiveDashboardOverlay(1);
+    check_ptr_parameter("IVROverlay_020_IsActiveDashboardOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_IsActiveDashboardOverlay", 1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetDashboardOverlaySceneProcess(1, 2);
+    check_ptr_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", 1);
+    check_uint32_parameter("IVROverlay_020_SetDashboardOverlaySceneProcess", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetDashboardOverlaySceneProcess(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", 1);
+    check_ptr_parameter("IVROverlay_020_GetDashboardOverlaySceneProcess", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_ShowDashboard, 1, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_020_ShowDashboard)(const char * pchOverlayToShow) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_ShowDashboard((void *)1);
+    check_ptr_parameter("IVROverlay_020_ShowDashboard", this_ptr_value);
+    check_ptr_parameter("IVROverlay_020_ShowDashboard", (void *)1);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    TrackedDeviceIndex_t (__stdcall *capi_IVROverlay_020_GetPrimaryDashboardDevice)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetPrimaryDashboardDevice();
+    check_ptr_parameter("IVROverlay_020_GetPrimaryDashboardDevice", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_ShowKeyboard, 7, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_ShowKeyboard(1, 2, (void *)3, 4, (void *)5, 1, 7);
+    check_ptr_parameter("IVROverlay_020_ShowKeyboard", this_ptr_value);
+    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 1);
+    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 2);
+    check_ptr_parameter("IVROverlay_020_ShowKeyboard", (void *)3);
+    check_uint32_parameter("IVROverlay_020_ShowKeyboard", 4);
+    check_ptr_parameter("IVROverlay_020_ShowKeyboard", (void *)5);
+    check_bool_parameter("IVROverlay_020_ShowKeyboard", 1);
+    check_uint64_parameter("IVROverlay_020_ShowKeyboard", 7);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_ShowKeyboardForOverlay(1, 2, 3, (void *)4, 5, (void *)6, 1, 8);
+    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_ShowKeyboardForOverlay", 1);
+    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 2);
+    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 3);
+    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", (void *)4);
+    check_uint32_parameter("IVROverlay_020_ShowKeyboardForOverlay", 5);
+    check_ptr_parameter("IVROverlay_020_ShowKeyboardForOverlay", (void *)6);
+    check_bool_parameter("IVROverlay_020_ShowKeyboardForOverlay", 1);
+    check_uint64_parameter("IVROverlay_020_ShowKeyboardForOverlay", 8);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetKeyboardText, 2, FALSE, FALSE);
+    uint32_t (__stdcall *capi_IVROverlay_020_GetKeyboardText)(char * pchText, uint32_t cchText) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetKeyboardText((void *)1, 2);
+    check_ptr_parameter("IVROverlay_020_GetKeyboardText", this_ptr_value);
+    check_ptr_parameter("IVROverlay_020_GetKeyboardText", (void *)1);
+    check_uint32_parameter("IVROverlay_020_GetKeyboardText", 2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_HideKeyboard, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_020_HideKeyboard)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_HideKeyboard();
+    check_ptr_parameter("IVROverlay_020_HideKeyboard", this_ptr_value);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_020_SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetKeyboardTransformAbsolute(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", this_ptr_value);
+    check_uint32_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", 1);
+    check_ptr_parameter("IVROverlay_020_SetKeyboardTransformAbsolute", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_020_SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetKeyboardPositionForOverlay(1, DEFAULT_RECT);
+    check_ptr_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", 1);
+    check_HmdRect2_parameter("IVROverlay_020_SetKeyboardPositionForOverlay", DEFAULT_RECT);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_SetOverlayIntersectionMask(1, (void *)2, 3, 4);
+    check_ptr_parameter("IVROverlay_020_SetOverlayIntersectionMask", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_SetOverlayIntersectionMask", 1);
+    check_ptr_parameter("IVROverlay_020_SetOverlayIntersectionMask", (void *)2);
+    check_uint32_parameter("IVROverlay_020_SetOverlayIntersectionMask", 3);
+    check_uint32_parameter("IVROverlay_020_SetOverlayIntersectionMask", 4);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_GetOverlayFlags, 2, FALSE, FALSE);
+    EVROverlayError (__stdcall *capi_IVROverlay_020_GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags) = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_GetOverlayFlags(1, (void *)2);
+    check_ptr_parameter("IVROverlay_020_GetOverlayFlags", this_ptr_value);
+    check_uint64_parameter("IVROverlay_020_GetOverlayFlags", 1);
+    check_ptr_parameter("IVROverlay_020_GetOverlayFlags", (void *)2);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_ShowMessageOverlay, 6, FALSE, FALSE);
+    VRMessageOverlayResponse (__stdcall *capi_IVROverlay_020_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_020_ShowMessageOverlay((void *)1, (void *)2, (void *)3, (void *)4, (void *)5, (void *)6);
+    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", this_ptr_value);
+    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)1);
+    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)2);
+    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)3);
+    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)4);
+    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)5);
+    check_ptr_parameter("IVROverlay_020_ShowMessageOverlay", (void *)6);
+
+    init_thunk(t, this_ptr_value, IVROverlay_020_CloseMessageOverlay, 0, FALSE, FALSE);
+    void (__stdcall *capi_IVROverlay_020_CloseMessageOverlay)() = (void *)t;
+
+    clear_parameters();
+    capi_IVROverlay_020_CloseMessageOverlay();
+    check_ptr_parameter("IVROverlay_020_CloseMessageOverlay", this_ptr_value);
+    VirtualFree(t, 0, MEM_RELEASE);
+}
+
 void test_capi_thunks_IVROverlay_019(void)
 {
     struct thunk *t = alloc_thunks(1);
diff --git a/vrclient_x64/tests/main_autogen.c b/vrclient_x64/tests/main_autogen.c
index 3e30ce29..e528c3ea 100644
--- a/vrclient_x64/tests/main_autogen.c
+++ b/vrclient_x64/tests/main_autogen.c
@@ -5,14 +5,14 @@
 
 int main(void)
 {
-    test_capi_thunks_IVRSystem_020();
-    test_capi_thunks_IVRApplications_006();
+    test_capi_thunks_IVRSystem_021();
+    test_capi_thunks_IVRApplications_007();
     test_capi_thunks_IVRSettings_002();
     test_capi_thunks_IVRChaperone_003();
     test_capi_thunks_IVRChaperoneSetup_006();
     test_capi_thunks_IVRCompositor_022();
     test_capi_thunks_IVRNotifications_002();
-    test_capi_thunks_IVROverlay_020();
+    test_capi_thunks_IVROverlay_021();
     test_capi_thunks_IVRRenderModels_006();
     test_capi_thunks_IVRExtendedDisplay_001();
     test_capi_thunks_IVRTrackedCamera_006();
@@ -22,6 +22,9 @@ int main(void)
     test_capi_thunks_IVRInput_007();
     test_capi_thunks_IVRIOBuffer_002();
     test_capi_thunks_IVRClientCore_003();
+    test_capi_thunks_IVRSystem_020();
+    test_capi_thunks_IVRApplications_006();
+    test_capi_thunks_IVROverlay_020();
     test_capi_thunks_IVROverlay_019();
     test_capi_thunks_IVRTrackedCamera_005();
     test_capi_thunks_IVRSystem_019();
diff --git a/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp b/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp
new file mode 100644
index 00000000..f2d93b3b
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.cpp
@@ -0,0 +1,164 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRApplications_IVRApplications_007.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_AddApplicationManifest(void *linux_side, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    return ((IVRApplications*)linux_side)->AddApplicationManifest((const char *)pchApplicationManifestFullPath, (bool)bTemporary);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_RemoveApplicationManifest(void *linux_side, const char * pchApplicationManifestFullPath)
+{
+    return ((IVRApplications*)linux_side)->RemoveApplicationManifest((const char *)pchApplicationManifestFullPath);
+}
+
+bool cppIVRApplications_IVRApplications_007_IsApplicationInstalled(void *linux_side, const char * pchAppKey)
+{
+    return ((IVRApplications*)linux_side)->IsApplicationInstalled((const char *)pchAppKey);
+}
+
+uint32_t cppIVRApplications_IVRApplications_007_GetApplicationCount(void *linux_side)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationCount();
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_GetApplicationKeyByIndex(void *linux_side, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationKeyByIndex((uint32_t)unApplicationIndex, (char *)pchAppKeyBuffer, (uint32_t)unAppKeyBufferLen);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_GetApplicationKeyByProcessId(void *linux_side, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationKeyByProcessId((uint32_t)unProcessId, (char *)pchAppKeyBuffer, (uint32_t)unAppKeyBufferLen);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchApplication(void *linux_side, const char * pchAppKey)
+{
+    return ((IVRApplications*)linux_side)->LaunchApplication((const char *)pchAppKey);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchTemplateApplication(void *linux_side, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys)
+{
+    return ((IVRApplications*)linux_side)->LaunchTemplateApplication((const char *)pchTemplateAppKey, (const char *)pchNewAppKey, (const vr::AppOverrideKeys_t *)pKeys, (uint32_t)unKeys);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchApplicationFromMimeType(void *linux_side, const char * pchMimeType, const char * pchArgs)
+{
+    return ((IVRApplications*)linux_side)->LaunchApplicationFromMimeType((const char *)pchMimeType, (const char *)pchArgs);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchDashboardOverlay(void *linux_side, const char * pchAppKey)
+{
+    return ((IVRApplications*)linux_side)->LaunchDashboardOverlay((const char *)pchAppKey);
+}
+
+bool cppIVRApplications_IVRApplications_007_CancelApplicationLaunch(void *linux_side, const char * pchAppKey)
+{
+    return ((IVRApplications*)linux_side)->CancelApplicationLaunch((const char *)pchAppKey);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_IdentifyApplication(void *linux_side, uint32_t unProcessId, const char * pchAppKey)
+{
+    return ((IVRApplications*)linux_side)->IdentifyApplication((uint32_t)unProcessId, (const char *)pchAppKey);
+}
+
+uint32_t cppIVRApplications_IVRApplications_007_GetApplicationProcessId(void *linux_side, const char * pchAppKey)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationProcessId((const char *)pchAppKey);
+}
+
+const char * cppIVRApplications_IVRApplications_007_GetApplicationsErrorNameFromEnum(void *linux_side, EVRApplicationError error)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationsErrorNameFromEnum((vr::EVRApplicationError)error);
+}
+
+uint32_t cppIVRApplications_IVRApplications_007_GetApplicationPropertyString(void *linux_side, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationPropertyString((const char *)pchAppKey, (vr::EVRApplicationProperty)eProperty, (char *)pchPropertyValueBuffer, (uint32_t)unPropertyValueBufferLen, (vr::EVRApplicationError *)peError);
+}
+
+bool cppIVRApplications_IVRApplications_007_GetApplicationPropertyBool(void *linux_side, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationPropertyBool((const char *)pchAppKey, (vr::EVRApplicationProperty)eProperty, (vr::EVRApplicationError *)peError);
+}
+
+uint64_t cppIVRApplications_IVRApplications_007_GetApplicationPropertyUint64(void *linux_side, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationPropertyUint64((const char *)pchAppKey, (vr::EVRApplicationProperty)eProperty, (vr::EVRApplicationError *)peError);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_SetApplicationAutoLaunch(void *linux_side, const char * pchAppKey, bool bAutoLaunch)
+{
+    return ((IVRApplications*)linux_side)->SetApplicationAutoLaunch((const char *)pchAppKey, (bool)bAutoLaunch);
+}
+
+bool cppIVRApplications_IVRApplications_007_GetApplicationAutoLaunch(void *linux_side, const char * pchAppKey)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationAutoLaunch((const char *)pchAppKey);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_SetDefaultApplicationForMimeType(void *linux_side, const char * pchAppKey, const char * pchMimeType)
+{
+    return ((IVRApplications*)linux_side)->SetDefaultApplicationForMimeType((const char *)pchAppKey, (const char *)pchMimeType);
+}
+
+bool cppIVRApplications_IVRApplications_007_GetDefaultApplicationForMimeType(void *linux_side, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    return ((IVRApplications*)linux_side)->GetDefaultApplicationForMimeType((const char *)pchMimeType, (char *)pchAppKeyBuffer, (uint32_t)unAppKeyBufferLen);
+}
+
+bool cppIVRApplications_IVRApplications_007_GetApplicationSupportedMimeTypes(void *linux_side, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationSupportedMimeTypes((const char *)pchAppKey, (char *)pchMimeTypesBuffer, (uint32_t)unMimeTypesBuffer);
+}
+
+uint32_t cppIVRApplications_IVRApplications_007_GetApplicationsThatSupportMimeType(void *linux_side, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationsThatSupportMimeType((const char *)pchMimeType, (char *)pchAppKeysThatSupportBuffer, (uint32_t)unAppKeysThatSupportBuffer);
+}
+
+uint32_t cppIVRApplications_IVRApplications_007_GetApplicationLaunchArguments(void *linux_side, uint32_t unHandle, char * pchArgs, uint32_t unArgs)
+{
+    return ((IVRApplications*)linux_side)->GetApplicationLaunchArguments((uint32_t)unHandle, (char *)pchArgs, (uint32_t)unArgs);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_GetStartingApplication(void *linux_side, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    return ((IVRApplications*)linux_side)->GetStartingApplication((char *)pchAppKeyBuffer, (uint32_t)unAppKeyBufferLen);
+}
+
+vr::EVRSceneApplicationState cppIVRApplications_IVRApplications_007_GetSceneApplicationState(void *linux_side)
+{
+    return ((IVRApplications*)linux_side)->GetSceneApplicationState();
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_PerformApplicationPrelaunchCheck(void *linux_side, const char * pchAppKey)
+{
+    return ((IVRApplications*)linux_side)->PerformApplicationPrelaunchCheck((const char *)pchAppKey);
+}
+
+const char * cppIVRApplications_IVRApplications_007_GetSceneApplicationStateNameFromEnum(void *linux_side, EVRSceneApplicationState state)
+{
+    return ((IVRApplications*)linux_side)->GetSceneApplicationStateNameFromEnum((vr::EVRSceneApplicationState)state);
+}
+
+vr::EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchInternalProcess(void *linux_side, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
+{
+    return ((IVRApplications*)linux_side)->LaunchInternalProcess((const char *)pchBinaryPath, (const char *)pchArguments, (const char *)pchWorkingDirectory);
+}
+
+uint32_t cppIVRApplications_IVRApplications_007_GetCurrentSceneProcessId(void *linux_side)
+{
+    return ((IVRApplications*)linux_side)->GetCurrentSceneProcessId();
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.h b/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.h
new file mode 100644
index 00000000..58a9e8bd
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVRApplications_IVRApplications_007.h
@@ -0,0 +1,36 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_AddApplicationManifest(void *, const char *, bool);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_RemoveApplicationManifest(void *, const char *);
+extern bool cppIVRApplications_IVRApplications_007_IsApplicationInstalled(void *, const char *);
+extern uint32_t cppIVRApplications_IVRApplications_007_GetApplicationCount(void *);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_GetApplicationKeyByIndex(void *, uint32_t, char *, uint32_t);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_GetApplicationKeyByProcessId(void *, uint32_t, char *, uint32_t);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchApplication(void *, const char *);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchTemplateApplication(void *, const char *, const char *, AppOverrideKeys_t *, uint32_t);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchApplicationFromMimeType(void *, const char *, const char *);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchDashboardOverlay(void *, const char *);
+extern bool cppIVRApplications_IVRApplications_007_CancelApplicationLaunch(void *, const char *);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_IdentifyApplication(void *, uint32_t, const char *);
+extern uint32_t cppIVRApplications_IVRApplications_007_GetApplicationProcessId(void *, const char *);
+extern const char * cppIVRApplications_IVRApplications_007_GetApplicationsErrorNameFromEnum(void *, EVRApplicationError);
+extern uint32_t cppIVRApplications_IVRApplications_007_GetApplicationPropertyString(void *, const char *, EVRApplicationProperty, char *, uint32_t, EVRApplicationError *);
+extern bool cppIVRApplications_IVRApplications_007_GetApplicationPropertyBool(void *, const char *, EVRApplicationProperty, EVRApplicationError *);
+extern uint64_t cppIVRApplications_IVRApplications_007_GetApplicationPropertyUint64(void *, const char *, EVRApplicationProperty, EVRApplicationError *);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_SetApplicationAutoLaunch(void *, const char *, bool);
+extern bool cppIVRApplications_IVRApplications_007_GetApplicationAutoLaunch(void *, const char *);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_SetDefaultApplicationForMimeType(void *, const char *, const char *);
+extern bool cppIVRApplications_IVRApplications_007_GetDefaultApplicationForMimeType(void *, const char *, char *, uint32_t);
+extern bool cppIVRApplications_IVRApplications_007_GetApplicationSupportedMimeTypes(void *, const char *, char *, uint32_t);
+extern uint32_t cppIVRApplications_IVRApplications_007_GetApplicationsThatSupportMimeType(void *, const char *, char *, uint32_t);
+extern uint32_t cppIVRApplications_IVRApplications_007_GetApplicationLaunchArguments(void *, uint32_t, char *, uint32_t);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_GetStartingApplication(void *, char *, uint32_t);
+extern EVRSceneApplicationState cppIVRApplications_IVRApplications_007_GetSceneApplicationState(void *);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_PerformApplicationPrelaunchCheck(void *, const char *);
+extern const char * cppIVRApplications_IVRApplications_007_GetSceneApplicationStateNameFromEnum(void *, EVRSceneApplicationState);
+extern EVRApplicationError cppIVRApplications_IVRApplications_007_LaunchInternalProcess(void *, const char *, const char *, const char *);
+extern uint32_t cppIVRApplications_IVRApplications_007_GetCurrentSceneProcessId(void *);
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp b/vrclient_x64/vrclient_x64/cppIVRChaperoneSetup_IVRChaperoneSetup_006.cpp
index d5019ba1..bd211454 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp b/vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp
index a84518d5..e682d768 100644
--- a/vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRChaperone_IVRChaperone_003.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/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 2473e073..2da439c0 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_022.cpp b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_022.cpp
index 7f267065..29919215 100644
--- a/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_022.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRCompositor_IVRCompositor_022.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp b/vrclient_x64/vrclient_x64/cppIVRDriverManager_IVRDriverManager_001.cpp
index 3145e814..69568e5c 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/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 63f1085f..c8115c00 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/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 d66c7cb6..fd221b40 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp
index c1586420..0511954a 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
@@ -34,63 +34,63 @@ vr::EVRInputError cppIVRInput_IVRInput_007_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_007_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1715 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *linux_side, VRActionHandle_t action, winInputDigitalActionData_t_1819 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputDigitalActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputDigitalActionData_t_1715_win_to_lin(pActionData, &lin);
+        struct_InputDigitalActionData_t_1819_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_1715_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputDigitalActionData_t_1819_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1715 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *linux_side, VRActionHandle_t action, winInputAnalogActionData_t_1819 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputAnalogActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputAnalogActionData_t_1715_win_to_lin(pActionData, &lin);
+        struct_InputAnalogActionData_t_1819_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_1715_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputAnalogActionData_t_1819_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1715 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1819 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputPoseActionData_t_1715_win_to_lin(pActionData, &lin);
+        struct_InputPoseActionData_t_1819_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_1715_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputPoseActionData_t_1819_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1715 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *linux_side, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1819 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     InputPoseActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputPoseActionData_t_1715_win_to_lin(pActionData, &lin);
+        struct_InputPoseActionData_t_1819_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_1715_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputPoseActionData_t_1819_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
-vr::EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1715 * pActionData, uint32_t unActionDataSize)
+vr::EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *linux_side, VRActionHandle_t action, winInputSkeletalActionData_t_1819 * pActionData, uint32_t unActionDataSize)
 {
     InputSkeletalActionData_t lin;
     vr::EVRInputError _ret;
     if(pActionData)
-        struct_InputSkeletalActionData_t_1715_win_to_lin(pActionData, &lin);
+        struct_InputSkeletalActionData_t_1819_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_1715_lin_to_win(&lin, pActionData, unActionDataSize);
+        struct_InputSkeletalActionData_t_1819_lin_to_win(&lin, pActionData, unActionDataSize);
     return _ret;
 }
 
@@ -179,6 +179,11 @@ bool cppIVRInput_IVRInput_007_IsUsingLegacyInput(void *linux_side)
     return ((IVRInput*)linux_side)->IsUsingLegacyInput();
 }
 
+vr::EVRInputError cppIVRInput_IVRInput_007_OpenBindingUI(void *linux_side, const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop)
+{
+    return ((IVRInput*)linux_side)->OpenBindingUI((const char *)pchAppKey, (vr::VRActionSetHandle_t)ulActionSetHandle, (vr::VRInputValueHandle_t)ulDeviceHandle, (bool)bShowOnDesktop);
+}
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h
index 32a83011..eff20017 100644
--- a/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h
+++ b/vrclient_x64/vrclient_x64/cppIVRInput_IVRInput_007.h
@@ -6,11 +6,11 @@ extern EVRInputError cppIVRInput_IVRInput_007_GetActionSetHandle(void *, const c
 extern EVRInputError cppIVRInput_IVRInput_007_GetActionHandle(void *, const char *, VRActionHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_007_GetInputSourceHandle(void *, const char *, VRInputValueHandle_t *);
 extern EVRInputError cppIVRInput_IVRInput_007_UpdateActionState(void *, VRActiveActionSet_t *, uint32_t, uint32_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1715 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1715 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1715 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1715 *, uint32_t, VRInputValueHandle_t);
-extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1715 *, uint32_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetDigitalActionData(void *, VRActionHandle_t, winInputDigitalActionData_t_1819 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetAnalogActionData(void *, VRActionHandle_t, winInputAnalogActionData_t_1819 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(void *, VRActionHandle_t, ETrackingUniverseOrigin, float, winInputPoseActionData_t_1819 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(void *, VRActionHandle_t, ETrackingUniverseOrigin, winInputPoseActionData_t_1819 *, uint32_t, VRInputValueHandle_t);
+extern EVRInputError cppIVRInput_IVRInput_007_GetSkeletalActionData(void *, VRActionHandle_t, winInputSkeletalActionData_t_1819 *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_007_GetBoneCount(void *, VRActionHandle_t, uint32_t *);
 extern EVRInputError cppIVRInput_IVRInput_007_GetBoneHierarchy(void *, VRActionHandle_t, BoneIndex_t *, uint32_t);
 extern EVRInputError cppIVRInput_IVRInput_007_GetBoneName(void *, VRActionHandle_t, BoneIndex_t, char *, uint32_t);
@@ -28,6 +28,7 @@ extern EVRInputError cppIVRInput_IVRInput_007_GetActionBindingInfo(void *, VRAct
 extern EVRInputError cppIVRInput_IVRInput_007_ShowActionOrigins(void *, VRActionSetHandle_t, VRActionHandle_t);
 extern EVRInputError cppIVRInput_IVRInput_007_ShowBindingsForActionSet(void *, VRActiveActionSet_t *, uint32_t, uint32_t, VRInputValueHandle_t);
 extern bool cppIVRInput_IVRInput_007_IsUsingLegacyInput(void *);
+extern EVRInputError cppIVRInput_IVRInput_007_OpenBindingUI(void *, const char *, VRActionSetHandle_t, VRInputValueHandle_t, bool);
 #ifdef __cplusplus
 }
 #endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp b/vrclient_x64/vrclient_x64/cppIVRNotifications_IVRNotifications_002.cpp
index c7ddb492..919cafd1 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_021.cpp b/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_021.cpp
new file mode 100644
index 00000000..dfad5148
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_021.cpp
@@ -0,0 +1,401 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVROverlay_IVROverlay_021.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_DestroyOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->DestroyOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+uint32_t cppIVROverlay_IVROverlay_021_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_021_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_021_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_021_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_021_GetOverlayErrorNameFromEnum(void *linux_side, EVROverlayError error)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayErrorNameFromEnum((vr::EVROverlayError)error);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_GetOverlayRenderingPid(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayRenderingPid((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_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_021_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_021_SetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float)fAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayAlpha(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayAlpha((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfAlpha);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float)fTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTexelAspect(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTexelAspect((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfTexelAspect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_SetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float)fWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayWidthInMeters(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayWidthInMeters((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfWidthInMeters);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float)fCurvature);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayCurvature(void *linux_side, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayCurvature((vr::VROverlayHandle_t)ulOverlayHandle, (float *)pfCurvature);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_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_021_GetOverlayTextureBounds(void *linux_side, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayTextureBounds((vr::VROverlayHandle_t)ulOverlayHandle, (vr::VRTextureBounds_t *)pOverlayTextureBounds);
+}
+
+uint32_t cppIVROverlay_IVROverlay_021_GetOverlayRenderModel(void *linux_side, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayRenderModel((vr::VROverlayHandle_t)ulOverlayHandle, (char *)pchValue, (uint32_t)unBufferSize, (vr::HmdColor_t *)pColor, (vr::EVROverlayError *)pError);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayRenderModel(void *linux_side, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayRenderModel((vr::VROverlayHandle_t)ulOverlayHandle, (const char *)pchRenderModel, (const vr::HmdColor_t *)pColor);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_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_021_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_021_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_021_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_021_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_021_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_021_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_021_ShowOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ShowOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_HideOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->HideOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+bool cppIVROverlay_IVROverlay_021_IsOverlayVisible(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsOverlayVisible((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_PollNextOverlayEvent(void *linux_side, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1819 * pEvent, uint32_t uncbVREvent)
+{
+    VREvent_t lin;
+    bool _ret;
+    if(pEvent)
+        struct_VREvent_t_1819_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_1819_lin_to_win(&lin, pEvent, uncbVREvent);
+    return _ret;
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_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_021_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_021_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_021_IsHoverTargetOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsHoverTargetOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayDualAnalogTransform(void *linux_side, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayDualAnalogTransform((vr::VROverlayHandle_t)ulOverlay, (vr::EDualAnalogWhich)eWhich, (const vr::HmdVector2_t *)pvCenter, (float)fRadius);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayDualAnalogTransform(void *linux_side, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayDualAnalogTransform((vr::VROverlayHandle_t)ulOverlay, (vr::EDualAnalogWhich)eWhich, (vr::HmdVector2_t *)pvCenter, (float *)pfRadius);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_ClearOverlayTexture(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->ClearOverlayTexture((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayRaw(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    return ((IVROverlay*)linux_side)->SetOverlayRaw((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pvBuffer, (uint32_t)unWidth, (uint32_t)unHeight, (uint32_t)unDepth);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_ReleaseNativeOverlayHandle(void *linux_side, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    return ((IVROverlay*)linux_side)->ReleaseNativeOverlayHandle((vr::VROverlayHandle_t)ulOverlayHandle, (void *)pNativeTextureHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_IsDashboardVisible(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->IsDashboardVisible();
+}
+
+bool cppIVROverlay_IVROverlay_021_IsActiveDashboardOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle)
+{
+    return ((IVROverlay*)linux_side)->IsActiveDashboardOverlay((vr::VROverlayHandle_t)ulOverlayHandle);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_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_021_ShowDashboard(void *linux_side, const char * pchOverlayToShow)
+{
+    ((IVROverlay*)linux_side)->ShowDashboard((const char *)pchOverlayToShow);
+}
+
+vr::TrackedDeviceIndex_t cppIVROverlay_IVROverlay_021_GetPrimaryDashboardDevice(void *linux_side)
+{
+    return ((IVROverlay*)linux_side)->GetPrimaryDashboardDevice();
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_ShowKeyboard(void *linux_side, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    return ((IVROverlay*)linux_side)->ShowKeyboard((vr::EGamepadTextInputMode)eInputMode, (vr::EGamepadTextInputLineMode)eLineInputMode, (const char *)pchDescription, (uint32_t)unCharMax, (const char *)pchExistingText, (bool)bUseMinimalMode, (uint64_t)uUserValue);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_ShowKeyboardForOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    return ((IVROverlay*)linux_side)->ShowKeyboardForOverlay((vr::VROverlayHandle_t)ulOverlayHandle, (vr::EGamepadTextInputMode)eInputMode, (vr::EGamepadTextInputLineMode)eLineInputMode, (const char *)pchDescription, (uint32_t)unCharMax, (const char *)pchExistingText, (bool)bUseMinimalMode, (uint64_t)uUserValue);
+}
+
+uint32_t cppIVROverlay_IVROverlay_021_GetKeyboardText(void *linux_side, char * pchText, uint32_t cchText)
+{
+    return ((IVROverlay*)linux_side)->GetKeyboardText((char *)pchText, (uint32_t)cchText);
+}
+
+void cppIVROverlay_IVROverlay_021_HideKeyboard(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->HideKeyboard();
+}
+
+void cppIVROverlay_IVROverlay_021_SetKeyboardTransformAbsolute(void *linux_side, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    ((IVROverlay*)linux_side)->SetKeyboardTransformAbsolute((vr::ETrackingUniverseOrigin)eTrackingOrigin, (const vr::HmdMatrix34_t *)pmatTrackingOriginToKeyboardTransform);
+}
+
+void cppIVROverlay_IVROverlay_021_SetKeyboardPositionForOverlay(void *linux_side, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    ((IVROverlay*)linux_side)->SetKeyboardPositionForOverlay((vr::VROverlayHandle_t)ulOverlayHandle, (vr::HmdRect2_t)avoidRect);
+}
+
+vr::EVROverlayError cppIVROverlay_IVROverlay_021_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_021_GetOverlayFlags(void *linux_side, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    return ((IVROverlay*)linux_side)->GetOverlayFlags((vr::VROverlayHandle_t)ulOverlayHandle, (uint32_t *)pFlags);
+}
+
+vr::VRMessageOverlayResponse cppIVROverlay_IVROverlay_021_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_021_CloseMessageOverlay(void *linux_side)
+{
+    ((IVROverlay*)linux_side)->CloseMessageOverlay();
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_021.h b/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_021.h
new file mode 100644
index 00000000..eca36c74
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVROverlay_IVROverlay_021.h
@@ -0,0 +1,82 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern EVROverlayError cppIVROverlay_IVROverlay_021_FindOverlay(void *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_CreateOverlay(void *, const char *, const char *, VROverlayHandle_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_DestroyOverlay(void *, VROverlayHandle_t);
+extern uint32_t cppIVROverlay_IVROverlay_021_GetOverlayKey(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern uint32_t cppIVROverlay_IVROverlay_021_GetOverlayName(void *, VROverlayHandle_t, char *, uint32_t, EVROverlayError *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayName(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayImageData(void *, VROverlayHandle_t, void *, uint32_t, uint32_t *, uint32_t *);
+extern const char * cppIVROverlay_IVROverlay_021_GetOverlayErrorNameFromEnum(void *, EVROverlayError);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayRenderingPid(void *, VROverlayHandle_t, uint32_t);
+extern uint32_t cppIVROverlay_IVROverlay_021_GetOverlayRenderingPid(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayFlag(void *, VROverlayHandle_t, VROverlayFlags, bool *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayColor(void *, VROverlayHandle_t, float, float, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayColor(void *, VROverlayHandle_t, float *, float *, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayAlpha(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayAlpha(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTexelAspect(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTexelAspect(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlaySortOrder(void *, VROverlayHandle_t, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayWidthInMeters(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayWidthInMeters(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayCurvature(void *, VROverlayHandle_t, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayCurvature(void *, VROverlayHandle_t, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTextureColorSpace(void *, VROverlayHandle_t, EColorSpace *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTextureBounds(void *, VROverlayHandle_t, VRTextureBounds_t *);
+extern uint32_t cppIVROverlay_IVROverlay_021_GetOverlayRenderModel(void *, VROverlayHandle_t, char *, uint32_t, HmdColor_t *, EVROverlayError *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayRenderModel(void *, VROverlayHandle_t, const char *, HmdColor_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTransformType(void *, VROverlayHandle_t, VROverlayTransformType *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTransformAbsolute(void *, VROverlayHandle_t, ETrackingUniverseOrigin *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent(void *, VROverlayHandle_t, TrackedDeviceIndex_t *, char *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t *, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTransformOverlayRelative(void *, VROverlayHandle_t, VROverlayHandle_t, HmdMatrix34_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_ShowOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_HideOverlay(void *, VROverlayHandle_t);
+extern bool cppIVROverlay_IVROverlay_021_IsOverlayVisible(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetTransformForOverlayCoordinates(void *, VROverlayHandle_t, ETrackingUniverseOrigin, HmdVector2_t, HmdMatrix34_t *);
+extern bool cppIVROverlay_IVROverlay_021_PollNextOverlayEvent(void *, VROverlayHandle_t, winVREvent_t_1819 *, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayInputMethod(void *, VROverlayHandle_t, VROverlayInputMethod);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayMouseScale(void *, VROverlayHandle_t, HmdVector2_t *);
+extern bool cppIVROverlay_IVROverlay_021_ComputeOverlayIntersection(void *, VROverlayHandle_t, VROverlayIntersectionParams_t *, VROverlayIntersectionResults_t *);
+extern bool cppIVROverlay_IVROverlay_021_IsHoverTargetOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayDualAnalogTransform(void *, VROverlayHandle_t, EDualAnalogWhich, HmdVector2_t *, float);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayDualAnalogTransform(void *, VROverlayHandle_t, EDualAnalogWhich, HmdVector2_t *, float *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayTexture(void *, VROverlayHandle_t, Texture_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_ClearOverlayTexture(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayRaw(void *, VROverlayHandle_t, void *, uint32_t, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayFromFile(void *, VROverlayHandle_t, const char *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTexture(void *, VROverlayHandle_t, void **, void *, uint32_t *, uint32_t *, uint32_t *, ETextureType *, EColorSpace *, VRTextureBounds_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_ReleaseNativeOverlayHandle(void *, VROverlayHandle_t, void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayTextureSize(void *, VROverlayHandle_t, uint32_t *, uint32_t *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_CreateDashboardOverlay(void *, const char *, const char *, VROverlayHandle_t *, VROverlayHandle_t *);
+extern bool cppIVROverlay_IVROverlay_021_IsDashboardVisible(void *);
+extern bool cppIVROverlay_IVROverlay_021_IsActiveDashboardOverlay(void *, VROverlayHandle_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetDashboardOverlaySceneProcess(void *, VROverlayHandle_t, uint32_t *);
+extern void cppIVROverlay_IVROverlay_021_ShowDashboard(void *, const char *);
+extern TrackedDeviceIndex_t cppIVROverlay_IVROverlay_021_GetPrimaryDashboardDevice(void *);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_ShowKeyboard(void *, EGamepadTextInputMode, EGamepadTextInputLineMode, const char *, uint32_t, const char *, bool, uint64_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_ShowKeyboardForOverlay(void *, VROverlayHandle_t, EGamepadTextInputMode, EGamepadTextInputLineMode, const char *, uint32_t, const char *, bool, uint64_t);
+extern uint32_t cppIVROverlay_IVROverlay_021_GetKeyboardText(void *, char *, uint32_t);
+extern void cppIVROverlay_IVROverlay_021_HideKeyboard(void *);
+extern void cppIVROverlay_IVROverlay_021_SetKeyboardTransformAbsolute(void *, ETrackingUniverseOrigin, HmdMatrix34_t *);
+extern void cppIVROverlay_IVROverlay_021_SetKeyboardPositionForOverlay(void *, VROverlayHandle_t, HmdRect2_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_SetOverlayIntersectionMask(void *, VROverlayHandle_t, VROverlayIntersectionMaskPrimitive_t *, uint32_t, uint32_t);
+extern EVROverlayError cppIVROverlay_IVROverlay_021_GetOverlayFlags(void *, VROverlayHandle_t, uint32_t *);
+extern VRMessageOverlayResponse cppIVROverlay_IVROverlay_021_ShowMessageOverlay(void *, const char *, const char *, const char *, const char *, const char *, const char *);
+extern void cppIVROverlay_IVROverlay_021_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 7f69dc43..fe3007d3 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/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_1715 ** ppRenderModel)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *linux_side, const char * pchRenderModelName, winRenderModel_t_1819 ** 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_1715_wrap(lin);
+        *ppRenderModel = struct_RenderModel_t_1819_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1715 * pRenderModel)
+void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *linux_side, winRenderModel_t_1819 * pRenderModel)
 {
-    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1715_unwrap(pRenderModel));
+    ((IVRRenderModels*)linux_side)->FreeRenderModel(struct_RenderModel_t_1819_unwrap(pRenderModel));
 }
 
-vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1715 ** ppTexture)
+vr::EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *linux_side, TextureID_t textureId, winRenderModel_TextureMap_t_1819 ** 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_1715_wrap(lin);
+        *ppTexture = struct_RenderModel_TextureMap_t_1819_wrap(lin);
     return _ret;
 }
 
-void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1715 * pTexture)
+void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *linux_side, winRenderModel_TextureMap_t_1819 * pTexture)
 {
-    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1715_unwrap(pTexture));
+    ((IVRRenderModels*)linux_side)->FreeTexture(struct_RenderModel_TextureMap_t_1819_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_1715_win_to_lin(pControllerState, &lin);
+        struct_VRControllerState001_t_1819_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 1dc21525..2bb0c7fb 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_1715 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1715 *);
-extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1715 **);
-extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1715 *);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(void *, const char *, winRenderModel_t_1819 **);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeRenderModel(void *, winRenderModel_t_1819 *);
+extern EVRRenderModelError cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(void *, TextureID_t, winRenderModel_TextureMap_t_1819 **);
+extern void cppIVRRenderModels_IVRRenderModels_006_FreeTexture(void *, winRenderModel_TextureMap_t_1819 *);
 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 4a4417a1..576ea06e 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/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 2b51e082..0332fa0c 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_002.cpp b/vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_002.cpp
index 3231fe88..344b143c 100644
--- a/vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_002.cpp
+++ b/vrclient_x64/vrclient_x64/cppIVRSettings_IVRSettings_002.cpp
@@ -1,6 +1,6 @@
 #include "vrclient_private.h"
 #include "vrclient_defs.h"
-#include "openvr_v1.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
 using namespace vr;
 extern "C" {
 #include "struct_converters.h"
diff --git a/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.cpp b/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.cpp
new file mode 100644
index 00000000..c9e7c581
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.cpp
@@ -0,0 +1,277 @@
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.8.19/ivrclientcore.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+}
+#include "cppIVRSystem_IVRSystem_021.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+void cppIVRSystem_IVRSystem_021_GetRecommendedRenderTargetSize(void *linux_side, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    ((IVRSystem*)linux_side)->GetRecommendedRenderTargetSize((uint32_t *)pnWidth, (uint32_t *)pnHeight);
+}
+
+vr::HmdMatrix44_t cppIVRSystem_IVRSystem_021_GetProjectionMatrix(void *linux_side, EVREye eEye, float fNearZ, float fFarZ)
+{
+    return ((IVRSystem*)linux_side)->GetProjectionMatrix((vr::EVREye)eEye, (float)fNearZ, (float)fFarZ);
+}
+
+void cppIVRSystem_IVRSystem_021_GetProjectionRaw(void *linux_side, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    ((IVRSystem*)linux_side)->GetProjectionRaw((vr::EVREye)eEye, (float *)pfLeft, (float *)pfRight, (float *)pfTop, (float *)pfBottom);
+}
+
+bool cppIVRSystem_IVRSystem_021_ComputeDistortion(void *linux_side, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    return ((IVRSystem*)linux_side)->ComputeDistortion((vr::EVREye)eEye, (float)fU, (float)fV, (vr::DistortionCoordinates_t *)pDistortionCoordinates);
+}
+
+vr::HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetEyeToHeadTransform(void *linux_side, EVREye eEye)
+{
+    return ((IVRSystem*)linux_side)->GetEyeToHeadTransform((vr::EVREye)eEye);
+}
+
+bool cppIVRSystem_IVRSystem_021_GetTimeSinceLastVsync(void *linux_side, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    return ((IVRSystem*)linux_side)->GetTimeSinceLastVsync((float *)pfSecondsSinceLastVsync, (uint64_t *)pulFrameCounter);
+}
+
+int32_t cppIVRSystem_IVRSystem_021_GetD3D9AdapterIndex(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->GetD3D9AdapterIndex();
+}
+
+void cppIVRSystem_IVRSystem_021_GetDXGIOutputInfo(void *linux_side, int32_t * pnAdapterIndex)
+{
+    ((IVRSystem*)linux_side)->GetDXGIOutputInfo((int32_t *)pnAdapterIndex);
+}
+
+void cppIVRSystem_IVRSystem_021_GetOutputDevice(void *linux_side, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
+{
+    ((IVRSystem*)linux_side)->GetOutputDevice((uint64_t *)pnDevice, (vr::ETextureType)textureType, (VkInstance_T *)pInstance);
+}
+
+bool cppIVRSystem_IVRSystem_021_IsDisplayOnDesktop(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->IsDisplayOnDesktop();
+}
+
+bool cppIVRSystem_IVRSystem_021_SetDisplayVisibility(void *linux_side, bool bIsVisibleOnDesktop)
+{
+    return ((IVRSystem*)linux_side)->SetDisplayVisibility((bool)bIsVisibleOnDesktop);
+}
+
+void cppIVRSystem_IVRSystem_021_GetDeviceToAbsoluteTrackingPose(void *linux_side, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    ((IVRSystem*)linux_side)->GetDeviceToAbsoluteTrackingPose((vr::ETrackingUniverseOrigin)eOrigin, (float)fPredictedSecondsToPhotonsFromNow, (vr::TrackedDevicePose_t *)pTrackedDevicePoseArray, (uint32_t)unTrackedDevicePoseArrayCount);
+}
+
+void cppIVRSystem_IVRSystem_021_ResetSeatedZeroPose(void *linux_side)
+{
+    ((IVRSystem*)linux_side)->ResetSeatedZeroPose();
+}
+
+vr::HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->GetSeatedZeroPoseToStandingAbsoluteTrackingPose();
+}
+
+vr::HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->GetRawZeroPoseToStandingAbsoluteTrackingPose();
+}
+
+uint32_t cppIVRSystem_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass(void *linux_side, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->GetSortedTrackedDeviceIndicesOfClass((vr::ETrackedDeviceClass)eTrackedDeviceClass, (vr::TrackedDeviceIndex_t *)punTrackedDeviceIndexArray, (uint32_t)unTrackedDeviceIndexArrayCount, (vr::TrackedDeviceIndex_t)unRelativeToTrackedDeviceIndex);
+}
+
+vr::EDeviceActivityLevel cppIVRSystem_IVRSystem_021_GetTrackedDeviceActivityLevel(void *linux_side, TrackedDeviceIndex_t unDeviceId)
+{
+    return ((IVRSystem*)linux_side)->GetTrackedDeviceActivityLevel((vr::TrackedDeviceIndex_t)unDeviceId);
+}
+
+void cppIVRSystem_IVRSystem_021_ApplyTransform(void *linux_side, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    ((IVRSystem*)linux_side)->ApplyTransform((vr::TrackedDevicePose_t *)pOutputPose, (const vr::TrackedDevicePose_t *)pTrackedDevicePose, (const vr::HmdMatrix34_t *)pTransform);
+}
+
+vr::TrackedDeviceIndex_t cppIVRSystem_IVRSystem_021_GetTrackedDeviceIndexForControllerRole(void *linux_side, ETrackedControllerRole unDeviceType)
+{
+    return ((IVRSystem*)linux_side)->GetTrackedDeviceIndexForControllerRole((vr::ETrackedControllerRole)unDeviceType);
+}
+
+vr::ETrackedControllerRole cppIVRSystem_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->GetControllerRoleForTrackedDeviceIndex((vr::TrackedDeviceIndex_t)unDeviceIndex);
+}
+
+vr::ETrackedDeviceClass cppIVRSystem_IVRSystem_021_GetTrackedDeviceClass(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->GetTrackedDeviceClass((vr::TrackedDeviceIndex_t)unDeviceIndex);
+}
+
+bool cppIVRSystem_IVRSystem_021_IsTrackedDeviceConnected(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->IsTrackedDeviceConnected((vr::TrackedDeviceIndex_t)unDeviceIndex);
+}
+
+bool cppIVRSystem_IVRSystem_021_GetBoolTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetBoolTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+float cppIVRSystem_IVRSystem_021_GetFloatTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetFloatTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+int32_t cppIVRSystem_IVRSystem_021_GetInt32TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetInt32TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+uint64_t cppIVRSystem_IVRSystem_021_GetUint64TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetUint64TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+vr::HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetMatrix34TrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetMatrix34TrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::ETrackedPropertyError *)pError);
+}
+
+uint32_t cppIVRSystem_IVRSystem_021_GetArrayTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetArrayTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (vr::PropertyTypeTag_t)propType, (void *)pBuffer, (uint32_t)unBufferSize, (vr::ETrackedPropertyError *)pError);
+}
+
+uint32_t cppIVRSystem_IVRSystem_021_GetStringTrackedDeviceProperty(void *linux_side, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    return ((IVRSystem*)linux_side)->GetStringTrackedDeviceProperty((vr::TrackedDeviceIndex_t)unDeviceIndex, (vr::ETrackedDeviceProperty)prop, (char *)pchValue, (uint32_t)unBufferSize, (vr::ETrackedPropertyError *)pError);
+}
+
+const char * cppIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(void *linux_side, ETrackedPropertyError error)
+{
+    return ((IVRSystem*)linux_side)->GetPropErrorNameFromEnum((vr::ETrackedPropertyError)error);
+}
+
+bool cppIVRSystem_IVRSystem_021_PollNextEvent(void *linux_side, winVREvent_t_1819 * pEvent, uint32_t uncbVREvent)
+{
+    VREvent_t lin;
+    bool _ret;
+    if(pEvent)
+        struct_VREvent_t_1819_win_to_lin(pEvent, &lin);
+    _ret = ((IVRSystem*)linux_side)->PollNextEvent(pEvent ? &lin : nullptr, uncbVREvent ? sizeof(lin) : 0);
+    if(pEvent)
+        struct_VREvent_t_1819_lin_to_win(&lin, pEvent, uncbVREvent);
+    return _ret;
+}
+
+bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, winVREvent_t_1819 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    VREvent_t lin;
+    bool _ret;
+    if(pEvent)
+        struct_VREvent_t_1819_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_1819_lin_to_win(&lin, pEvent, uncbVREvent);
+    return _ret;
+}
+
+const char * cppIVRSystem_IVRSystem_021_GetEventTypeNameFromEnum(void *linux_side, EVREventType eType)
+{
+    return ((IVRSystem*)linux_side)->GetEventTypeNameFromEnum((vr::EVREventType)eType);
+}
+
+vr::HiddenAreaMesh_t cppIVRSystem_IVRSystem_021_GetHiddenAreaMesh(void *linux_side, EVREye eEye, EHiddenAreaMeshType type)
+{
+    return ((IVRSystem*)linux_side)->GetHiddenAreaMesh((vr::EVREye)eEye, (vr::EHiddenAreaMeshType)type);
+}
+
+bool cppIVRSystem_IVRSystem_021_GetControllerState(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1819 * pControllerState, uint32_t unControllerStateSize)
+{
+    VRControllerState001_t lin;
+    bool _ret;
+    if(pControllerState)
+        struct_VRControllerState001_t_1819_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_1819_lin_to_win(&lin, pControllerState, unControllerStateSize);
+    return _ret;
+}
+
+bool cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(void *linux_side, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1819 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    VRControllerState001_t lin;
+    bool _ret;
+    if(pControllerState)
+        struct_VRControllerState001_t_1819_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_1819_lin_to_win(&lin, pControllerState, unControllerStateSize);
+    return _ret;
+}
+
+void cppIVRSystem_IVRSystem_021_TriggerHapticPulse(void *linux_side, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    ((IVRSystem*)linux_side)->TriggerHapticPulse((vr::TrackedDeviceIndex_t)unControllerDeviceIndex, (uint32_t)unAxisId, (unsigned short)usDurationMicroSec);
+}
+
+const char * cppIVRSystem_IVRSystem_021_GetButtonIdNameFromEnum(void *linux_side, EVRButtonId eButtonId)
+{
+    return ((IVRSystem*)linux_side)->GetButtonIdNameFromEnum((vr::EVRButtonId)eButtonId);
+}
+
+const char * cppIVRSystem_IVRSystem_021_GetControllerAxisTypeNameFromEnum(void *linux_side, EVRControllerAxisType eAxisType)
+{
+    return ((IVRSystem*)linux_side)->GetControllerAxisTypeNameFromEnum((vr::EVRControllerAxisType)eAxisType);
+}
+
+bool cppIVRSystem_IVRSystem_021_IsInputAvailable(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->IsInputAvailable();
+}
+
+bool cppIVRSystem_IVRSystem_021_IsSteamVRDrawingControllers(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->IsSteamVRDrawingControllers();
+}
+
+bool cppIVRSystem_IVRSystem_021_ShouldApplicationPause(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->ShouldApplicationPause();
+}
+
+bool cppIVRSystem_IVRSystem_021_ShouldApplicationReduceRenderingWork(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->ShouldApplicationReduceRenderingWork();
+}
+
+vr::EVRFirmwareError cppIVRSystem_IVRSystem_021_PerformFirmwareUpdate(void *linux_side, TrackedDeviceIndex_t unDeviceIndex)
+{
+    return ((IVRSystem*)linux_side)->PerformFirmwareUpdate((vr::TrackedDeviceIndex_t)unDeviceIndex);
+}
+
+void cppIVRSystem_IVRSystem_021_AcknowledgeQuit_Exiting(void *linux_side)
+{
+    ((IVRSystem*)linux_side)->AcknowledgeQuit_Exiting();
+}
+
+uint32_t cppIVRSystem_IVRSystem_021_GetAppContainerFilePaths(void *linux_side, char * pchBuffer, uint32_t unBufferSize)
+{
+    return ((IVRSystem*)linux_side)->GetAppContainerFilePaths((char *)pchBuffer, (uint32_t)unBufferSize);
+}
+
+const char * cppIVRSystem_IVRSystem_021_GetRuntimeVersion(void *linux_side)
+{
+    return ((IVRSystem*)linux_side)->GetRuntimeVersion();
+}
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.h b/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.h
new file mode 100644
index 00000000..4fdff35e
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/cppIVRSystem_IVRSystem_021.h
@@ -0,0 +1,53 @@
+#ifdef __cplusplus
+extern "C" {
+#endif
+extern void cppIVRSystem_IVRSystem_021_GetRecommendedRenderTargetSize(void *, uint32_t *, uint32_t *);
+extern HmdMatrix44_t cppIVRSystem_IVRSystem_021_GetProjectionMatrix(void *, EVREye, float, float);
+extern void cppIVRSystem_IVRSystem_021_GetProjectionRaw(void *, EVREye, float *, float *, float *, float *);
+extern bool cppIVRSystem_IVRSystem_021_ComputeDistortion(void *, EVREye, float, float, DistortionCoordinates_t *);
+extern HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetEyeToHeadTransform(void *, EVREye);
+extern bool cppIVRSystem_IVRSystem_021_GetTimeSinceLastVsync(void *, float *, uint64_t *);
+extern int32_t cppIVRSystem_IVRSystem_021_GetD3D9AdapterIndex(void *);
+extern void cppIVRSystem_IVRSystem_021_GetDXGIOutputInfo(void *, int32_t *);
+extern void cppIVRSystem_IVRSystem_021_GetOutputDevice(void *, uint64_t *, ETextureType, VkInstance_T *);
+extern bool cppIVRSystem_IVRSystem_021_IsDisplayOnDesktop(void *);
+extern bool cppIVRSystem_IVRSystem_021_SetDisplayVisibility(void *, bool);
+extern void cppIVRSystem_IVRSystem_021_GetDeviceToAbsoluteTrackingPose(void *, ETrackingUniverseOrigin, float, TrackedDevicePose_t *, uint32_t);
+extern void cppIVRSystem_IVRSystem_021_ResetSeatedZeroPose(void *);
+extern HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(void *);
+extern HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose(void *);
+extern uint32_t cppIVRSystem_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass(void *, ETrackedDeviceClass, TrackedDeviceIndex_t *, uint32_t, TrackedDeviceIndex_t);
+extern EDeviceActivityLevel cppIVRSystem_IVRSystem_021_GetTrackedDeviceActivityLevel(void *, TrackedDeviceIndex_t);
+extern void cppIVRSystem_IVRSystem_021_ApplyTransform(void *, TrackedDevicePose_t *, TrackedDevicePose_t *, HmdMatrix34_t *);
+extern TrackedDeviceIndex_t cppIVRSystem_IVRSystem_021_GetTrackedDeviceIndexForControllerRole(void *, ETrackedControllerRole);
+extern ETrackedControllerRole cppIVRSystem_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex(void *, TrackedDeviceIndex_t);
+extern ETrackedDeviceClass cppIVRSystem_IVRSystem_021_GetTrackedDeviceClass(void *, TrackedDeviceIndex_t);
+extern bool cppIVRSystem_IVRSystem_021_IsTrackedDeviceConnected(void *, TrackedDeviceIndex_t);
+extern bool cppIVRSystem_IVRSystem_021_GetBoolTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern float cppIVRSystem_IVRSystem_021_GetFloatTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern int32_t cppIVRSystem_IVRSystem_021_GetInt32TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern uint64_t cppIVRSystem_IVRSystem_021_GetUint64TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern HmdMatrix34_t cppIVRSystem_IVRSystem_021_GetMatrix34TrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, ETrackedPropertyError *);
+extern uint32_t cppIVRSystem_IVRSystem_021_GetArrayTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, PropertyTypeTag_t, void *, uint32_t, ETrackedPropertyError *);
+extern uint32_t cppIVRSystem_IVRSystem_021_GetStringTrackedDeviceProperty(void *, TrackedDeviceIndex_t, ETrackedDeviceProperty, char *, uint32_t, ETrackedPropertyError *);
+extern const char * cppIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(void *, ETrackedPropertyError);
+extern bool cppIVRSystem_IVRSystem_021_PollNextEvent(void *, winVREvent_t_1819 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_021_PollNextEventWithPose(void *, ETrackingUniverseOrigin, winVREvent_t_1819 *, uint32_t, TrackedDevicePose_t *);
+extern const char * cppIVRSystem_IVRSystem_021_GetEventTypeNameFromEnum(void *, EVREventType);
+extern HiddenAreaMesh_t cppIVRSystem_IVRSystem_021_GetHiddenAreaMesh(void *, EVREye, EHiddenAreaMeshType);
+extern bool cppIVRSystem_IVRSystem_021_GetControllerState(void *, TrackedDeviceIndex_t, winVRControllerState001_t_1819 *, uint32_t);
+extern bool cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(void *, ETrackingUniverseOrigin, TrackedDeviceIndex_t, winVRControllerState001_t_1819 *, uint32_t, TrackedDevicePose_t *);
+extern void cppIVRSystem_IVRSystem_021_TriggerHapticPulse(void *, TrackedDeviceIndex_t, uint32_t, unsigned short);
+extern const char * cppIVRSystem_IVRSystem_021_GetButtonIdNameFromEnum(void *, EVRButtonId);
+extern const char * cppIVRSystem_IVRSystem_021_GetControllerAxisTypeNameFromEnum(void *, EVRControllerAxisType);
+extern bool cppIVRSystem_IVRSystem_021_IsInputAvailable(void *);
+extern bool cppIVRSystem_IVRSystem_021_IsSteamVRDrawingControllers(void *);
+extern bool cppIVRSystem_IVRSystem_021_ShouldApplicationPause(void *);
+extern bool cppIVRSystem_IVRSystem_021_ShouldApplicationReduceRenderingWork(void *);
+extern EVRFirmwareError cppIVRSystem_IVRSystem_021_PerformFirmwareUpdate(void *, TrackedDeviceIndex_t);
+extern void cppIVRSystem_IVRSystem_021_AcknowledgeQuit_Exiting(void *);
+extern uint32_t cppIVRSystem_IVRSystem_021_GetAppContainerFilePaths(void *, char *, uint32_t);
+extern const char * cppIVRSystem_IVRSystem_021_GetRuntimeVersion(void *);
+#ifdef __cplusplus
+}
+#endif
diff --git a/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp b/vrclient_x64/vrclient_x64/cppIVRTrackedCamera_IVRTrackedCamera_006.cpp
index 1d0f9be6..33be3c11 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.7.15/ivrclientcore.h"
+#include "openvr_v1.8.19/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_1715 * 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_1819 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1715_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1819_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_1715_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1819_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_1715 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, winCameraVideoStreamFrameHeader_t_1819 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1715_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1819_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_1715_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1819_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_1715 * pFrameHeader, uint32_t nFrameHeaderSize)
+vr::EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *linux_side, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1819 * pFrameHeader, uint32_t nFrameHeaderSize)
 {
     CameraVideoStreamFrameHeader_t lin;
     vr::EVRTrackedCameraError _ret;
     if(pFrameHeader)
-        struct_CameraVideoStreamFrameHeader_t_1715_win_to_lin(pFrameHeader, &lin);
+        struct_CameraVideoStreamFrameHeader_t_1819_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_1715_lin_to_win(&lin, pFrameHeader, nFrameHeaderSize);
+        struct_CameraVideoStreamFrameHeader_t_1819_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 56f110a5..b5d402f2 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_1715 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamFrameBuffer(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, uint32_t, winCameraVideoStreamFrameHeader_t_1819 *, 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_1715 *, uint32_t);
-extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1715 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureD3D11(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, void *, void **, winCameraVideoStreamFrameHeader_t_1819 *, uint32_t);
+extern EVRTrackedCameraError cppIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(void *, TrackedCameraHandle_t, EVRTrackedCameraFrameType, glUInt_t *, winCameraVideoStreamFrameHeader_t_1819 *, 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 391801ee..63ffc97b 100644
--- a/vrclient_x64/vrclient_x64/struct_converters.h
+++ b/vrclient_x64/vrclient_x64/struct_converters.h
@@ -1,3 +1,34 @@
+typedef struct winVREvent_t_1819 winVREvent_t_1819;
+extern void struct_VREvent_t_1819_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_VREvent_t_1819_win_to_lin(void *w, void *l);
+typedef struct winVRControllerState001_t_1819 winVRControllerState001_t_1819;
+extern void struct_VRControllerState001_t_1819_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_VRControllerState001_t_1819_win_to_lin(void *w, void *l);
+typedef struct winCameraVideoStreamFrameHeader_t_1819 winCameraVideoStreamFrameHeader_t_1819;
+extern void struct_CameraVideoStreamFrameHeader_t_1819_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_CameraVideoStreamFrameHeader_t_1819_win_to_lin(void *w, void *l);
+typedef struct winRenderModel_TextureMap_t_1819 winRenderModel_TextureMap_t_1819;
+extern void struct_RenderModel_TextureMap_t_1819_lin_to_win(void *l, void *w);
+extern void struct_RenderModel_TextureMap_t_1819_win_to_lin(void *w, void *l);
+extern struct winRenderModel_TextureMap_t_1819 *struct_RenderModel_TextureMap_t_1819_wrap(void *l);
+extern RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1819_unwrap(winRenderModel_TextureMap_t_1819 *w);
+typedef struct winRenderModel_t_1819 winRenderModel_t_1819;
+extern void struct_RenderModel_t_1819_lin_to_win(void *l, void *w);
+extern void struct_RenderModel_t_1819_win_to_lin(void *w, void *l);
+extern struct winRenderModel_t_1819 *struct_RenderModel_t_1819_wrap(void *l);
+extern RenderModel_t *struct_RenderModel_t_1819_unwrap(winRenderModel_t_1819 *w);
+typedef struct winInputAnalogActionData_t_1819 winInputAnalogActionData_t_1819;
+extern void struct_InputAnalogActionData_t_1819_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputAnalogActionData_t_1819_win_to_lin(void *w, void *l);
+typedef struct winInputDigitalActionData_t_1819 winInputDigitalActionData_t_1819;
+extern void struct_InputDigitalActionData_t_1819_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputDigitalActionData_t_1819_win_to_lin(void *w, void *l);
+typedef struct winInputPoseActionData_t_1819 winInputPoseActionData_t_1819;
+extern void struct_InputPoseActionData_t_1819_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputPoseActionData_t_1819_win_to_lin(void *w, void *l);
+typedef struct winInputSkeletalActionData_t_1819 winInputSkeletalActionData_t_1819;
+extern void struct_InputSkeletalActionData_t_1819_lin_to_win(void *l, void *w, uint32_t sz);
+extern void struct_InputSkeletalActionData_t_1819_win_to_lin(void *w, void *l);
 typedef struct winVREvent_t_1715 winVREvent_t_1715;
 extern void struct_VREvent_t_1715_lin_to_win(void *l, void *w, uint32_t sz);
 extern void struct_VREvent_t_1715_win_to_lin(void *w, void *l);
diff --git a/vrclient_x64/vrclient_x64/struct_converters_1819.cpp b/vrclient_x64/vrclient_x64/struct_converters_1819.cpp
new file mode 100644
index 00000000..a585b460
--- /dev/null
+++ b/vrclient_x64/vrclient_x64/struct_converters_1819.cpp
@@ -0,0 +1,331 @@
+#include <stdlib.h>
+#include <string.h>
+#include "vrclient_private.h"
+#include "vrclient_defs.h"
+#include "openvr_v1.8.19/openvr.h"
+using namespace vr;
+extern "C" {
+#include "struct_converters.h"
+#pragma pack(push, 8)
+struct winVREvent_t_1819 {
+    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_1819_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winVREvent_t_1819 *win = (struct winVREvent_t_1819 *)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_1819_win_to_lin(void *w, void *l)
+{
+    struct winVREvent_t_1819 *win = (struct winVREvent_t_1819 *)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_1819 {
+    uint32_t unPacketNum;
+    uint64_t ulButtonPressed;
+    uint64_t ulButtonTouched;
+    vr::VRControllerAxis_t rAxis[5];
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_VRControllerState001_t_1819_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winVRControllerState001_t_1819 *win = (struct winVRControllerState001_t_1819 *)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_1819_win_to_lin(void *w, void *l)
+{
+    struct winVRControllerState001_t_1819 *win = (struct winVRControllerState001_t_1819 *)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_1819 {
+    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_1819_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winCameraVideoStreamFrameHeader_t_1819 *win = (struct winCameraVideoStreamFrameHeader_t_1819 *)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_1819_win_to_lin(void *w, void *l)
+{
+    struct winCameraVideoStreamFrameHeader_t_1819 *win = (struct winCameraVideoStreamFrameHeader_t_1819 *)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_1819 {
+    uint16_t unWidth;
+    uint16_t unHeight;
+    const uint8_t * rubTextureMapData;
+
+    RenderModel_TextureMap_t *linux_side;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_RenderModel_TextureMap_t_1819_lin_to_win(void *l, void *w)
+{
+    struct winRenderModel_TextureMap_t_1819 *win = (struct winRenderModel_TextureMap_t_1819 *)w;
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    win->unWidth = lin->unWidth;
+    win->unHeight = lin->unHeight;
+    win->rubTextureMapData = lin->rubTextureMapData;
+}
+
+void struct_RenderModel_TextureMap_t_1819_win_to_lin(void *w, void *l)
+{
+    struct winRenderModel_TextureMap_t_1819 *win = (struct winRenderModel_TextureMap_t_1819 *)w;
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    lin->unWidth = win->unWidth;
+    lin->unHeight = win->unHeight;
+    lin->rubTextureMapData = win->rubTextureMapData;
+}
+
+struct winRenderModel_TextureMap_t_1819 *struct_RenderModel_TextureMap_t_1819_wrap(void *l)
+{
+    struct winRenderModel_TextureMap_t_1819 *win = (struct winRenderModel_TextureMap_t_1819 *)malloc(sizeof(*win));
+    RenderModel_TextureMap_t *lin = (RenderModel_TextureMap_t *)l;
+    win->unWidth = lin->unWidth;
+    win->unHeight = lin->unHeight;
+    win->rubTextureMapData = lin->rubTextureMapData;
+    win->linux_side = lin;
+    return win;
+}
+
+struct RenderModel_TextureMap_t *struct_RenderModel_TextureMap_t_1819_unwrap(winRenderModel_TextureMap_t_1819 *w)
+{
+    RenderModel_TextureMap_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winRenderModel_t_1819 {
+    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_1819_lin_to_win(void *l, void *w)
+{
+    struct winRenderModel_t_1819 *win = (struct winRenderModel_t_1819 *)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_1819_win_to_lin(void *w, void *l)
+{
+    struct winRenderModel_t_1819 *win = (struct winRenderModel_t_1819 *)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_1819 *struct_RenderModel_t_1819_wrap(void *l)
+{
+    struct winRenderModel_t_1819 *win = (struct winRenderModel_t_1819 *)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_1819_unwrap(winRenderModel_t_1819 *w)
+{
+    RenderModel_t *ret = w->linux_side;
+    free(w);
+    return ret;
+}
+
+#pragma pack(push, 8)
+struct winInputAnalogActionData_t_1819 {
+    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_1819_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputAnalogActionData_t_1819 *win = (struct winInputAnalogActionData_t_1819 *)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_1819_win_to_lin(void *w, void *l)
+{
+    struct winInputAnalogActionData_t_1819 *win = (struct winInputAnalogActionData_t_1819 *)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_1819 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    bool bState;
+    bool bChanged;
+    float fUpdateTime;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputDigitalActionData_t_1819_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputDigitalActionData_t_1819 *win = (struct winInputDigitalActionData_t_1819 *)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_1819_win_to_lin(void *w, void *l)
+{
+    struct winInputDigitalActionData_t_1819 *win = (struct winInputDigitalActionData_t_1819 *)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_1819 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+    vr::TrackedDevicePose_t pose __attribute__((aligned(4)));
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputPoseActionData_t_1819_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputPoseActionData_t_1819 *win = (struct winInputPoseActionData_t_1819 *)w;
+    InputPoseActionData_t *lin = (InputPoseActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+    win->pose = lin->pose;
+}
+
+void struct_InputPoseActionData_t_1819_win_to_lin(void *w, void *l)
+{
+    struct winInputPoseActionData_t_1819 *win = (struct winInputPoseActionData_t_1819 *)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_1819 {
+    bool bActive;
+    vr::VRInputValueHandle_t activeOrigin;
+}  __attribute__ ((ms_struct));
+#pragma pack(pop)
+
+void struct_InputSkeletalActionData_t_1819_lin_to_win(void *l, void *w, uint32_t sz)
+{
+    struct winInputSkeletalActionData_t_1819 *win = (struct winInputSkeletalActionData_t_1819 *)w;
+    InputSkeletalActionData_t *lin = (InputSkeletalActionData_t *)l;
+    win->bActive = lin->bActive;
+    win->activeOrigin = lin->activeOrigin;
+}
+
+void struct_InputSkeletalActionData_t_1819_win_to_lin(void *w, void *l)
+{
+    struct winInputSkeletalActionData_t_1819 *win = (struct winInputSkeletalActionData_t_1819 *)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 2eb599b0..8d89cabb 100644
--- a/vrclient_x64/vrclient_x64/vrclient_defs.h
+++ b/vrclient_x64/vrclient_x64/vrclient_defs.h
@@ -65,7 +65,8 @@ typedef int
         EVRSkeletalMotionRange,
         EVRSkeletalReferencePose,
         EVRSkeletalTrackingLevel,
-        EVRSummaryType;
+        EVRSummaryType,
+        EVRSceneApplicationState;
 
 typedef uint32_t DriverId_t;
 typedef uint32_t TrackedDeviceIndex_t;
diff --git a/vrclient_x64/vrclient_x64/vrclient_main.c b/vrclient_x64/vrclient_x64/vrclient_main.c
index 857159dd..e42a1b3c 100644
--- a/vrclient_x64/vrclient_x64/vrclient_main.c
+++ b/vrclient_x64/vrclient_x64/vrclient_main.c
@@ -39,8 +39,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_1715 winRenderModel_t_1715;
-typedef struct winRenderModel_TextureMap_t_1715 winRenderModel_TextureMap_t_1715;
+typedef struct winRenderModel_t_1819 winRenderModel_t_1819;
+typedef struct winRenderModel_TextureMap_t_1819 winRenderModel_TextureMap_t_1819;
 #include "cppIVRRenderModels_IVRRenderModels_006.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
@@ -1113,7 +1113,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_1715 **)texture_map);
+        return cppIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(linux_side, texture_id, (struct winRenderModel_TextureMap_t_1819 **)texture_map);
     }
     FIXME("Unsupported IVRRenderModels version! %u\n", version);
     return VRRenderModelError_NotSupported;
@@ -1130,7 +1130,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_1715 *)texture_map);
+        cppIVRRenderModels_IVRRenderModels_006_FreeTexture(linux_side, (struct winRenderModel_TextureMap_t_1819 *)texture_map);
         break;
     default:
         FIXME("Unsupported IVRRenderModels version! %u\n", version);
diff --git a/vrclient_x64/vrclient_x64/winIVRApplications.c b/vrclient_x64/vrclient_x64/winIVRApplications.c
index 3f192b95..5ab4e422 100644
--- a/vrclient_x64/vrclient_x64/winIVRApplications.c
+++ b/vrclient_x64/vrclient_x64/winIVRApplications.c
@@ -18,6 +18,337 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRApplications_IVRApplications_007.h"
+
+typedef struct __winIVRApplications_IVRApplications_007 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRApplications_IVRApplications_007;
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_AddApplicationManifest, 9)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_AddApplicationManifest(winIVRApplications_IVRApplications_007 *_this, const char * pchApplicationManifestFullPath, bool bTemporary)
+{
+    char lin_pchApplicationManifestFullPath[PATH_MAX];
+    vrclient_dos_path_to_unix_path(pchApplicationManifestFullPath, lin_pchApplicationManifestFullPath);
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_AddApplicationManifest(_this->linux_side, pchApplicationManifestFullPath ? lin_pchApplicationManifestFullPath : NULL, bTemporary);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_RemoveApplicationManifest, 8)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_RemoveApplicationManifest(winIVRApplications_IVRApplications_007 *_this, const char * pchApplicationManifestFullPath)
+{
+    char lin_pchApplicationManifestFullPath[PATH_MAX];
+    vrclient_dos_path_to_unix_path(pchApplicationManifestFullPath, lin_pchApplicationManifestFullPath);
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_RemoveApplicationManifest(_this->linux_side, pchApplicationManifestFullPath ? lin_pchApplicationManifestFullPath : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_IsApplicationInstalled, 8)
+bool __thiscall winIVRApplications_IVRApplications_007_IsApplicationInstalled(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_IsApplicationInstalled(_this->linux_side, pchAppKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationCount, 4)
+uint32_t __thiscall winIVRApplications_IVRApplications_007_GetApplicationCount(winIVRApplications_IVRApplications_007 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationCount(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationKeyByIndex, 16)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_GetApplicationKeyByIndex(winIVRApplications_IVRApplications_007 *_this, uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationKeyByIndex(_this->linux_side, unApplicationIndex, pchAppKeyBuffer, unAppKeyBufferLen);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationKeyByProcessId, 16)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_GetApplicationKeyByProcessId(winIVRApplications_IVRApplications_007 *_this, uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationKeyByProcessId(_this->linux_side, unProcessId, pchAppKeyBuffer, unAppKeyBufferLen);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_LaunchApplication, 8)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_LaunchApplication(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_LaunchApplication(_this->linux_side, pchAppKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_LaunchTemplateApplication, 20)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_LaunchTemplateApplication(winIVRApplications_IVRApplications_007 *_this, const char * pchTemplateAppKey, const char * pchNewAppKey, AppOverrideKeys_t * pKeys, uint32_t unKeys)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_LaunchTemplateApplication(_this->linux_side, pchTemplateAppKey, pchNewAppKey, pKeys, unKeys);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_LaunchApplicationFromMimeType, 12)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_LaunchApplicationFromMimeType(winIVRApplications_IVRApplications_007 *_this, const char * pchMimeType, const char * pchArgs)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_LaunchApplicationFromMimeType(_this->linux_side, pchMimeType, pchArgs);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_LaunchDashboardOverlay, 8)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_LaunchDashboardOverlay(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_LaunchDashboardOverlay(_this->linux_side, pchAppKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_CancelApplicationLaunch, 8)
+bool __thiscall winIVRApplications_IVRApplications_007_CancelApplicationLaunch(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_CancelApplicationLaunch(_this->linux_side, pchAppKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_IdentifyApplication, 12)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_IdentifyApplication(winIVRApplications_IVRApplications_007 *_this, uint32_t unProcessId, const char * pchAppKey)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_IdentifyApplication(_this->linux_side, unProcessId, pchAppKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationProcessId, 8)
+uint32_t __thiscall winIVRApplications_IVRApplications_007_GetApplicationProcessId(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationProcessId(_this->linux_side, pchAppKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationsErrorNameFromEnum, 8)
+const char * __thiscall winIVRApplications_IVRApplications_007_GetApplicationsErrorNameFromEnum(winIVRApplications_IVRApplications_007 *_this, EVRApplicationError error)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationsErrorNameFromEnum(_this->linux_side, error);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationPropertyString, 24)
+uint32_t __thiscall winIVRApplications_IVRApplications_007_GetApplicationPropertyString(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationPropertyString(_this->linux_side, pchAppKey, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen, peError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationPropertyBool, 16)
+bool __thiscall winIVRApplications_IVRApplications_007_GetApplicationPropertyBool(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationPropertyBool(_this->linux_side, pchAppKey, eProperty, peError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationPropertyUint64, 16)
+uint64_t __thiscall winIVRApplications_IVRApplications_007_GetApplicationPropertyUint64(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationPropertyUint64(_this->linux_side, pchAppKey, eProperty, peError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_SetApplicationAutoLaunch, 9)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_SetApplicationAutoLaunch(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey, bool bAutoLaunch)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_SetApplicationAutoLaunch(_this->linux_side, pchAppKey, bAutoLaunch);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationAutoLaunch, 8)
+bool __thiscall winIVRApplications_IVRApplications_007_GetApplicationAutoLaunch(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationAutoLaunch(_this->linux_side, pchAppKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_SetDefaultApplicationForMimeType, 12)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_SetDefaultApplicationForMimeType(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey, const char * pchMimeType)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_SetDefaultApplicationForMimeType(_this->linux_side, pchAppKey, pchMimeType);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetDefaultApplicationForMimeType, 16)
+bool __thiscall winIVRApplications_IVRApplications_007_GetDefaultApplicationForMimeType(winIVRApplications_IVRApplications_007 *_this, const char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetDefaultApplicationForMimeType(_this->linux_side, pchMimeType, pchAppKeyBuffer, unAppKeyBufferLen);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationSupportedMimeTypes, 16)
+bool __thiscall winIVRApplications_IVRApplications_007_GetApplicationSupportedMimeTypes(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationSupportedMimeTypes(_this->linux_side, pchAppKey, pchMimeTypesBuffer, unMimeTypesBuffer);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationsThatSupportMimeType, 16)
+uint32_t __thiscall winIVRApplications_IVRApplications_007_GetApplicationsThatSupportMimeType(winIVRApplications_IVRApplications_007 *_this, const char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationsThatSupportMimeType(_this->linux_side, pchMimeType, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetApplicationLaunchArguments, 16)
+uint32_t __thiscall winIVRApplications_IVRApplications_007_GetApplicationLaunchArguments(winIVRApplications_IVRApplications_007 *_this, uint32_t unHandle, char * pchArgs, uint32_t unArgs)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetApplicationLaunchArguments(_this->linux_side, unHandle, pchArgs, unArgs);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetStartingApplication, 12)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_GetStartingApplication(winIVRApplications_IVRApplications_007 *_this, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetStartingApplication(_this->linux_side, pchAppKeyBuffer, unAppKeyBufferLen);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetSceneApplicationState, 4)
+EVRSceneApplicationState __thiscall winIVRApplications_IVRApplications_007_GetSceneApplicationState(winIVRApplications_IVRApplications_007 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetSceneApplicationState(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_PerformApplicationPrelaunchCheck, 8)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_PerformApplicationPrelaunchCheck(winIVRApplications_IVRApplications_007 *_this, const char * pchAppKey)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_PerformApplicationPrelaunchCheck(_this->linux_side, pchAppKey);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetSceneApplicationStateNameFromEnum, 8)
+const char * __thiscall winIVRApplications_IVRApplications_007_GetSceneApplicationStateNameFromEnum(winIVRApplications_IVRApplications_007 *_this, EVRSceneApplicationState state)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetSceneApplicationStateNameFromEnum(_this->linux_side, state);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_LaunchInternalProcess, 16)
+EVRApplicationError __thiscall winIVRApplications_IVRApplications_007_LaunchInternalProcess(winIVRApplications_IVRApplications_007 *_this, const char * pchBinaryPath, const char * pchArguments, const char * pchWorkingDirectory)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_LaunchInternalProcess(_this->linux_side, pchBinaryPath, pchArguments, pchWorkingDirectory);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRApplications_IVRApplications_007_GetCurrentSceneProcessId, 4)
+uint32_t __thiscall winIVRApplications_IVRApplications_007_GetCurrentSceneProcessId(winIVRApplications_IVRApplications_007 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRApplications_IVRApplications_007_GetCurrentSceneProcessId(_this->linux_side);
+}
+
+extern vtable_ptr winIVRApplications_IVRApplications_007_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRApplications_IVRApplications_007,
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_AddApplicationManifest)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_RemoveApplicationManifest)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_IsApplicationInstalled)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationCount)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationKeyByIndex)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationKeyByProcessId)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_LaunchApplication)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_LaunchTemplateApplication)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_LaunchApplicationFromMimeType)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_LaunchDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_CancelApplicationLaunch)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_IdentifyApplication)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationProcessId)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationsErrorNameFromEnum)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationPropertyString)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationPropertyBool)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationPropertyUint64)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_SetApplicationAutoLaunch)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationAutoLaunch)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_SetDefaultApplicationForMimeType)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetDefaultApplicationForMimeType)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationSupportedMimeTypes)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationsThatSupportMimeType)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetApplicationLaunchArguments)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetStartingApplication)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetSceneApplicationState)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_PerformApplicationPrelaunchCheck)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetSceneApplicationStateNameFromEnum)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_LaunchInternalProcess)
+        VTABLE_ADD_FUNC(winIVRApplications_IVRApplications_007_GetCurrentSceneProcessId)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRApplications_IVRApplications_007 *create_winIVRApplications_IVRApplications_007(void *linux_side)
+{
+    winIVRApplications_IVRApplications_007 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRApplications_IVRApplications_007));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRApplications_IVRApplications_007_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRApplications_IVRApplications_007(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRApplications_IVRApplications_007 *create_winIVRApplications_IVRApplications_007_FnTable(void *linux_side)
+{
+    winIVRApplications_IVRApplications_007 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRApplications_IVRApplications_007));
+    struct thunk *thunks = alloc_thunks(30);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 30 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRApplications_IVRApplications_007_AddApplicationManifest, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRApplications_IVRApplications_007_RemoveApplicationManifest, 1, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVRApplications_IVRApplications_007_IsApplicationInstalled, 1, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRApplications_IVRApplications_007_GetApplicationCount, 0, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVRApplications_IVRApplications_007_GetApplicationKeyByIndex, 3, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRApplications_IVRApplications_007_GetApplicationKeyByProcessId, 3, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRApplications_IVRApplications_007_LaunchApplication, 1, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRApplications_IVRApplications_007_LaunchTemplateApplication, 4, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVRApplications_IVRApplications_007_LaunchApplicationFromMimeType, 2, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRApplications_IVRApplications_007_LaunchDashboardOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRApplications_IVRApplications_007_CancelApplicationLaunch, 1, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRApplications_IVRApplications_007_IdentifyApplication, 2, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVRApplications_IVRApplications_007_GetApplicationProcessId, 1, FALSE, FALSE);
+    init_thunk(&thunks[13], r, winIVRApplications_IVRApplications_007_GetApplicationsErrorNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVRApplications_IVRApplications_007_GetApplicationPropertyString, 5, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVRApplications_IVRApplications_007_GetApplicationPropertyBool, 3, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRApplications_IVRApplications_007_GetApplicationPropertyUint64, 3, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRApplications_IVRApplications_007_SetApplicationAutoLaunch, 2, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVRApplications_IVRApplications_007_GetApplicationAutoLaunch, 1, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVRApplications_IVRApplications_007_SetDefaultApplicationForMimeType, 2, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVRApplications_IVRApplications_007_GetDefaultApplicationForMimeType, 3, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVRApplications_IVRApplications_007_GetApplicationSupportedMimeTypes, 3, FALSE, FALSE);
+    init_thunk(&thunks[22], r, winIVRApplications_IVRApplications_007_GetApplicationsThatSupportMimeType, 3, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVRApplications_IVRApplications_007_GetApplicationLaunchArguments, 3, FALSE, FALSE);
+    init_thunk(&thunks[24], r, winIVRApplications_IVRApplications_007_GetStartingApplication, 2, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVRApplications_IVRApplications_007_GetSceneApplicationState, 0, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVRApplications_IVRApplications_007_PerformApplicationPrelaunchCheck, 1, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVRApplications_IVRApplications_007_GetSceneApplicationStateNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVRApplications_IVRApplications_007_LaunchInternalProcess, 3, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVRApplications_IVRApplications_007_GetCurrentSceneProcessId, 0, FALSE, FALSE);
+    for (i = 0; i < 30; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRApplications_IVRApplications_007_FnTable(void *object)
+{
+    winIVRApplications_IVRApplications_007 *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 "cppIVRApplications_IVRApplications_006.h"
 
 typedef struct __winIVRApplications_IVRApplications_006 {
diff --git a/vrclient_x64/vrclient_x64/winIVRInput.c b/vrclient_x64/vrclient_x64/winIVRInput.c
index 2b6493cf..f5c2ccdf 100644
--- a/vrclient_x64/vrclient_x64/winIVRInput.c
+++ b/vrclient_x64/vrclient_x64/winIVRInput.c
@@ -63,35 +63,35 @@ EVRInputError __thiscall winIVRInput_IVRInput_007_UpdateActionState(winIVRInput_
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetDigitalActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetDigitalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1715 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetDigitalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputDigitalActionData_t_1819 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetDigitalActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetAnalogActionData, 28)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetAnalogActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1715 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetAnalogActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputAnalogActionData_t_1819 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetAnalogActionData(_this->linux_side, action, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow, 36)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1715 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, winInputPoseActionData_t_1819 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetPoseActionDataRelativeToNow(_this->linux_side, action, eOrigin, fPredictedSecondsFromNow, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame, 32)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1715 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, winInputPoseActionData_t_1819 * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetPoseActionDataForNextFrame(_this->linux_side, action, eOrigin, pActionData, unActionDataSize, ulRestrictToDevice);
 }
 
 DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_GetSkeletalActionData, 20)
-EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1715 * pActionData, uint32_t unActionDataSize)
+EVRInputError __thiscall winIVRInput_IVRInput_007_GetSkeletalActionData(winIVRInput_IVRInput_007 *_this, VRActionHandle_t action, winInputSkeletalActionData_t_1819 * pActionData, uint32_t unActionDataSize)
 {
     TRACE("%p\n", _this);
     return cppIVRInput_IVRInput_007_GetSkeletalActionData(_this->linux_side, action, pActionData, unActionDataSize);
@@ -216,6 +216,13 @@ bool __thiscall winIVRInput_IVRInput_007_IsUsingLegacyInput(winIVRInput_IVRInput
     return cppIVRInput_IVRInput_007_IsUsingLegacyInput(_this->linux_side);
 }
 
+DEFINE_THISCALL_WRAPPER(winIVRInput_IVRInput_007_OpenBindingUI, 25)
+EVRInputError __thiscall winIVRInput_IVRInput_007_OpenBindingUI(winIVRInput_IVRInput_007 *_this, const char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop)
+{
+    TRACE("%p\n", _this);
+    return cppIVRInput_IVRInput_007_OpenBindingUI(_this->linux_side, pchAppKey, ulActionSetHandle, ulDeviceHandle, bShowOnDesktop);
+}
+
 extern vtable_ptr winIVRInput_IVRInput_007_vtable;
 
 #ifndef __GNUC__
@@ -249,6 +256,7 @@ void __asm_dummy_vtables(void) {
         VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_ShowActionOrigins)
         VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_ShowBindingsForActionSet)
         VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_IsUsingLegacyInput)
+        VTABLE_ADD_FUNC(winIVRInput_IVRInput_007_OpenBindingUI)
     );
 #ifndef __GNUC__
 }
@@ -272,8 +280,8 @@ void destroy_winIVRInput_IVRInput_007(void *object)
 winIVRInput_IVRInput_007 *create_winIVRInput_IVRInput_007_FnTable(void *linux_side)
 {
     winIVRInput_IVRInput_007 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRInput_IVRInput_007));
-    struct thunk *thunks = alloc_thunks(27);
-    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 27 * sizeof(*vtable));
+    struct thunk *thunks = alloc_thunks(28);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 28 * sizeof(*vtable));
     int i;
 
     TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
@@ -304,7 +312,8 @@ winIVRInput_IVRInput_007 *create_winIVRInput_IVRInput_007_FnTable(void *linux_si
     init_thunk(&thunks[24], r, winIVRInput_IVRInput_007_ShowActionOrigins, 2, FALSE, FALSE);
     init_thunk(&thunks[25], r, winIVRInput_IVRInput_007_ShowBindingsForActionSet, 4, FALSE, FALSE);
     init_thunk(&thunks[26], r, winIVRInput_IVRInput_007_IsUsingLegacyInput, 0, FALSE, FALSE);
-    for (i = 0; i < 27; i++)
+    init_thunk(&thunks[27], r, winIVRInput_IVRInput_007_OpenBindingUI, 4, FALSE, FALSE);
+    for (i = 0; i < 28; i++)
         vtable[i] = &thunks[i];
     r->linux_side = linux_side;
     r->vtable = (void *)vtable;
diff --git a/vrclient_x64/vrclient_x64/winIVROverlay.c b/vrclient_x64/vrclient_x64/winIVROverlay.c
index c1b0cfb2..79dd783d 100644
--- a/vrclient_x64/vrclient_x64/winIVROverlay.c
+++ b/vrclient_x64/vrclient_x64/winIVROverlay.c
@@ -18,6 +18,749 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVROverlay_IVROverlay_021.h"
+
+typedef struct __winIVROverlay_IVROverlay_021 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVROverlay_IVROverlay_021;
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_FindOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_FindOverlay(winIVROverlay_IVROverlay_021 *_this, const char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_FindOverlay(_this->linux_side, pchOverlayKey, pOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_CreateOverlay, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_CreateOverlay(winIVROverlay_IVROverlay_021 *_this, const char * pchOverlayKey, const char * pchOverlayName, VROverlayHandle_t * pOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_CreateOverlay(_this->linux_side, pchOverlayKey, pchOverlayName, pOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_DestroyOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_DestroyOverlay(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_DestroyOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayKey, 24)
+uint32_t __thiscall winIVROverlay_IVROverlay_021_GetOverlayKey(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayKey(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayName, 24)
+uint32_t __thiscall winIVROverlay_IVROverlay_021_GetOverlayName(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayName(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayName, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayName(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchName)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayName(_this->linux_side, ulOverlayHandle, pchName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayImageData, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayImageData(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayImageData(_this->linux_side, ulOverlayHandle, pvBuffer, unBufferSize, punWidth, punHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayErrorNameFromEnum, 8)
+const char * __thiscall winIVROverlay_IVROverlay_021_GetOverlayErrorNameFromEnum(winIVROverlay_IVROverlay_021 *_this, EVROverlayError error)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayErrorNameFromEnum(_this->linux_side, error);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayRenderingPid, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayRenderingPid(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unPID)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayRenderingPid(_this->linux_side, ulOverlayHandle, unPID);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayRenderingPid, 12)
+uint32_t __thiscall winIVROverlay_IVROverlay_021_GetOverlayRenderingPid(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayRenderingPid(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayFlag, 17)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayFlag(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, bEnabled);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayFlag, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayFlag(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayFlag(_this->linux_side, ulOverlayHandle, eOverlayFlag, pbEnabled);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayColor, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayColor(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayColor(_this->linux_side, ulOverlayHandle, fRed, fGreen, fBlue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayColor, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayColor(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayColor(_this->linux_side, ulOverlayHandle, pfRed, pfGreen, pfBlue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayAlpha, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayAlpha(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float fAlpha)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayAlpha(_this->linux_side, ulOverlayHandle, fAlpha);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayAlpha, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayAlpha(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float * pfAlpha)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayAlpha(_this->linux_side, ulOverlayHandle, pfAlpha);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayTexelAspect, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTexelAspect(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float fTexelAspect)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, fTexelAspect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTexelAspect, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTexelAspect(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTexelAspect(_this->linux_side, ulOverlayHandle, pfTexelAspect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlaySortOrder, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlaySortOrder(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlaySortOrder(_this->linux_side, ulOverlayHandle, unSortOrder);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlaySortOrder, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlaySortOrder(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlaySortOrder(_this->linux_side, ulOverlayHandle, punSortOrder);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayWidthInMeters, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayWidthInMeters(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float fWidthInMeters)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, fWidthInMeters);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayWidthInMeters, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayWidthInMeters(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayWidthInMeters(_this->linux_side, ulOverlayHandle, pfWidthInMeters);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayCurvature, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayCurvature(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float fCurvature)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayCurvature(_this->linux_side, ulOverlayHandle, fCurvature);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayCurvature, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayCurvature(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, float * pfCurvature)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayCurvature(_this->linux_side, ulOverlayHandle, pfCurvature);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayTextureColorSpace, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTextureColorSpace(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, eTextureColorSpace);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTextureColorSpace, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTextureColorSpace(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTextureColorSpace(_this->linux_side, ulOverlayHandle, peTextureColorSpace);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayTextureBounds, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTextureBounds(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTextureBounds, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTextureBounds(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t * pOverlayTextureBounds)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTextureBounds(_this->linux_side, ulOverlayHandle, pOverlayTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayRenderModel, 28)
+uint32_t __thiscall winIVROverlay_IVROverlay_021_GetOverlayRenderModel(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, HmdColor_t * pColor, EVROverlayError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayRenderModel(_this->linux_side, ulOverlayHandle, pchValue, unBufferSize, pColor, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayRenderModel, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayRenderModel(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, const char * pchRenderModel, HmdColor_t * pColor)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayRenderModel(_this->linux_side, ulOverlayHandle, pchRenderModel, pColor);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTransformType, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTransformType(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTransformType(_this->linux_side, ulOverlayHandle, peTransformType);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayTransformAbsolute, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTransformAbsolute(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, eTrackingOrigin, pmatTrackingOriginToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTransformAbsolute, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTransformAbsolute(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTransformAbsolute(_this->linux_side, ulOverlayHandle, peTrackingOrigin, pmatTrackingOriginToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, unTrackedDevice, pmatTrackedDeviceToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative(_this->linux_side, ulOverlayHandle, punTrackedDevice, pmatTrackedDeviceToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char * pchComponentName)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, unDeviceIndex, pchComponentName);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent(_this->linux_side, ulOverlayHandle, punDeviceIndex, pchComponentName, unComponentNameSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTransformOverlayRelative, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayTransformOverlayRelative, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTransformOverlayRelative(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, HmdMatrix34_t * pmatParentOverlayToOverlayTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayTransformOverlayRelative(_this->linux_side, ulOverlayHandle, ulOverlayHandleParent, pmatParentOverlayToOverlayTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_ShowOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_ShowOverlay(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_ShowOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_HideOverlay, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_HideOverlay(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_HideOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_IsOverlayVisible, 12)
+bool __thiscall winIVROverlay_IVROverlay_021_IsOverlayVisible(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_IsOverlayVisible(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetTransformForOverlayCoordinates, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetTransformForOverlayCoordinates(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t * pmatTransform)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetTransformForOverlayCoordinates(_this->linux_side, ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, pmatTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_PollNextOverlayEvent, 20)
+bool __thiscall winIVROverlay_IVROverlay_021_PollNextOverlayEvent(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, winVREvent_t_1819 * pEvent, uint32_t uncbVREvent)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_PollNextOverlayEvent(_this->linux_side, ulOverlayHandle, pEvent, uncbVREvent);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayInputMethod, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayInputMethod(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayInputMethod(_this->linux_side, ulOverlayHandle, peInputMethod);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayInputMethod, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayInputMethod(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayInputMethod(_this->linux_side, ulOverlayHandle, eInputMethod);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayMouseScale, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayMouseScale(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayMouseScale, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayMouseScale(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, HmdVector2_t * pvecMouseScale)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayMouseScale(_this->linux_side, ulOverlayHandle, pvecMouseScale);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_ComputeOverlayIntersection, 20)
+bool __thiscall winIVROverlay_IVROverlay_021_ComputeOverlayIntersection(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionParams_t * pParams, VROverlayIntersectionResults_t * pResults)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_ComputeOverlayIntersection(_this->linux_side, ulOverlayHandle, pParams, pResults);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_IsHoverTargetOverlay, 12)
+bool __thiscall winIVROverlay_IVROverlay_021_IsHoverTargetOverlay(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_IsHoverTargetOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayDualAnalogTransform, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayDualAnalogTransform(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float fRadius)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayDualAnalogTransform(_this->linux_side, ulOverlay, eWhich, pvCenter, fRadius);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayDualAnalogTransform, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayDualAnalogTransform(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlay, EDualAnalogWhich eWhich, HmdVector2_t * pvCenter, float * pfRadius)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayDualAnalogTransform(_this->linux_side, ulOverlay, eWhich, pvCenter, pfRadius);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayTexture, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayTexture(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, Texture_t * pTexture)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayTexture(_this->linux_side, ulOverlayHandle, pTexture);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_ClearOverlayTexture, 12)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_ClearOverlayTexture(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_ClearOverlayTexture(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayRaw, 28)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayRaw(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayRaw(_this->linux_side, ulOverlayHandle, pvBuffer, unWidth, unHeight, unDepth);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayFromFile, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayFromFile(winIVROverlay_IVROverlay_021 *_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_021_SetOverlayFromFile(_this->linux_side, ulOverlayHandle, pchFilePath ? lin_pchFilePath : NULL);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTexture, 44)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTexture(winIVROverlay_IVROverlay_021 *_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_021_GetOverlayTexture(_this->linux_side, ulOverlayHandle, pNativeTextureHandle, pNativeTextureRef, pWidth, pHeight, pNativeFormat, pAPIType, pColorSpace, pTextureBounds);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_ReleaseNativeOverlayHandle, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_ReleaseNativeOverlayHandle(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_ReleaseNativeOverlayHandle(_this->linux_side, ulOverlayHandle, pNativeTextureHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayTextureSize, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayTextureSize(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayTextureSize(_this->linux_side, ulOverlayHandle, pWidth, pHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_CreateDashboardOverlay, 20)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_CreateDashboardOverlay(winIVROverlay_IVROverlay_021 *_this, const char * pchOverlayKey, const char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_CreateDashboardOverlay(_this->linux_side, pchOverlayKey, pchOverlayFriendlyName, pMainHandle, pThumbnailHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_IsDashboardVisible, 4)
+bool __thiscall winIVROverlay_IVROverlay_021_IsDashboardVisible(winIVROverlay_IVROverlay_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_IsDashboardVisible(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_IsActiveDashboardOverlay, 12)
+bool __thiscall winIVROverlay_IVROverlay_021_IsActiveDashboardOverlay(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_IsActiveDashboardOverlay(_this->linux_side, ulOverlayHandle);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetDashboardOverlaySceneProcess, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, unProcessId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetDashboardOverlaySceneProcess, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetDashboardOverlaySceneProcess(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetDashboardOverlaySceneProcess(_this->linux_side, ulOverlayHandle, punProcessId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_ShowDashboard, 8)
+void __thiscall winIVROverlay_IVROverlay_021_ShowDashboard(winIVROverlay_IVROverlay_021 *_this, const char * pchOverlayToShow)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_021_ShowDashboard(_this->linux_side, pchOverlayToShow);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetPrimaryDashboardDevice, 4)
+TrackedDeviceIndex_t __thiscall winIVROverlay_IVROverlay_021_GetPrimaryDashboardDevice(winIVROverlay_IVROverlay_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetPrimaryDashboardDevice(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_ShowKeyboard, 33)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_ShowKeyboard(winIVROverlay_IVROverlay_021 *_this, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_ShowKeyboard(_this->linux_side, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText, bUseMinimalMode, uUserValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_ShowKeyboardForOverlay, 41)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_ShowKeyboardForOverlay(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char * pchDescription, uint32_t unCharMax, const char * pchExistingText, bool bUseMinimalMode, uint64_t uUserValue)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_ShowKeyboardForOverlay(_this->linux_side, ulOverlayHandle, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText, bUseMinimalMode, uUserValue);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetKeyboardText, 12)
+uint32_t __thiscall winIVROverlay_IVROverlay_021_GetKeyboardText(winIVROverlay_IVROverlay_021 *_this, char * pchText, uint32_t cchText)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetKeyboardText(_this->linux_side, pchText, cchText);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_HideKeyboard, 4)
+void __thiscall winIVROverlay_IVROverlay_021_HideKeyboard(winIVROverlay_IVROverlay_021 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_021_HideKeyboard(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetKeyboardTransformAbsolute, 12)
+void __thiscall winIVROverlay_IVROverlay_021_SetKeyboardTransformAbsolute(winIVROverlay_IVROverlay_021 *_this, ETrackingUniverseOrigin eTrackingOrigin, HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_021_SetKeyboardTransformAbsolute(_this->linux_side, eTrackingOrigin, pmatTrackingOriginToKeyboardTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetKeyboardPositionForOverlay, 28)
+void __thiscall winIVROverlay_IVROverlay_021_SetKeyboardPositionForOverlay(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_021_SetKeyboardPositionForOverlay(_this->linux_side, ulOverlayHandle, avoidRect);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_SetOverlayIntersectionMask, 24)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_SetOverlayIntersectionMask(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_SetOverlayIntersectionMask(_this->linux_side, ulOverlayHandle, pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_GetOverlayFlags, 16)
+EVROverlayError __thiscall winIVROverlay_IVROverlay_021_GetOverlayFlags(winIVROverlay_IVROverlay_021 *_this, VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags)
+{
+    TRACE("%p\n", _this);
+    return cppIVROverlay_IVROverlay_021_GetOverlayFlags(_this->linux_side, ulOverlayHandle, pFlags);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_ShowMessageOverlay, 28)
+VRMessageOverlayResponse __thiscall winIVROverlay_IVROverlay_021_ShowMessageOverlay(winIVROverlay_IVROverlay_021 *_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_021_ShowMessageOverlay(_this->linux_side, pchText, pchCaption, pchButton0Text, pchButton1Text, pchButton2Text, pchButton3Text);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVROverlay_IVROverlay_021_CloseMessageOverlay, 4)
+void __thiscall winIVROverlay_IVROverlay_021_CloseMessageOverlay(winIVROverlay_IVROverlay_021 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVROverlay_IVROverlay_021_CloseMessageOverlay(_this->linux_side);
+}
+
+extern vtable_ptr winIVROverlay_IVROverlay_021_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVROverlay_IVROverlay_021,
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_FindOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_CreateOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_DestroyOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayKey)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayName)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayName)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayImageData)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayErrorNameFromEnum)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayRenderingPid)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayRenderingPid)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayFlag)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayFlag)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayColor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayColor)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayAlpha)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayAlpha)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayTexelAspect)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTexelAspect)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlaySortOrder)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlaySortOrder)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayWidthInMeters)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayWidthInMeters)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayCurvature)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayCurvature)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayTextureColorSpace)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTextureColorSpace)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayTextureBounds)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTextureBounds)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayRenderModel)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayRenderModel)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTransformType)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTransformOverlayRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayTransformOverlayRelative)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_ShowOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_HideOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_IsOverlayVisible)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetTransformForOverlayCoordinates)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_PollNextOverlayEvent)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayInputMethod)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayInputMethod)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayMouseScale)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayMouseScale)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_ComputeOverlayIntersection)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_IsHoverTargetOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayDualAnalogTransform)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayDualAnalogTransform)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_ClearOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayRaw)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayFromFile)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTexture)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_ReleaseNativeOverlayHandle)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayTextureSize)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_CreateDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_IsDashboardVisible)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_IsActiveDashboardOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetDashboardOverlaySceneProcess)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetDashboardOverlaySceneProcess)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_ShowDashboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetPrimaryDashboardDevice)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_ShowKeyboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_ShowKeyboardForOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetKeyboardText)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_HideKeyboard)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetKeyboardTransformAbsolute)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetKeyboardPositionForOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_SetOverlayIntersectionMask)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_GetOverlayFlags)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_ShowMessageOverlay)
+        VTABLE_ADD_FUNC(winIVROverlay_IVROverlay_021_CloseMessageOverlay)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVROverlay_IVROverlay_021 *create_winIVROverlay_IVROverlay_021(void *linux_side)
+{
+    winIVROverlay_IVROverlay_021 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_021));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVROverlay_IVROverlay_021_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVROverlay_IVROverlay_021(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVROverlay_IVROverlay_021 *create_winIVROverlay_IVROverlay_021_FnTable(void *linux_side)
+{
+    winIVROverlay_IVROverlay_021 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVROverlay_IVROverlay_021));
+    struct thunk *thunks = alloc_thunks(76);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 76 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVROverlay_IVROverlay_021_FindOverlay, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVROverlay_IVROverlay_021_CreateOverlay, 3, FALSE, FALSE);
+    init_thunk(&thunks[2], r, winIVROverlay_IVROverlay_021_DestroyOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVROverlay_IVROverlay_021_GetOverlayKey, 4, FALSE, FALSE);
+    init_thunk(&thunks[4], r, winIVROverlay_IVROverlay_021_GetOverlayName, 4, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVROverlay_IVROverlay_021_SetOverlayName, 2, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVROverlay_IVROverlay_021_GetOverlayImageData, 5, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVROverlay_IVROverlay_021_GetOverlayErrorNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVROverlay_IVROverlay_021_SetOverlayRenderingPid, 2, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVROverlay_IVROverlay_021_GetOverlayRenderingPid, 1, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVROverlay_IVROverlay_021_SetOverlayFlag, 3, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVROverlay_IVROverlay_021_GetOverlayFlag, 3, FALSE, FALSE);
+    init_thunk(&thunks[12], r, winIVROverlay_IVROverlay_021_SetOverlayColor, 4, TRUE, TRUE);
+    init_thunk(&thunks[13], r, winIVROverlay_IVROverlay_021_GetOverlayColor, 4, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVROverlay_IVROverlay_021_SetOverlayAlpha, 2, TRUE, FALSE);
+    init_thunk(&thunks[15], r, winIVROverlay_IVROverlay_021_GetOverlayAlpha, 2, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVROverlay_IVROverlay_021_SetOverlayTexelAspect, 2, TRUE, FALSE);
+    init_thunk(&thunks[17], r, winIVROverlay_IVROverlay_021_GetOverlayTexelAspect, 2, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVROverlay_IVROverlay_021_SetOverlaySortOrder, 2, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVROverlay_IVROverlay_021_GetOverlaySortOrder, 2, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVROverlay_IVROverlay_021_SetOverlayWidthInMeters, 2, TRUE, FALSE);
+    init_thunk(&thunks[21], r, winIVROverlay_IVROverlay_021_GetOverlayWidthInMeters, 2, FALSE, FALSE);
+    init_thunk(&thunks[22], r, winIVROverlay_IVROverlay_021_SetOverlayCurvature, 2, TRUE, FALSE);
+    init_thunk(&thunks[23], r, winIVROverlay_IVROverlay_021_GetOverlayCurvature, 2, FALSE, FALSE);
+    init_thunk(&thunks[24], r, winIVROverlay_IVROverlay_021_SetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVROverlay_IVROverlay_021_GetOverlayTextureColorSpace, 2, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVROverlay_IVROverlay_021_SetOverlayTextureBounds, 2, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVROverlay_IVROverlay_021_GetOverlayTextureBounds, 2, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVROverlay_IVROverlay_021_GetOverlayRenderModel, 5, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVROverlay_IVROverlay_021_SetOverlayRenderModel, 3, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVROverlay_IVROverlay_021_GetOverlayTransformType, 2, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVROverlay_IVROverlay_021_SetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    init_thunk(&thunks[32], r, winIVROverlay_IVROverlay_021_GetOverlayTransformAbsolute, 3, FALSE, FALSE);
+    init_thunk(&thunks[33], r, winIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[34], r, winIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[35], r, winIVROverlay_IVROverlay_021_SetOverlayTransformTrackedDeviceComponent, 3, FALSE, FALSE);
+    init_thunk(&thunks[36], r, winIVROverlay_IVROverlay_021_GetOverlayTransformTrackedDeviceComponent, 4, FALSE, FALSE);
+    init_thunk(&thunks[37], r, winIVROverlay_IVROverlay_021_GetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[38], r, winIVROverlay_IVROverlay_021_SetOverlayTransformOverlayRelative, 3, FALSE, FALSE);
+    init_thunk(&thunks[39], r, winIVROverlay_IVROverlay_021_ShowOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[40], r, winIVROverlay_IVROverlay_021_HideOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[41], r, winIVROverlay_IVROverlay_021_IsOverlayVisible, 1, FALSE, FALSE);
+    init_thunk(&thunks[42], r, winIVROverlay_IVROverlay_021_GetTransformForOverlayCoordinates, 4, FALSE, FALSE);
+    init_thunk(&thunks[43], r, winIVROverlay_IVROverlay_021_PollNextOverlayEvent, 3, FALSE, FALSE);
+    init_thunk(&thunks[44], r, winIVROverlay_IVROverlay_021_GetOverlayInputMethod, 2, FALSE, FALSE);
+    init_thunk(&thunks[45], r, winIVROverlay_IVROverlay_021_SetOverlayInputMethod, 2, FALSE, FALSE);
+    init_thunk(&thunks[46], r, winIVROverlay_IVROverlay_021_GetOverlayMouseScale, 2, FALSE, FALSE);
+    init_thunk(&thunks[47], r, winIVROverlay_IVROverlay_021_SetOverlayMouseScale, 2, FALSE, FALSE);
+    init_thunk(&thunks[48], r, winIVROverlay_IVROverlay_021_ComputeOverlayIntersection, 3, FALSE, FALSE);
+    init_thunk(&thunks[49], r, winIVROverlay_IVROverlay_021_IsHoverTargetOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[50], r, winIVROverlay_IVROverlay_021_SetOverlayDualAnalogTransform, 4, TRUE, TRUE);
+    init_thunk(&thunks[51], r, winIVROverlay_IVROverlay_021_GetOverlayDualAnalogTransform, 4, FALSE, FALSE);
+    init_thunk(&thunks[52], r, winIVROverlay_IVROverlay_021_SetOverlayTexture, 2, FALSE, FALSE);
+    init_thunk(&thunks[53], r, winIVROverlay_IVROverlay_021_ClearOverlayTexture, 1, FALSE, FALSE);
+    init_thunk(&thunks[54], r, winIVROverlay_IVROverlay_021_SetOverlayRaw, 5, FALSE, FALSE);
+    init_thunk(&thunks[55], r, winIVROverlay_IVROverlay_021_SetOverlayFromFile, 2, FALSE, FALSE);
+    init_thunk(&thunks[56], r, winIVROverlay_IVROverlay_021_GetOverlayTexture, 9, FALSE, FALSE);
+    init_thunk(&thunks[57], r, winIVROverlay_IVROverlay_021_ReleaseNativeOverlayHandle, 2, FALSE, FALSE);
+    init_thunk(&thunks[58], r, winIVROverlay_IVROverlay_021_GetOverlayTextureSize, 3, FALSE, FALSE);
+    init_thunk(&thunks[59], r, winIVROverlay_IVROverlay_021_CreateDashboardOverlay, 4, FALSE, FALSE);
+    init_thunk(&thunks[60], r, winIVROverlay_IVROverlay_021_IsDashboardVisible, 0, FALSE, FALSE);
+    init_thunk(&thunks[61], r, winIVROverlay_IVROverlay_021_IsActiveDashboardOverlay, 1, FALSE, FALSE);
+    init_thunk(&thunks[62], r, winIVROverlay_IVROverlay_021_SetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    init_thunk(&thunks[63], r, winIVROverlay_IVROverlay_021_GetDashboardOverlaySceneProcess, 2, FALSE, FALSE);
+    init_thunk(&thunks[64], r, winIVROverlay_IVROverlay_021_ShowDashboard, 1, FALSE, FALSE);
+    init_thunk(&thunks[65], r, winIVROverlay_IVROverlay_021_GetPrimaryDashboardDevice, 0, FALSE, FALSE);
+    init_thunk(&thunks[66], r, winIVROverlay_IVROverlay_021_ShowKeyboard, 7, FALSE, FALSE);
+    init_thunk(&thunks[67], r, winIVROverlay_IVROverlay_021_ShowKeyboardForOverlay, 8, FALSE, FALSE);
+    init_thunk(&thunks[68], r, winIVROverlay_IVROverlay_021_GetKeyboardText, 2, FALSE, FALSE);
+    init_thunk(&thunks[69], r, winIVROverlay_IVROverlay_021_HideKeyboard, 0, FALSE, FALSE);
+    init_thunk(&thunks[70], r, winIVROverlay_IVROverlay_021_SetKeyboardTransformAbsolute, 2, FALSE, FALSE);
+    init_thunk(&thunks[71], r, winIVROverlay_IVROverlay_021_SetKeyboardPositionForOverlay, 2, FALSE, FALSE);
+    init_thunk(&thunks[72], r, winIVROverlay_IVROverlay_021_SetOverlayIntersectionMask, 4, FALSE, FALSE);
+    init_thunk(&thunks[73], r, winIVROverlay_IVROverlay_021_GetOverlayFlags, 2, FALSE, FALSE);
+    init_thunk(&thunks[74], r, winIVROverlay_IVROverlay_021_ShowMessageOverlay, 6, FALSE, FALSE);
+    init_thunk(&thunks[75], r, winIVROverlay_IVROverlay_021_CloseMessageOverlay, 0, FALSE, FALSE);
+    for (i = 0; i < 76; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVROverlay_IVROverlay_021_FnTable(void *object)
+{
+    winIVROverlay_IVROverlay_021 *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_020.h"
 
 typedef struct __winIVROverlay_IVROverlay_020 {
diff --git a/vrclient_x64/vrclient_x64/winIVRRenderModels.c b/vrclient_x64/vrclient_x64/winIVRRenderModels.c
index b9c735b8..684c5f7d 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_1715 ** ppRenderModel)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadRenderModel_Async(winIVRRenderModels_IVRRenderModels_006 *_this, const char * pchRenderModelName, winRenderModel_t_1819 ** 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_1715 * pRenderModel)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeRenderModel(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_t_1819 * 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_1715 ** ppTexture)
+EVRRenderModelError __thiscall winIVRRenderModels_IVRRenderModels_006_LoadTexture_Async(winIVRRenderModels_IVRRenderModels_006 *_this, TextureID_t textureId, winRenderModel_TextureMap_t_1819 ** 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_1715 * pTexture)
+void __thiscall winIVRRenderModels_IVRRenderModels_006_FreeTexture(winIVRRenderModels_IVRRenderModels_006 *_this, winRenderModel_TextureMap_t_1819 * 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 dde39789..4fc69823 100644
--- a/vrclient_x64/vrclient_x64/winIVRSystem.c
+++ b/vrclient_x64/vrclient_x64/winIVRSystem.c
@@ -18,6 +18,492 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(vrclient);
 
+#include "cppIVRSystem_IVRSystem_021.h"
+
+typedef struct __winIVRSystem_IVRSystem_021 {
+    vtable_ptr *vtable;
+    void *linux_side;
+} winIVRSystem_IVRSystem_021;
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetRecommendedRenderTargetSize, 12)
+void __thiscall winIVRSystem_IVRSystem_021_GetRecommendedRenderTargetSize(winIVRSystem_IVRSystem_021 *_this, uint32_t * pnWidth, uint32_t * pnHeight)
+{
+    TRACE("%p\n", _this);
+    cppIVRSystem_IVRSystem_021_GetRecommendedRenderTargetSize(_this->linux_side, pnWidth, pnHeight);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetProjectionMatrix, 20)
+HmdMatrix44_t *__thiscall winIVRSystem_IVRSystem_021_GetProjectionMatrix(winIVRSystem_IVRSystem_021 *_this, HmdMatrix44_t *_r, EVREye eEye, float fNearZ, float fFarZ)
+{
+    TRACE("%p\n", _this);
+    *_r = cppIVRSystem_IVRSystem_021_GetProjectionMatrix(_this->linux_side, eEye, fNearZ, fFarZ);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetProjectionRaw, 24)
+void __thiscall winIVRSystem_IVRSystem_021_GetProjectionRaw(winIVRSystem_IVRSystem_021 *_this, EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom)
+{
+    TRACE("%p\n", _this);
+    cppIVRSystem_IVRSystem_021_GetProjectionRaw(_this->linux_side, eEye, pfLeft, pfRight, pfTop, pfBottom);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_ComputeDistortion, 20)
+bool __thiscall winIVRSystem_IVRSystem_021_ComputeDistortion(winIVRSystem_IVRSystem_021 *_this, EVREye eEye, float fU, float fV, DistortionCoordinates_t * pDistortionCoordinates)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_ComputeDistortion(_this->linux_side, eEye, fU, fV, pDistortionCoordinates);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetEyeToHeadTransform, 12)
+HmdMatrix34_t *__thiscall winIVRSystem_IVRSystem_021_GetEyeToHeadTransform(winIVRSystem_IVRSystem_021 *_this, HmdMatrix34_t *_r, EVREye eEye)
+{
+    TRACE("%p\n", _this);
+    *_r = cppIVRSystem_IVRSystem_021_GetEyeToHeadTransform(_this->linux_side, eEye);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetTimeSinceLastVsync, 12)
+bool __thiscall winIVRSystem_IVRSystem_021_GetTimeSinceLastVsync(winIVRSystem_IVRSystem_021 *_this, float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetTimeSinceLastVsync(_this->linux_side, pfSecondsSinceLastVsync, pulFrameCounter);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetD3D9AdapterIndex, 4)
+int32_t __thiscall winIVRSystem_IVRSystem_021_GetD3D9AdapterIndex(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetD3D9AdapterIndex(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetDXGIOutputInfo, 8)
+void __thiscall winIVRSystem_IVRSystem_021_GetDXGIOutputInfo(winIVRSystem_IVRSystem_021 *_this, int32_t * pnAdapterIndex)
+{
+    TRACE("%p\n", _this);
+    get_dxgi_output_info(cppIVRSystem_IVRSystem_021_GetDXGIOutputInfo, _this->linux_side, pnAdapterIndex, 21);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetOutputDevice, 16)
+void __thiscall winIVRSystem_IVRSystem_021_GetOutputDevice(winIVRSystem_IVRSystem_021 *_this, uint64_t * pnDevice, ETextureType textureType, VkInstance_T * pInstance)
+{
+    TRACE("%p\n", _this);
+    ivrsystem_get_output_device(cppIVRSystem_IVRSystem_021_GetOutputDevice, _this->linux_side, pnDevice, textureType, pInstance, 21);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_IsDisplayOnDesktop, 4)
+bool __thiscall winIVRSystem_IVRSystem_021_IsDisplayOnDesktop(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_IsDisplayOnDesktop(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_SetDisplayVisibility, 5)
+bool __thiscall winIVRSystem_IVRSystem_021_SetDisplayVisibility(winIVRSystem_IVRSystem_021 *_this, bool bIsVisibleOnDesktop)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_SetDisplayVisibility(_this->linux_side, bIsVisibleOnDesktop);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetDeviceToAbsoluteTrackingPose, 20)
+void __thiscall winIVRSystem_IVRSystem_021_GetDeviceToAbsoluteTrackingPose(winIVRSystem_IVRSystem_021 *_this, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount)
+{
+    TRACE("%p\n", _this);
+    cppIVRSystem_IVRSystem_021_GetDeviceToAbsoluteTrackingPose(_this->linux_side, eOrigin, fPredictedSecondsToPhotonsFromNow, pTrackedDevicePoseArray, unTrackedDevicePoseArrayCount);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_ResetSeatedZeroPose, 4)
+void __thiscall winIVRSystem_IVRSystem_021_ResetSeatedZeroPose(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRSystem_IVRSystem_021_ResetSeatedZeroPose(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 8)
+HmdMatrix34_t *__thiscall winIVRSystem_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(winIVRSystem_IVRSystem_021 *_this, HmdMatrix34_t *_r)
+{
+    TRACE("%p\n", _this);
+    *_r = cppIVRSystem_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose(_this->linux_side);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose, 8)
+HmdMatrix34_t *__thiscall winIVRSystem_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose(winIVRSystem_IVRSystem_021 *_this, HmdMatrix34_t *_r)
+{
+    TRACE("%p\n", _this);
+    *_r = cppIVRSystem_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose(_this->linux_side);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass, 20)
+uint32_t __thiscall winIVRSystem_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass(winIVRSystem_IVRSystem_021 *_this, ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass(_this->linux_side, eTrackedDeviceClass, punTrackedDeviceIndexArray, unTrackedDeviceIndexArrayCount, unRelativeToTrackedDeviceIndex);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetTrackedDeviceActivityLevel, 8)
+EDeviceActivityLevel __thiscall winIVRSystem_IVRSystem_021_GetTrackedDeviceActivityLevel(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceId)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetTrackedDeviceActivityLevel(_this->linux_side, unDeviceId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_ApplyTransform, 16)
+void __thiscall winIVRSystem_IVRSystem_021_ApplyTransform(winIVRSystem_IVRSystem_021 *_this, TrackedDevicePose_t * pOutputPose, TrackedDevicePose_t * pTrackedDevicePose, HmdMatrix34_t * pTransform)
+{
+    TRACE("%p\n", _this);
+    cppIVRSystem_IVRSystem_021_ApplyTransform(_this->linux_side, pOutputPose, pTrackedDevicePose, pTransform);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetTrackedDeviceIndexForControllerRole, 8)
+TrackedDeviceIndex_t __thiscall winIVRSystem_IVRSystem_021_GetTrackedDeviceIndexForControllerRole(winIVRSystem_IVRSystem_021 *_this, ETrackedControllerRole unDeviceType)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetTrackedDeviceIndexForControllerRole(_this->linux_side, unDeviceType);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex, 8)
+ETrackedControllerRole __thiscall winIVRSystem_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex(_this->linux_side, unDeviceIndex);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetTrackedDeviceClass, 8)
+ETrackedDeviceClass __thiscall winIVRSystem_IVRSystem_021_GetTrackedDeviceClass(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetTrackedDeviceClass(_this->linux_side, unDeviceIndex);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_IsTrackedDeviceConnected, 8)
+bool __thiscall winIVRSystem_IVRSystem_021_IsTrackedDeviceConnected(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_IsTrackedDeviceConnected(_this->linux_side, unDeviceIndex);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetBoolTrackedDeviceProperty, 16)
+bool __thiscall winIVRSystem_IVRSystem_021_GetBoolTrackedDeviceProperty(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetBoolTrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetFloatTrackedDeviceProperty, 16)
+float __thiscall winIVRSystem_IVRSystem_021_GetFloatTrackedDeviceProperty(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetFloatTrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetInt32TrackedDeviceProperty, 16)
+int32_t __thiscall winIVRSystem_IVRSystem_021_GetInt32TrackedDeviceProperty(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetInt32TrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetUint64TrackedDeviceProperty, 16)
+uint64_t __thiscall winIVRSystem_IVRSystem_021_GetUint64TrackedDeviceProperty(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetUint64TrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetMatrix34TrackedDeviceProperty, 20)
+HmdMatrix34_t *__thiscall winIVRSystem_IVRSystem_021_GetMatrix34TrackedDeviceProperty(winIVRSystem_IVRSystem_021 *_this, HmdMatrix34_t *_r, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError)
+{
+    TRACE("%p\n", _this);
+    *_r = cppIVRSystem_IVRSystem_021_GetMatrix34TrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pError);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetArrayTrackedDeviceProperty, 28)
+uint32_t __thiscall winIVRSystem_IVRSystem_021_GetArrayTrackedDeviceProperty(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetArrayTrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, propType, pBuffer, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetStringTrackedDeviceProperty, 24)
+uint32_t __thiscall winIVRSystem_IVRSystem_021_GetStringTrackedDeviceProperty(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetStringTrackedDeviceProperty(_this->linux_side, unDeviceIndex, prop, pchValue, unBufferSize, pError);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum, 8)
+const char * __thiscall winIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(winIVRSystem_IVRSystem_021 *_this, ETrackedPropertyError error)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum(_this->linux_side, error);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_PollNextEvent, 12)
+bool __thiscall winIVRSystem_IVRSystem_021_PollNextEvent(winIVRSystem_IVRSystem_021 *_this, winVREvent_t_1819 * pEvent, uint32_t uncbVREvent)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_PollNextEvent(_this->linux_side, pEvent, uncbVREvent);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_PollNextEventWithPose, 20)
+bool __thiscall winIVRSystem_IVRSystem_021_PollNextEventWithPose(winIVRSystem_IVRSystem_021 *_this, ETrackingUniverseOrigin eOrigin, winVREvent_t_1819 * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_PollNextEventWithPose(_this->linux_side, eOrigin, pEvent, uncbVREvent, pTrackedDevicePose);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetEventTypeNameFromEnum, 8)
+const char * __thiscall winIVRSystem_IVRSystem_021_GetEventTypeNameFromEnum(winIVRSystem_IVRSystem_021 *_this, EVREventType eType)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetEventTypeNameFromEnum(_this->linux_side, eType);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetHiddenAreaMesh, 16)
+HiddenAreaMesh_t *__thiscall winIVRSystem_IVRSystem_021_GetHiddenAreaMesh(winIVRSystem_IVRSystem_021 *_this, HiddenAreaMesh_t *_r, EVREye eEye, EHiddenAreaMeshType type)
+{
+    TRACE("%p\n", _this);
+    *_r = cppIVRSystem_IVRSystem_021_GetHiddenAreaMesh(_this->linux_side, eEye, type);
+    return _r;
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetControllerState, 16)
+bool __thiscall winIVRSystem_IVRSystem_021_GetControllerState(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1819 * pControllerState, uint32_t unControllerStateSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetControllerState(_this->linux_side, unControllerDeviceIndex, pControllerState, unControllerStateSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetControllerStateWithPose, 24)
+bool __thiscall winIVRSystem_IVRSystem_021_GetControllerStateWithPose(winIVRSystem_IVRSystem_021 *_this, ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, winVRControllerState001_t_1819 * pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t * pTrackedDevicePose)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetControllerStateWithPose(_this->linux_side, eOrigin, unControllerDeviceIndex, pControllerState, unControllerStateSize, pTrackedDevicePose);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_TriggerHapticPulse, 14)
+void __thiscall winIVRSystem_IVRSystem_021_TriggerHapticPulse(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec)
+{
+    TRACE("%p\n", _this);
+    cppIVRSystem_IVRSystem_021_TriggerHapticPulse(_this->linux_side, unControllerDeviceIndex, unAxisId, usDurationMicroSec);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetButtonIdNameFromEnum, 8)
+const char * __thiscall winIVRSystem_IVRSystem_021_GetButtonIdNameFromEnum(winIVRSystem_IVRSystem_021 *_this, EVRButtonId eButtonId)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetButtonIdNameFromEnum(_this->linux_side, eButtonId);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetControllerAxisTypeNameFromEnum, 8)
+const char * __thiscall winIVRSystem_IVRSystem_021_GetControllerAxisTypeNameFromEnum(winIVRSystem_IVRSystem_021 *_this, EVRControllerAxisType eAxisType)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetControllerAxisTypeNameFromEnum(_this->linux_side, eAxisType);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_IsInputAvailable, 4)
+bool __thiscall winIVRSystem_IVRSystem_021_IsInputAvailable(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_IsInputAvailable(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_IsSteamVRDrawingControllers, 4)
+bool __thiscall winIVRSystem_IVRSystem_021_IsSteamVRDrawingControllers(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_IsSteamVRDrawingControllers(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_ShouldApplicationPause, 4)
+bool __thiscall winIVRSystem_IVRSystem_021_ShouldApplicationPause(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_ShouldApplicationPause(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_ShouldApplicationReduceRenderingWork, 4)
+bool __thiscall winIVRSystem_IVRSystem_021_ShouldApplicationReduceRenderingWork(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_ShouldApplicationReduceRenderingWork(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_PerformFirmwareUpdate, 8)
+EVRFirmwareError __thiscall winIVRSystem_IVRSystem_021_PerformFirmwareUpdate(winIVRSystem_IVRSystem_021 *_this, TrackedDeviceIndex_t unDeviceIndex)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_PerformFirmwareUpdate(_this->linux_side, unDeviceIndex);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_AcknowledgeQuit_Exiting, 4)
+void __thiscall winIVRSystem_IVRSystem_021_AcknowledgeQuit_Exiting(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    cppIVRSystem_IVRSystem_021_AcknowledgeQuit_Exiting(_this->linux_side);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetAppContainerFilePaths, 12)
+uint32_t __thiscall winIVRSystem_IVRSystem_021_GetAppContainerFilePaths(winIVRSystem_IVRSystem_021 *_this, char * pchBuffer, uint32_t unBufferSize)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetAppContainerFilePaths(_this->linux_side, pchBuffer, unBufferSize);
+}
+
+DEFINE_THISCALL_WRAPPER(winIVRSystem_IVRSystem_021_GetRuntimeVersion, 4)
+const char * __thiscall winIVRSystem_IVRSystem_021_GetRuntimeVersion(winIVRSystem_IVRSystem_021 *_this)
+{
+    TRACE("%p\n", _this);
+    return cppIVRSystem_IVRSystem_021_GetRuntimeVersion(_this->linux_side);
+}
+
+extern vtable_ptr winIVRSystem_IVRSystem_021_vtable;
+
+#ifndef __GNUC__
+void __asm_dummy_vtables(void) {
+#endif
+    __ASM_VTABLE(winIVRSystem_IVRSystem_021,
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetRecommendedRenderTargetSize)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetProjectionMatrix)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetProjectionRaw)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_ComputeDistortion)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetEyeToHeadTransform)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetTimeSinceLastVsync)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetD3D9AdapterIndex)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetDXGIOutputInfo)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetOutputDevice)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_IsDisplayOnDesktop)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_SetDisplayVisibility)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetDeviceToAbsoluteTrackingPose)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_ResetSeatedZeroPose)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetTrackedDeviceActivityLevel)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_ApplyTransform)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetTrackedDeviceIndexForControllerRole)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetTrackedDeviceClass)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_IsTrackedDeviceConnected)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetBoolTrackedDeviceProperty)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetFloatTrackedDeviceProperty)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetInt32TrackedDeviceProperty)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetUint64TrackedDeviceProperty)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetMatrix34TrackedDeviceProperty)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetArrayTrackedDeviceProperty)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetStringTrackedDeviceProperty)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_PollNextEvent)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_PollNextEventWithPose)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetEventTypeNameFromEnum)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetHiddenAreaMesh)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetControllerState)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetControllerStateWithPose)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_TriggerHapticPulse)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetButtonIdNameFromEnum)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetControllerAxisTypeNameFromEnum)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_IsInputAvailable)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_IsSteamVRDrawingControllers)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_ShouldApplicationPause)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_ShouldApplicationReduceRenderingWork)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_PerformFirmwareUpdate)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_AcknowledgeQuit_Exiting)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetAppContainerFilePaths)
+        VTABLE_ADD_FUNC(winIVRSystem_IVRSystem_021_GetRuntimeVersion)
+    );
+#ifndef __GNUC__
+}
+#endif
+
+winIVRSystem_IVRSystem_021 *create_winIVRSystem_IVRSystem_021(void *linux_side)
+{
+    winIVRSystem_IVRSystem_021 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_021));
+    TRACE("-> %p\n", r);
+    r->vtable = &winIVRSystem_IVRSystem_021_vtable;
+    r->linux_side = linux_side;
+    return r;
+}
+
+void destroy_winIVRSystem_IVRSystem_021(void *object)
+{
+    TRACE("%p\n", object);
+    HeapFree(GetProcessHeap(), 0, object);
+}
+
+winIVRSystem_IVRSystem_021 *create_winIVRSystem_IVRSystem_021_FnTable(void *linux_side)
+{
+    winIVRSystem_IVRSystem_021 *r = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(winIVRSystem_IVRSystem_021));
+    struct thunk *thunks = alloc_thunks(47);
+    struct thunk **vtable = HeapAlloc(GetProcessHeap(), 0, 47 * sizeof(*vtable));
+    int i;
+
+    TRACE("-> %p, vtable %p, thunks %p\n", r, vtable, thunks);
+    init_thunk(&thunks[0], r, winIVRSystem_IVRSystem_021_GetRecommendedRenderTargetSize, 2, FALSE, FALSE);
+    init_thunk(&thunks[1], r, winIVRSystem_IVRSystem_021_GetProjectionMatrix, 4, TRUE, TRUE);
+    init_thunk(&thunks[2], r, winIVRSystem_IVRSystem_021_GetProjectionRaw, 5, FALSE, FALSE);
+    init_thunk(&thunks[3], r, winIVRSystem_IVRSystem_021_ComputeDistortion, 4, TRUE, FALSE);
+    init_thunk(&thunks[4], r, winIVRSystem_IVRSystem_021_GetEyeToHeadTransform, 2, FALSE, FALSE);
+    init_thunk(&thunks[5], r, winIVRSystem_IVRSystem_021_GetTimeSinceLastVsync, 2, FALSE, FALSE);
+    init_thunk(&thunks[6], r, winIVRSystem_IVRSystem_021_GetD3D9AdapterIndex, 0, FALSE, FALSE);
+    init_thunk(&thunks[7], r, winIVRSystem_IVRSystem_021_GetDXGIOutputInfo, 1, FALSE, FALSE);
+    init_thunk(&thunks[8], r, winIVRSystem_IVRSystem_021_GetOutputDevice, 3, FALSE, FALSE);
+    init_thunk(&thunks[9], r, winIVRSystem_IVRSystem_021_IsDisplayOnDesktop, 0, FALSE, FALSE);
+    init_thunk(&thunks[10], r, winIVRSystem_IVRSystem_021_SetDisplayVisibility, 1, FALSE, FALSE);
+    init_thunk(&thunks[11], r, winIVRSystem_IVRSystem_021_GetDeviceToAbsoluteTrackingPose, 4, TRUE, FALSE);
+    init_thunk(&thunks[12], r, winIVRSystem_IVRSystem_021_ResetSeatedZeroPose, 0, FALSE, FALSE);
+    init_thunk(&thunks[13], r, winIVRSystem_IVRSystem_021_GetSeatedZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    init_thunk(&thunks[14], r, winIVRSystem_IVRSystem_021_GetRawZeroPoseToStandingAbsoluteTrackingPose, 1, FALSE, FALSE);
+    init_thunk(&thunks[15], r, winIVRSystem_IVRSystem_021_GetSortedTrackedDeviceIndicesOfClass, 4, FALSE, FALSE);
+    init_thunk(&thunks[16], r, winIVRSystem_IVRSystem_021_GetTrackedDeviceActivityLevel, 1, FALSE, FALSE);
+    init_thunk(&thunks[17], r, winIVRSystem_IVRSystem_021_ApplyTransform, 3, FALSE, FALSE);
+    init_thunk(&thunks[18], r, winIVRSystem_IVRSystem_021_GetTrackedDeviceIndexForControllerRole, 1, FALSE, FALSE);
+    init_thunk(&thunks[19], r, winIVRSystem_IVRSystem_021_GetControllerRoleForTrackedDeviceIndex, 1, FALSE, FALSE);
+    init_thunk(&thunks[20], r, winIVRSystem_IVRSystem_021_GetTrackedDeviceClass, 1, FALSE, FALSE);
+    init_thunk(&thunks[21], r, winIVRSystem_IVRSystem_021_IsTrackedDeviceConnected, 1, FALSE, FALSE);
+    init_thunk(&thunks[22], r, winIVRSystem_IVRSystem_021_GetBoolTrackedDeviceProperty, 3, FALSE, FALSE);
+    init_thunk(&thunks[23], r, winIVRSystem_IVRSystem_021_GetFloatTrackedDeviceProperty, 3, FALSE, FALSE);
+    init_thunk(&thunks[24], r, winIVRSystem_IVRSystem_021_GetInt32TrackedDeviceProperty, 3, FALSE, FALSE);
+    init_thunk(&thunks[25], r, winIVRSystem_IVRSystem_021_GetUint64TrackedDeviceProperty, 3, FALSE, FALSE);
+    init_thunk(&thunks[26], r, winIVRSystem_IVRSystem_021_GetMatrix34TrackedDeviceProperty, 4, FALSE, FALSE);
+    init_thunk(&thunks[27], r, winIVRSystem_IVRSystem_021_GetArrayTrackedDeviceProperty, 6, FALSE, FALSE);
+    init_thunk(&thunks[28], r, winIVRSystem_IVRSystem_021_GetStringTrackedDeviceProperty, 5, FALSE, FALSE);
+    init_thunk(&thunks[29], r, winIVRSystem_IVRSystem_021_GetPropErrorNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[30], r, winIVRSystem_IVRSystem_021_PollNextEvent, 2, FALSE, FALSE);
+    init_thunk(&thunks[31], r, winIVRSystem_IVRSystem_021_PollNextEventWithPose, 4, FALSE, FALSE);
+    init_thunk(&thunks[32], r, winIVRSystem_IVRSystem_021_GetEventTypeNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[33], r, winIVRSystem_IVRSystem_021_GetHiddenAreaMesh, 3, FALSE, FALSE);
+    init_thunk(&thunks[34], r, winIVRSystem_IVRSystem_021_GetControllerState, 3, FALSE, FALSE);
+    init_thunk(&thunks[35], r, winIVRSystem_IVRSystem_021_GetControllerStateWithPose, 5, FALSE, FALSE);
+    init_thunk(&thunks[36], r, winIVRSystem_IVRSystem_021_TriggerHapticPulse, 3, FALSE, FALSE);
+    init_thunk(&thunks[37], r, winIVRSystem_IVRSystem_021_GetButtonIdNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[38], r, winIVRSystem_IVRSystem_021_GetControllerAxisTypeNameFromEnum, 1, FALSE, FALSE);
+    init_thunk(&thunks[39], r, winIVRSystem_IVRSystem_021_IsInputAvailable, 0, FALSE, FALSE);
+    init_thunk(&thunks[40], r, winIVRSystem_IVRSystem_021_IsSteamVRDrawingControllers, 0, FALSE, FALSE);
+    init_thunk(&thunks[41], r, winIVRSystem_IVRSystem_021_ShouldApplicationPause, 0, FALSE, FALSE);
+    init_thunk(&thunks[42], r, winIVRSystem_IVRSystem_021_ShouldApplicationReduceRenderingWork, 0, FALSE, FALSE);
+    init_thunk(&thunks[43], r, winIVRSystem_IVRSystem_021_PerformFirmwareUpdate, 1, FALSE, FALSE);
+    init_thunk(&thunks[44], r, winIVRSystem_IVRSystem_021_AcknowledgeQuit_Exiting, 0, FALSE, FALSE);
+    init_thunk(&thunks[45], r, winIVRSystem_IVRSystem_021_GetAppContainerFilePaths, 2, FALSE, FALSE);
+    init_thunk(&thunks[46], r, winIVRSystem_IVRSystem_021_GetRuntimeVersion, 0, FALSE, FALSE);
+    for (i = 0; i < 47; i++)
+        vtable[i] = &thunks[i];
+    r->linux_side = linux_side;
+    r->vtable = (void *)vtable;
+    return r;
+}
+
+void destroy_winIVRSystem_IVRSystem_021_FnTable(void *object)
+{
+    winIVRSystem_IVRSystem_021 *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 "cppIVRSystem_IVRSystem_020.h"
 
 typedef struct __winIVRSystem_IVRSystem_020 {
diff --git a/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c b/vrclient_x64/vrclient_x64/winIVRTrackedCamera.c
index 6eb1f8ee..11929a65 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_1715 * 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_1819 * 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_1715 * 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_1819 * 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_1715 * pFrameHeader, uint32_t nFrameHeaderSize)
+EVRTrackedCameraError __thiscall winIVRTrackedCamera_IVRTrackedCamera_006_GetVideoStreamTextureGL(winIVRTrackedCamera_IVRTrackedCamera_006 *_this, TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, winCameraVideoStreamFrameHeader_t_1819 * 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 c58cde83..0d777386 100644
--- a/vrclient_x64/vrclient_x64/win_constructors.h
+++ b/vrclient_x64/vrclient_x64/win_constructors.h
@@ -1,7 +1,7 @@
-extern void *create_winIVRSystem_IVRSystem_020(void *);
-extern void *create_winIVRSystem_IVRSystem_020_FnTable(void *);
-extern void *create_winIVRApplications_IVRApplications_006(void *);
-extern void *create_winIVRApplications_IVRApplications_006_FnTable(void *);
+extern void *create_winIVRSystem_IVRSystem_021(void *);
+extern void *create_winIVRSystem_IVRSystem_021_FnTable(void *);
+extern void *create_winIVRApplications_IVRApplications_007(void *);
+extern void *create_winIVRApplications_IVRApplications_007_FnTable(void *);
 extern void *create_winIVRSettings_IVRSettings_002(void *);
 extern void *create_winIVRSettings_IVRSettings_002_FnTable(void *);
 extern void *create_winIVRChaperone_IVRChaperone_003(void *);
@@ -12,8 +12,8 @@ extern void *create_winIVRCompositor_IVRCompositor_022(void *);
 extern void *create_winIVRCompositor_IVRCompositor_022_FnTable(void *);
 extern void *create_winIVRNotifications_IVRNotifications_002(void *);
 extern void *create_winIVRNotifications_IVRNotifications_002_FnTable(void *);
-extern void *create_winIVROverlay_IVROverlay_020(void *);
-extern void *create_winIVROverlay_IVROverlay_020_FnTable(void *);
+extern void *create_winIVROverlay_IVROverlay_021(void *);
+extern void *create_winIVROverlay_IVROverlay_021_FnTable(void *);
 extern void *create_winIVRRenderModels_IVRRenderModels_006(void *);
 extern void *create_winIVRRenderModels_IVRRenderModels_006_FnTable(void *);
 extern void *create_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *);
@@ -32,6 +32,12 @@ 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_winIVRSystem_IVRSystem_020(void *);
+extern void *create_winIVRSystem_IVRSystem_020_FnTable(void *);
+extern void *create_winIVRApplications_IVRApplications_006(void *);
+extern void *create_winIVRApplications_IVRApplications_006_FnTable(void *);
+extern void *create_winIVROverlay_IVROverlay_020(void *);
+extern void *create_winIVROverlay_IVROverlay_020_FnTable(void *);
 extern void *create_winIVROverlay_IVROverlay_019(void *);
 extern void *create_winIVROverlay_IVROverlay_019_FnTable(void *);
 extern void *create_winIVRTrackedCamera_IVRTrackedCamera_005(void *);
diff --git a/vrclient_x64/vrclient_x64/win_constructors_table.dat b/vrclient_x64/vrclient_x64/win_constructors_table.dat
index 8027aa51..7ade3139 100644
--- a/vrclient_x64/vrclient_x64/win_constructors_table.dat
+++ b/vrclient_x64/vrclient_x64/win_constructors_table.dat
@@ -1,7 +1,7 @@
-    {"IVRSystem_020", &create_winIVRSystem_IVRSystem_020, &destroy_winIVRSystem_IVRSystem_020},
-    {"FnTable:IVRSystem_020", &create_winIVRSystem_IVRSystem_020_FnTable, &destroy_winIVRSystem_IVRSystem_020_FnTable},
-    {"IVRApplications_006", &create_winIVRApplications_IVRApplications_006, &destroy_winIVRApplications_IVRApplications_006},
-    {"FnTable:IVRApplications_006", &create_winIVRApplications_IVRApplications_006_FnTable, &destroy_winIVRApplications_IVRApplications_006_FnTable},
+    {"IVRSystem_021", &create_winIVRSystem_IVRSystem_021, &destroy_winIVRSystem_IVRSystem_021},
+    {"FnTable:IVRSystem_021", &create_winIVRSystem_IVRSystem_021_FnTable, &destroy_winIVRSystem_IVRSystem_021_FnTable},
+    {"IVRApplications_007", &create_winIVRApplications_IVRApplications_007, &destroy_winIVRApplications_IVRApplications_007},
+    {"FnTable:IVRApplications_007", &create_winIVRApplications_IVRApplications_007_FnTable, &destroy_winIVRApplications_IVRApplications_007_FnTable},
     {"IVRSettings_002", &create_winIVRSettings_IVRSettings_002, &destroy_winIVRSettings_IVRSettings_002},
     {"FnTable:IVRSettings_002", &create_winIVRSettings_IVRSettings_002_FnTable, &destroy_winIVRSettings_IVRSettings_002_FnTable},
     {"IVRChaperone_003", &create_winIVRChaperone_IVRChaperone_003, &destroy_winIVRChaperone_IVRChaperone_003},
@@ -12,8 +12,8 @@
     {"FnTable:IVRCompositor_022", &create_winIVRCompositor_IVRCompositor_022_FnTable, &destroy_winIVRCompositor_IVRCompositor_022_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_020", &create_winIVROverlay_IVROverlay_020, &destroy_winIVROverlay_IVROverlay_020},
-    {"FnTable:IVROverlay_020", &create_winIVROverlay_IVROverlay_020_FnTable, &destroy_winIVROverlay_IVROverlay_020_FnTable},
+    {"IVROverlay_021", &create_winIVROverlay_IVROverlay_021, &destroy_winIVROverlay_IVROverlay_021},
+    {"FnTable:IVROverlay_021", &create_winIVROverlay_IVROverlay_021_FnTable, &destroy_winIVROverlay_IVROverlay_021_FnTable},
     {"IVRRenderModels_006", &create_winIVRRenderModels_IVRRenderModels_006, &destroy_winIVRRenderModels_IVRRenderModels_006},
     {"FnTable:IVRRenderModels_006", &create_winIVRRenderModels_IVRRenderModels_006_FnTable, &destroy_winIVRRenderModels_IVRRenderModels_006_FnTable},
     {"IVRExtendedDisplay_001", &create_winIVRExtendedDisplay_IVRExtendedDisplay_001, &destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001},
@@ -32,6 +32,12 @@
     {"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},
+    {"IVRSystem_020", &create_winIVRSystem_IVRSystem_020, &destroy_winIVRSystem_IVRSystem_020},
+    {"FnTable:IVRSystem_020", &create_winIVRSystem_IVRSystem_020_FnTable, &destroy_winIVRSystem_IVRSystem_020_FnTable},
+    {"IVRApplications_006", &create_winIVRApplications_IVRApplications_006, &destroy_winIVRApplications_IVRApplications_006},
+    {"FnTable:IVRApplications_006", &create_winIVRApplications_IVRApplications_006_FnTable, &destroy_winIVRApplications_IVRApplications_006_FnTable},
+    {"IVROverlay_020", &create_winIVROverlay_IVROverlay_020, &destroy_winIVROverlay_IVROverlay_020},
+    {"FnTable:IVROverlay_020", &create_winIVROverlay_IVROverlay_020_FnTable, &destroy_winIVROverlay_IVROverlay_020_FnTable},
     {"IVROverlay_019", &create_winIVROverlay_IVROverlay_019, &destroy_winIVROverlay_IVROverlay_019},
     {"FnTable:IVROverlay_019", &create_winIVROverlay_IVROverlay_019_FnTable, &destroy_winIVROverlay_IVROverlay_019_FnTable},
     {"IVRTrackedCamera_005", &create_winIVRTrackedCamera_IVRTrackedCamera_005, &destroy_winIVRTrackedCamera_IVRTrackedCamera_005},
diff --git a/vrclient_x64/vrclient_x64/win_destructors.h b/vrclient_x64/vrclient_x64/win_destructors.h
index 53d247e1..63f2a1e9 100644
--- a/vrclient_x64/vrclient_x64/win_destructors.h
+++ b/vrclient_x64/vrclient_x64/win_destructors.h
@@ -1,7 +1,7 @@
-extern void destroy_winIVRSystem_IVRSystem_020(void *);
-extern void destroy_winIVRSystem_IVRSystem_020_FnTable(void *);
-extern void destroy_winIVRApplications_IVRApplications_006(void *);
-extern void destroy_winIVRApplications_IVRApplications_006_FnTable(void *);
+extern void destroy_winIVRSystem_IVRSystem_021(void *);
+extern void destroy_winIVRSystem_IVRSystem_021_FnTable(void *);
+extern void destroy_winIVRApplications_IVRApplications_007(void *);
+extern void destroy_winIVRApplications_IVRApplications_007_FnTable(void *);
 extern void destroy_winIVRSettings_IVRSettings_002(void *);
 extern void destroy_winIVRSettings_IVRSettings_002_FnTable(void *);
 extern void destroy_winIVRChaperone_IVRChaperone_003(void *);
@@ -12,8 +12,8 @@ extern void destroy_winIVRCompositor_IVRCompositor_022(void *);
 extern void destroy_winIVRCompositor_IVRCompositor_022_FnTable(void *);
 extern void destroy_winIVRNotifications_IVRNotifications_002(void *);
 extern void destroy_winIVRNotifications_IVRNotifications_002_FnTable(void *);
-extern void destroy_winIVROverlay_IVROverlay_020(void *);
-extern void destroy_winIVROverlay_IVROverlay_020_FnTable(void *);
+extern void destroy_winIVROverlay_IVROverlay_021(void *);
+extern void destroy_winIVROverlay_IVROverlay_021_FnTable(void *);
 extern void destroy_winIVRRenderModels_IVRRenderModels_006(void *);
 extern void destroy_winIVRRenderModels_IVRRenderModels_006_FnTable(void *);
 extern void destroy_winIVRExtendedDisplay_IVRExtendedDisplay_001(void *);
@@ -32,6 +32,12 @@ 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_winIVRSystem_IVRSystem_020(void *);
+extern void destroy_winIVRSystem_IVRSystem_020_FnTable(void *);
+extern void destroy_winIVRApplications_IVRApplications_006(void *);
+extern void destroy_winIVRApplications_IVRApplications_006_FnTable(void *);
+extern void destroy_winIVROverlay_IVROverlay_020(void *);
+extern void destroy_winIVROverlay_IVROverlay_020_FnTable(void *);
 extern void destroy_winIVROverlay_IVROverlay_019(void *);
 extern void destroy_winIVROverlay_IVROverlay_019_FnTable(void *);
 extern void destroy_winIVRTrackedCamera_IVRTrackedCamera_005(void *);