From 59fc76f90e7f1d787c3a98bc45390fe45986a660 Mon Sep 17 00:00:00 2001
From: "Ybalrid (Arthur Brainville)" <ybalrid@ybalrid.info>
Date: Mon, 10 May 2021 18:34:59 +0200
Subject: [PATCH] Use OpenVR to find SteamVR to find it's manifest

---
 .gitmodules                                   |    3 +
 .../OpenXR-Runtime-Manager.csproj             |   12 +
 .../OpenXR-Runtime-Manager/RuntimeManager.cs  |   41 +-
 .../OpenXR-Runtime-Manager/openvr_api.cs      | 8220 +++++++++++++++++
 .../OpenXR-Runtime-Manager/openvr_api.dll     |  Bin 0 -> 818904 bytes
 third-party/openvr                            |    1 +
 6 files changed, 8275 insertions(+), 2 deletions(-)
 create mode 100644 .gitmodules
 create mode 100644 OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/openvr_api.cs
 create mode 100644 OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/openvr_api.dll
 create mode 160000 third-party/openvr

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 0000000..06cc59a
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "third-party/openvr"]
+	path = third-party/openvr
+	url = https://github.com/ValveSoftware/openvr
diff --git a/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager.csproj b/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager.csproj
index 44364f7..b120a43 100644
--- a/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager.csproj
+++ b/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager.csproj
@@ -99,6 +99,7 @@
       <Generator>MSBuild:Compile</Generator>
       <SubType>Designer</SubType>
     </ApplicationDefinition>
+    <Compile Include="openvr_api.cs" />
     <Compile Include="Runtime.cs" />
     <Compile Include="RuntimeManager.cs" />
     <Compile Include="Version.cs" />
@@ -158,5 +159,16 @@
       <Install>false</Install>
     </BootstrapperPackage>
   </ItemGroup>
+  <ItemGroup>
+    <Content Include="openvr_api.dll" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PostBuildEvent>copy $(ProjectDir)openvr_api.dll $(TargetDir)</PostBuildEvent>
+  </PropertyGroup>
+  <PropertyGroup>
+    <PreBuildEvent>copy $(ProjectDir)..\..\third-party\openvr\bin\win64\openvr_api.dll ${ProjectDir)
+copy $(ProjectDir)..\..\third-party\openvr\headers\openvr_api.cs ${ProjectDir)
+</PreBuildEvent>
+  </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/RuntimeManager.cs b/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/RuntimeManager.cs
index 86540b0..27d2566 100644
--- a/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/RuntimeManager.cs
+++ b/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/RuntimeManager.cs
@@ -1,18 +1,20 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.Diagnostics;
 using System.IO;
+using System.Text;
 using Microsoft.Win32;
 using Newtonsoft.Json;
+using Valve.VR;
 
 namespace OpenXR_Runtime_Manager
 {
 	class RuntimeManager
 	{
 		//TODO make a database of paths to manifest for known OpenXR runtimes that are compatible with MS Windows
-		readonly string[] WellKnwonOpenXRRuntimeManifestPaths =
+		List<string> WellKnwonOpenXRRuntimeManifestPaths = new List<string>()
 		{
-			"%ProgramFiles(x86)%\\Steam\\steamapps\\common\\SteamVR\\steamxr_win64.json",
 			"%ProgramFiles%\\Oculus\\Support\\oculus-runtime\\oculus_openxr_32.json",
 			"%ProgramFiles%\\Oculus\\Support\\oculus-runtime\\oculus_openxr_64.json",
 			"%windir%\\system32\\MixedRealityRuntime.json",
@@ -148,9 +150,44 @@ private static string GetKhronosOpenXRVersionRegistryKeyPath(int OpenXRVersion =
 			return $@"SOFTWARE\Khronos\OpenXR\{OpenXRVersion}";
 		}
 
+		/// <summary>
+		/// Uses OpenVR to query the installation path of SteamVR, to then build the path to the OpenXR manifest file
+		/// </summary>
+		/// <returns>True upon success. </returns>
+		private bool ProbeForSteamVRInstallationPath()
+		{
+			StringBuilder pathBuilder = new StringBuilder(256);
+			uint bufferSize = (uint)pathBuilder.Length;
+			try
+			{
+				if (OpenVRInterop.GetRuntimePath(pathBuilder, bufferSize, ref bufferSize))
+				{
+					string pathToSteamVR = pathBuilder.ToString();
+					Debug.Print($"Found a SteamVR installation at {pathToSteamVR}");
+					string pathToSteamVRManifest = Path.Combine(pathBuilder.ToString(), "steamxr_win64.json");
+					WellKnwonOpenXRRuntimeManifestPaths.Add(pathToSteamVRManifest);
+					return true;
+				}
+				return false;
+			}
+			catch(DllNotFoundException e)
+			{
+				Debug.Print("Missing openvr_api.dll?!");
+				Debug.Print(e.Message);
+				return false;
+			}
+		}
+
 		public RuntimeManager()
 		{
 			GetActiveRuntimeFromRegistry();
+
+			if(!ProbeForSteamVRInstallationPath())
+			{
+				Debug.Print("This system seems to not have SteamVR installed, or we cannot call OpenVR for some other reasons. Will probe in default installation folder instead");
+				WellKnwonOpenXRRuntimeManifestPaths.Add("%ProgramFiles(x86)%\\Steam\\steamapps\\common\\SteamVR\\steamxr_win64.json");
+			}
+
 			ProbeForAdditionalRuntimes();
 
 			foreach (KeyValuePair<string, Runtime> availableRuntime in _availableRuntimes)
diff --git a/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/openvr_api.cs b/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/openvr_api.cs
new file mode 100644
index 0000000..4732b62
--- /dev/null
+++ b/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/openvr_api.cs
@@ -0,0 +1,8220 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: This file contains C#/managed code bindings for the OpenVR interfaces
+// This file is auto-generated, do not edit it.
+//
+//=============================================================================
+#if !OPENVR_XR_API
+
+using System;
+using System.Runtime.InteropServices;
+using Valve.VR;
+
+#if UNITY_5_3_OR_NEWER
+using UnityEngine;
+#endif
+
+namespace Valve.VR
+{
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRSystem
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetRecommendedRenderTargetSize(ref uint pnWidth, ref uint pnHeight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetRecommendedRenderTargetSize GetRecommendedRenderTargetSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate HmdMatrix44_t _GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetProjectionMatrix GetProjectionMatrix;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetProjectionRaw(EVREye eEye, ref float pfLeft, ref float pfRight, ref float pfTop, ref float pfBottom);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetProjectionRaw GetProjectionRaw;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _ComputeDistortion(EVREye eEye, float fU, float fV, ref DistortionCoordinates_t pDistortionCoordinates);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ComputeDistortion ComputeDistortion;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate HmdMatrix34_t _GetEyeToHeadTransform(EVREye eEye);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetEyeToHeadTransform GetEyeToHeadTransform;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync, ref ulong pulFrameCounter);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetTimeSinceLastVsync GetTimeSinceLastVsync;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate int _GetD3D9AdapterIndex();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetD3D9AdapterIndex GetD3D9AdapterIndex;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDXGIOutputInfo GetDXGIOutputInfo;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetOutputDevice(ref ulong pnDevice, ETextureType textureType, IntPtr pInstance);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOutputDevice GetOutputDevice;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsDisplayOnDesktop();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsDisplayOnDesktop IsDisplayOnDesktop;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _SetDisplayVisibility(bool bIsVisibleOnDesktop);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetDisplayVisibility SetDisplayVisibility;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, [In, Out] TrackedDevicePose_t[] pTrackedDevicePoseArray, uint unTrackedDevicePoseArrayCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDeviceToAbsoluteTrackingPose GetDeviceToAbsoluteTrackingPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate HmdMatrix34_t _GetSeatedZeroPoseToStandingAbsoluteTrackingPose();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSeatedZeroPoseToStandingAbsoluteTrackingPose GetSeatedZeroPoseToStandingAbsoluteTrackingPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate HmdMatrix34_t _GetRawZeroPoseToStandingAbsoluteTrackingPose();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetRawZeroPoseToStandingAbsoluteTrackingPose GetRawZeroPoseToStandingAbsoluteTrackingPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, [In, Out] uint[] punTrackedDeviceIndexArray, uint unTrackedDeviceIndexArrayCount, uint unRelativeToTrackedDeviceIndex);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSortedTrackedDeviceIndicesOfClass GetSortedTrackedDeviceIndicesOfClass;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EDeviceActivityLevel _GetTrackedDeviceActivityLevel(uint unDeviceId);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetTrackedDeviceActivityLevel GetTrackedDeviceActivityLevel;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ApplyTransform(ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pTrackedDevicePose, ref HmdMatrix34_t pTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ApplyTransform ApplyTransform;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetTrackedDeviceIndexForControllerRole GetTrackedDeviceIndexForControllerRole;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackedControllerRole _GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetControllerRoleForTrackedDeviceIndex GetControllerRoleForTrackedDeviceIndex;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackedDeviceClass _GetTrackedDeviceClass(uint unDeviceIndex);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetTrackedDeviceClass GetTrackedDeviceClass;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsTrackedDeviceConnected(uint unDeviceIndex);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsTrackedDeviceConnected IsTrackedDeviceConnected;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetBoolTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetBoolTrackedDeviceProperty GetBoolTrackedDeviceProperty;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate float _GetFloatTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetFloatTrackedDeviceProperty GetFloatTrackedDeviceProperty;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate int _GetInt32TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetInt32TrackedDeviceProperty GetInt32TrackedDeviceProperty;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ulong _GetUint64TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetUint64TrackedDeviceProperty GetUint64TrackedDeviceProperty;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate HmdMatrix34_t _GetMatrix34TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetMatrix34TrackedDeviceProperty GetMatrix34TrackedDeviceProperty;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetArrayTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, uint propType, IntPtr pBuffer, uint unBufferSize, ref ETrackedPropertyError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetArrayTrackedDeviceProperty GetArrayTrackedDeviceProperty;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetStringTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, System.Text.StringBuilder pchValue, uint unBufferSize, ref ETrackedPropertyError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetStringTrackedDeviceProperty GetStringTrackedDeviceProperty;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetPropErrorNameFromEnum(ETrackedPropertyError error);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetPropErrorNameFromEnum GetPropErrorNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _PollNextEvent(ref VREvent_t pEvent, uint uncbVREvent);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _PollNextEvent PollNextEvent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, ref VREvent_t pEvent, uint uncbVREvent, ref TrackedDevicePose_t pTrackedDevicePose);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _PollNextEventWithPose PollNextEventWithPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetEventTypeNameFromEnum(EVREventType eType);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetEventTypeNameFromEnum GetEventTypeNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate HiddenAreaMesh_t _GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetHiddenAreaMesh GetHiddenAreaMesh;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetControllerState(uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetControllerState GetControllerState;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetControllerStateWithPose GetControllerStateWithPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _TriggerHapticPulse(uint unControllerDeviceIndex, uint unAxisId, ushort usDurationMicroSec);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _TriggerHapticPulse TriggerHapticPulse;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetButtonIdNameFromEnum(EVRButtonId eButtonId);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetButtonIdNameFromEnum GetButtonIdNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetControllerAxisTypeNameFromEnum GetControllerAxisTypeNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsInputAvailable();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsInputAvailable IsInputAvailable;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsSteamVRDrawingControllers();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsSteamVRDrawingControllers IsSteamVRDrawingControllers;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _ShouldApplicationPause();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShouldApplicationPause ShouldApplicationPause;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _ShouldApplicationReduceRenderingWork();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShouldApplicationReduceRenderingWork ShouldApplicationReduceRenderingWork;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRFirmwareError _PerformFirmwareUpdate(uint unDeviceIndex);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _PerformFirmwareUpdate PerformFirmwareUpdate;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _AcknowledgeQuit_Exiting();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _AcknowledgeQuit_Exiting AcknowledgeQuit_Exiting;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetAppContainerFilePaths(System.Text.StringBuilder pchBuffer, uint unBufferSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetAppContainerFilePaths GetAppContainerFilePaths;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetRuntimeVersion();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetRuntimeVersion GetRuntimeVersion;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRExtendedDisplay
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetWindowBounds(ref int pnX, ref int pnY, ref uint pnWidth, ref uint pnHeight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetWindowBounds GetWindowBounds;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetEyeOutputViewport(EVREye eEye, ref uint pnX, ref uint pnY, ref uint pnWidth, ref uint pnHeight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetEyeOutputViewport GetEyeOutputViewport;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex, ref int pnAdapterOutputIndex);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDXGIOutputInfo GetDXGIOutputInfo;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRTrackedCamera
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetCameraErrorNameFromEnum(EVRTrackedCameraError eCameraError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCameraErrorNameFromEnum GetCameraErrorNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _HasCamera(uint nDeviceIndex, ref bool pHasCamera);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _HasCamera HasCamera;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _GetCameraFrameSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref uint pnWidth, ref uint pnHeight, ref uint pnFrameBufferSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCameraFrameSize GetCameraFrameSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _GetCameraIntrinsics(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, ref HmdVector2_t pFocalLength, ref HmdVector2_t pCenter);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCameraIntrinsics GetCameraIntrinsics;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _GetCameraProjection(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, ref HmdMatrix44_t pProjection);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCameraProjection GetCameraProjection;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _AcquireVideoStreamingService(uint nDeviceIndex, ref ulong pHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _AcquireVideoStreamingService AcquireVideoStreamingService;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _ReleaseVideoStreamingService(ulong hTrackedCamera);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReleaseVideoStreamingService ReleaseVideoStreamingService;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _GetVideoStreamFrameBuffer(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pFrameBuffer, uint nFrameBufferSize, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetVideoStreamFrameBuffer GetVideoStreamFrameBuffer;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _GetVideoStreamTextureSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref VRTextureBounds_t pTextureBounds, ref uint pnWidth, ref uint pnHeight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetVideoStreamTextureSize GetVideoStreamTextureSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _GetVideoStreamTextureD3D11(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetVideoStreamTextureD3D11 GetVideoStreamTextureD3D11;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _GetVideoStreamTextureGL(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, ref uint pglTextureId, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetVideoStreamTextureGL GetVideoStreamTextureGL;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRTrackedCameraError _ReleaseVideoStreamTextureGL(ulong hTrackedCamera, uint glTextureId);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReleaseVideoStreamTextureGL ReleaseVideoStreamTextureGL;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetCameraTrackingSpace(ETrackingUniverseOrigin eUniverse);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetCameraTrackingSpace SetCameraTrackingSpace;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackingUniverseOrigin _GetCameraTrackingSpace();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCameraTrackingSpace GetCameraTrackingSpace;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRApplications
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _AddApplicationManifest(IntPtr pchApplicationManifestFullPath, bool bTemporary);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _AddApplicationManifest AddApplicationManifest;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _RemoveApplicationManifest(IntPtr pchApplicationManifestFullPath);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _RemoveApplicationManifest RemoveApplicationManifest;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsApplicationInstalled(IntPtr pchAppKey);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsApplicationInstalled IsApplicationInstalled;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetApplicationCount();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationCount GetApplicationCount;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _GetApplicationKeyByIndex(uint unApplicationIndex, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationKeyByIndex GetApplicationKeyByIndex;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _GetApplicationKeyByProcessId(uint unProcessId, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationKeyByProcessId GetApplicationKeyByProcessId;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _LaunchApplication(IntPtr pchAppKey);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LaunchApplication LaunchApplication;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _LaunchTemplateApplication(IntPtr pchTemplateAppKey, IntPtr pchNewAppKey, [In, Out] AppOverrideKeys_t[] pKeys, uint unKeys);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LaunchTemplateApplication LaunchTemplateApplication;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _LaunchApplicationFromMimeType(IntPtr pchMimeType, IntPtr pchArgs);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LaunchApplicationFromMimeType LaunchApplicationFromMimeType;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _LaunchDashboardOverlay(IntPtr pchAppKey);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LaunchDashboardOverlay LaunchDashboardOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _CancelApplicationLaunch(IntPtr pchAppKey);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CancelApplicationLaunch CancelApplicationLaunch;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _IdentifyApplication(uint unProcessId, IntPtr pchAppKey);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IdentifyApplication IdentifyApplication;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetApplicationProcessId(IntPtr pchAppKey);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationProcessId GetApplicationProcessId;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetApplicationsErrorNameFromEnum(EVRApplicationError error);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationsErrorNameFromEnum GetApplicationsErrorNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetApplicationPropertyString(IntPtr pchAppKey, EVRApplicationProperty eProperty, System.Text.StringBuilder pchPropertyValueBuffer, uint unPropertyValueBufferLen, ref EVRApplicationError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationPropertyString GetApplicationPropertyString;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetApplicationPropertyBool(IntPtr pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationPropertyBool GetApplicationPropertyBool;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ulong _GetApplicationPropertyUint64(IntPtr pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationPropertyUint64 GetApplicationPropertyUint64;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _SetApplicationAutoLaunch(IntPtr pchAppKey, bool bAutoLaunch);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetApplicationAutoLaunch SetApplicationAutoLaunch;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetApplicationAutoLaunch(IntPtr pchAppKey);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationAutoLaunch GetApplicationAutoLaunch;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _SetDefaultApplicationForMimeType(IntPtr pchAppKey, IntPtr pchMimeType);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetDefaultApplicationForMimeType SetDefaultApplicationForMimeType;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetDefaultApplicationForMimeType(IntPtr pchMimeType, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDefaultApplicationForMimeType GetDefaultApplicationForMimeType;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetApplicationSupportedMimeTypes(IntPtr pchAppKey, System.Text.StringBuilder pchMimeTypesBuffer, uint unMimeTypesBuffer);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationSupportedMimeTypes GetApplicationSupportedMimeTypes;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetApplicationsThatSupportMimeType(IntPtr pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationsThatSupportMimeType GetApplicationsThatSupportMimeType;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetApplicationLaunchArguments(uint unHandle, System.Text.StringBuilder pchArgs, uint unArgs);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetApplicationLaunchArguments GetApplicationLaunchArguments;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetStartingApplication GetStartingApplication;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRSceneApplicationState _GetSceneApplicationState();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSceneApplicationState GetSceneApplicationState;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _PerformApplicationPrelaunchCheck(IntPtr pchAppKey);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _PerformApplicationPrelaunchCheck PerformApplicationPrelaunchCheck;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetSceneApplicationStateNameFromEnum(EVRSceneApplicationState state);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSceneApplicationStateNameFromEnum GetSceneApplicationStateNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRApplicationError _LaunchInternalProcess(IntPtr pchBinaryPath, IntPtr pchArguments, IntPtr pchWorkingDirectory);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LaunchInternalProcess LaunchInternalProcess;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetCurrentSceneProcessId();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCurrentSceneProcessId GetCurrentSceneProcessId;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRChaperone
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ChaperoneCalibrationState _GetCalibrationState();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCalibrationState GetCalibrationState;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetPlayAreaSize(ref float pSizeX, ref float pSizeZ);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetPlayAreaSize GetPlayAreaSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetPlayAreaRect(ref HmdQuad_t rect);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetPlayAreaRect GetPlayAreaRect;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ReloadInfo();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReloadInfo ReloadInfo;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetSceneColor(HmdColor_t color);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetSceneColor SetSceneColor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetBoundsColor(ref HmdColor_t pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, ref HmdColor_t pOutputCameraColor);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetBoundsColor GetBoundsColor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _AreBoundsVisible();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _AreBoundsVisible AreBoundsVisible;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ForceBoundsVisible(bool bForce);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ForceBoundsVisible ForceBoundsVisible;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ResetZeroPose(ETrackingUniverseOrigin eTrackingUniverseOrigin);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ResetZeroPose ResetZeroPose;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRChaperoneSetup
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _CommitWorkingCopy(EChaperoneConfigFile configFile);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CommitWorkingCopy CommitWorkingCopy;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _RevertWorkingCopy();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _RevertWorkingCopy RevertWorkingCopy;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetWorkingPlayAreaSize(ref float pSizeX, ref float pSizeZ);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetWorkingPlayAreaSize GetWorkingPlayAreaSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetWorkingPlayAreaRect(ref HmdQuad_t rect);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetWorkingPlayAreaRect GetWorkingPlayAreaRect;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetWorkingCollisionBoundsInfo GetWorkingCollisionBoundsInfo;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetLiveCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetLiveCollisionBoundsInfo GetLiveCollisionBoundsInfo;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetWorkingSeatedZeroPoseToRawTrackingPose GetWorkingSeatedZeroPoseToRawTrackingPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetWorkingStandingZeroPoseToRawTrackingPose GetWorkingStandingZeroPoseToRawTrackingPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetWorkingPlayAreaSize(float sizeX, float sizeZ);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetWorkingPlayAreaSize SetWorkingPlayAreaSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, uint unQuadsCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetWorkingCollisionBoundsInfo SetWorkingCollisionBoundsInfo;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetWorkingPerimeter([In, Out] HmdVector2_t[] pPointBuffer, uint unPointCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetWorkingPerimeter SetWorkingPerimeter;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetWorkingSeatedZeroPoseToRawTrackingPose SetWorkingSeatedZeroPoseToRawTrackingPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetWorkingStandingZeroPoseToRawTrackingPose SetWorkingStandingZeroPoseToRawTrackingPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ReloadFromDisk(EChaperoneConfigFile configFile);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReloadFromDisk ReloadFromDisk;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetLiveSeatedZeroPoseToRawTrackingPose GetLiveSeatedZeroPoseToRawTrackingPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _ExportLiveToBuffer(System.Text.StringBuilder pBuffer, ref uint pnBufferLength);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ExportLiveToBuffer ExportLiveToBuffer;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _ImportFromBufferToWorking(IntPtr pBuffer, uint nImportFlags);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ImportFromBufferToWorking ImportFromBufferToWorking;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ShowWorkingSetPreview();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowWorkingSetPreview ShowWorkingSetPreview;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _HideWorkingSetPreview();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _HideWorkingSetPreview HideWorkingSetPreview;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _RoomSetupStarting();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _RoomSetupStarting RoomSetupStarting;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRCompositor
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetTrackingSpace(ETrackingUniverseOrigin eOrigin);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetTrackingSpace SetTrackingSpace;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackingUniverseOrigin _GetTrackingSpace();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetTrackingSpace GetTrackingSpace;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _WaitGetPoses([In, Out] TrackedDevicePose_t[] pRenderPoseArray, uint unRenderPoseArrayCount, [In, Out] TrackedDevicePose_t[] pGamePoseArray, uint unGamePoseArrayCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _WaitGetPoses WaitGetPoses;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _GetLastPoses([In, Out] TrackedDevicePose_t[] pRenderPoseArray, uint unRenderPoseArrayCount, [In, Out] TrackedDevicePose_t[] pGamePoseArray, uint unGamePoseArrayCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetLastPoses GetLastPoses;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _GetLastPoseForTrackedDeviceIndex(uint unDeviceIndex, ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pOutputGamePose);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetLastPoseForTrackedDeviceIndex GetLastPoseForTrackedDeviceIndex;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _Submit(EVREye eEye, ref Texture_t pTexture, ref VRTextureBounds_t pBounds, EVRSubmitFlags nSubmitFlags);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _Submit Submit;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ClearLastSubmittedFrame();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ClearLastSubmittedFrame ClearLastSubmittedFrame;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _PostPresentHandoff();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _PostPresentHandoff PostPresentHandoff;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetFrameTiming(ref Compositor_FrameTiming pTiming, uint unFramesAgo);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetFrameTiming GetFrameTiming;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetFrameTimings([In, Out] Compositor_FrameTiming[] pTiming, uint nFrames);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetFrameTimings GetFrameTimings;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate float _GetFrameTimeRemaining();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetFrameTimeRemaining GetFrameTimeRemaining;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetCumulativeStats(ref Compositor_CumulativeStats pStats, uint nStatsSizeInBytes);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCumulativeStats GetCumulativeStats;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _FadeToColor FadeToColor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate HmdColor_t _GetCurrentFadeColor(bool bBackground);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCurrentFadeColor GetCurrentFadeColor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _FadeGrid(float fSeconds, bool bFadeGridIn);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _FadeGrid FadeGrid;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate float _GetCurrentGridAlpha();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCurrentGridAlpha GetCurrentGridAlpha;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _SetSkyboxOverride([In, Out] Texture_t[] pTextures, uint unTextureCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetSkyboxOverride SetSkyboxOverride;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ClearSkyboxOverride();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ClearSkyboxOverride ClearSkyboxOverride;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _CompositorBringToFront();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CompositorBringToFront CompositorBringToFront;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _CompositorGoToBack();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CompositorGoToBack CompositorGoToBack;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _CompositorQuit();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CompositorQuit CompositorQuit;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsFullscreen();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsFullscreen IsFullscreen;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetCurrentSceneFocusProcess();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCurrentSceneFocusProcess GetCurrentSceneFocusProcess;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetLastFrameRenderer();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetLastFrameRenderer GetLastFrameRenderer;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _CanRenderScene();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CanRenderScene CanRenderScene;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ShowMirrorWindow();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowMirrorWindow ShowMirrorWindow;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _HideMirrorWindow();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _HideMirrorWindow HideMirrorWindow;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsMirrorWindowVisible();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsMirrorWindowVisible IsMirrorWindowVisible;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _CompositorDumpImages();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CompositorDumpImages CompositorDumpImages;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _ShouldAppRenderWithLowResources();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShouldAppRenderWithLowResources ShouldAppRenderWithLowResources;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ForceInterleavedReprojectionOn(bool bOverride);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ForceInterleavedReprojectionOn ForceInterleavedReprojectionOn;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ForceReconnectProcess();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ForceReconnectProcess ForceReconnectProcess;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SuspendRendering(bool bSuspend);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SuspendRendering SuspendRendering;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _GetMirrorTextureD3D11(EVREye eEye, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetMirrorTextureD3D11 GetMirrorTextureD3D11;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReleaseMirrorTextureD3D11 ReleaseMirrorTextureD3D11;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _GetMirrorTextureGL(EVREye eEye, ref uint pglTextureId, IntPtr pglSharedTextureHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetMirrorTextureGL GetMirrorTextureGL;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _ReleaseSharedGLTexture(uint glTextureId, IntPtr glSharedTextureHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReleaseSharedGLTexture ReleaseSharedGLTexture;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LockGLSharedTextureForAccess LockGLSharedTextureForAccess;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _UnlockGLSharedTextureForAccess UnlockGLSharedTextureForAccess;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue, uint unBufferSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetVulkanInstanceExtensionsRequired GetVulkanInstanceExtensionsRequired;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice, System.Text.StringBuilder pchValue, uint unBufferSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetVulkanDeviceExtensionsRequired GetVulkanDeviceExtensionsRequired;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetExplicitTimingMode SetExplicitTimingMode;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _SubmitExplicitTimingData();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SubmitExplicitTimingData SubmitExplicitTimingData;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsMotionSmoothingEnabled();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsMotionSmoothingEnabled IsMotionSmoothingEnabled;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsMotionSmoothingSupported();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsMotionSmoothingSupported IsMotionSmoothingSupported;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsCurrentSceneFocusAppLoading();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsCurrentSceneFocusAppLoading IsCurrentSceneFocusAppLoading;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _SetStageOverride_Async(IntPtr pchRenderModelPath, ref HmdMatrix34_t pTransform, ref Compositor_StageRenderSettings pRenderSettings, uint nSizeOfRenderSettings);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetStageOverride_Async SetStageOverride_Async;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ClearStageOverride();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ClearStageOverride ClearStageOverride;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetCompositorBenchmarkResults(ref Compositor_BenchmarkResults pBenchmarkResults, uint nSizeOfBenchmarkResults);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetCompositorBenchmarkResults GetCompositorBenchmarkResults;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _GetLastPosePredictionIDs(ref uint pRenderPosePredictionID, ref uint pGamePosePredictionID);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetLastPosePredictionIDs GetLastPosePredictionIDs;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRCompositorError _GetPosesForFrame(uint unPosePredictionID, [In, Out] TrackedDevicePose_t[] pPoseArray, uint unPoseArrayCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetPosesForFrame GetPosesForFrame;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVROverlay
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _FindOverlay(IntPtr pchOverlayKey, ref ulong pOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _FindOverlay FindOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _CreateOverlay(IntPtr pchOverlayKey, IntPtr pchOverlayName, ref ulong pOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CreateOverlay CreateOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _DestroyOverlay(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _DestroyOverlay DestroyOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetOverlayKey(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayKey GetOverlayKey;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetOverlayName(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayName GetOverlayName;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayName(ulong ulOverlayHandle, IntPtr pchName);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayName SetOverlayName;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayImageData(ulong ulOverlayHandle, IntPtr pvBuffer, uint unBufferSize, ref uint punWidth, ref uint punHeight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayImageData GetOverlayImageData;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetOverlayErrorNameFromEnum(EVROverlayError error);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayErrorNameFromEnum GetOverlayErrorNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayRenderingPid(ulong ulOverlayHandle, uint unPID);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayRenderingPid SetOverlayRenderingPid;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetOverlayRenderingPid(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayRenderingPid GetOverlayRenderingPid;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayFlag SetOverlayFlag;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, ref bool pbEnabled);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayFlag GetOverlayFlag;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayFlags(ulong ulOverlayHandle, ref uint pFlags);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayFlags GetOverlayFlags;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayColor(ulong ulOverlayHandle, float fRed, float fGreen, float fBlue);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayColor SetOverlayColor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayColor(ulong ulOverlayHandle, ref float pfRed, ref float pfGreen, ref float pfBlue);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayColor GetOverlayColor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayAlpha(ulong ulOverlayHandle, float fAlpha);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayAlpha SetOverlayAlpha;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayAlpha(ulong ulOverlayHandle, ref float pfAlpha);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayAlpha GetOverlayAlpha;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTexelAspect(ulong ulOverlayHandle, float fTexelAspect);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTexelAspect SetOverlayTexelAspect;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTexelAspect(ulong ulOverlayHandle, ref float pfTexelAspect);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTexelAspect GetOverlayTexelAspect;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlaySortOrder(ulong ulOverlayHandle, uint unSortOrder);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlaySortOrder SetOverlaySortOrder;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlaySortOrder(ulong ulOverlayHandle, ref uint punSortOrder);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlaySortOrder GetOverlaySortOrder;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayWidthInMeters(ulong ulOverlayHandle, float fWidthInMeters);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayWidthInMeters SetOverlayWidthInMeters;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayWidthInMeters(ulong ulOverlayHandle, ref float pfWidthInMeters);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayWidthInMeters GetOverlayWidthInMeters;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayCurvature(ulong ulOverlayHandle, float fCurvature);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayCurvature SetOverlayCurvature;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayCurvature(ulong ulOverlayHandle, ref float pfCurvature);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayCurvature GetOverlayCurvature;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTextureColorSpace(ulong ulOverlayHandle, EColorSpace eTextureColorSpace);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTextureColorSpace SetOverlayTextureColorSpace;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTextureColorSpace(ulong ulOverlayHandle, ref EColorSpace peTextureColorSpace);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTextureColorSpace GetOverlayTextureColorSpace;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTextureBounds SetOverlayTextureBounds;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTextureBounds GetOverlayTextureBounds;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTransformType(ulong ulOverlayHandle, ref VROverlayTransformType peTransformType);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTransformType GetOverlayTransformType;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTransformAbsolute(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTransformAbsolute SetOverlayTransformAbsolute;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTransformAbsolute GetOverlayTransformAbsolute;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, uint unTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTransformTrackedDeviceRelative SetOverlayTransformTrackedDeviceRelative;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, ref uint punTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTransformTrackedDeviceRelative GetOverlayTransformTrackedDeviceRelative;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, IntPtr pchComponentName);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTransformTrackedDeviceComponent SetOverlayTransformTrackedDeviceComponent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, ref uint punDeviceIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTransformTrackedDeviceComponent GetOverlayTransformTrackedDeviceComponent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ref ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTransformOverlayRelative GetOverlayTransformOverlayRelative;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTransformOverlayRelative SetOverlayTransformOverlayRelative;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTransformCursor(ulong ulCursorOverlayHandle, ref HmdVector2_t pvHotspot);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTransformCursor SetOverlayTransformCursor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTransformCursor(ulong ulOverlayHandle, ref HmdVector2_t pvHotspot);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTransformCursor GetOverlayTransformCursor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTransformProjection(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform, ref VROverlayProjection_t pProjection, EVREye eEye);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTransformProjection SetOverlayTransformProjection;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _ShowOverlay(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowOverlay ShowOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _HideOverlay(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _HideOverlay HideOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsOverlayVisible(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsOverlayVisible IsOverlayVisible;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetTransformForOverlayCoordinates GetTransformForOverlayCoordinates;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _PollNextOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pEvent, uint uncbVREvent);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _PollNextOverlayEvent PollNextOverlayEvent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayInputMethod(ulong ulOverlayHandle, ref VROverlayInputMethod peInputMethod);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayInputMethod GetOverlayInputMethod;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayInputMethod(ulong ulOverlayHandle, VROverlayInputMethod eInputMethod);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayInputMethod SetOverlayInputMethod;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayMouseScale GetOverlayMouseScale;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayMouseScale SetOverlayMouseScale;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _ComputeOverlayIntersection(ulong ulOverlayHandle, ref VROverlayIntersectionParams_t pParams, ref VROverlayIntersectionResults_t pResults);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ComputeOverlayIntersection ComputeOverlayIntersection;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsHoverTargetOverlay(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsHoverTargetOverlay IsHoverTargetOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayIntersectionMask(ulong ulOverlayHandle, ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives, uint unNumMaskPrimitives, uint unPrimitiveSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayIntersectionMask SetOverlayIntersectionMask;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _TriggerLaserMouseHapticVibration(ulong ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _TriggerLaserMouseHapticVibration TriggerLaserMouseHapticVibration;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayCursor(ulong ulOverlayHandle, ulong ulCursorHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayCursor SetOverlayCursor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayCursorPositionOverride(ulong ulOverlayHandle, ref HmdVector2_t pvCursor);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayCursorPositionOverride SetOverlayCursorPositionOverride;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _ClearOverlayCursorPositionOverride(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ClearOverlayCursorPositionOverride ClearOverlayCursorPositionOverride;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayTexture(ulong ulOverlayHandle, ref Texture_t pTexture);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayTexture SetOverlayTexture;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _ClearOverlayTexture(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ClearOverlayTexture ClearOverlayTexture;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayRaw(ulong ulOverlayHandle, IntPtr pvBuffer, uint unWidth, uint unHeight, uint unBytesPerPixel);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayRaw SetOverlayRaw;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetOverlayFromFile(ulong ulOverlayHandle, IntPtr pchFilePath);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetOverlayFromFile SetOverlayFromFile;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref ETextureType pAPIType, ref EColorSpace pColorSpace, ref VRTextureBounds_t pTextureBounds);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTexture GetOverlayTexture;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _ReleaseNativeOverlayHandle(ulong ulOverlayHandle, IntPtr pNativeTextureHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReleaseNativeOverlayHandle ReleaseNativeOverlayHandle;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetOverlayTextureSize(ulong ulOverlayHandle, ref uint pWidth, ref uint pHeight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOverlayTextureSize GetOverlayTextureSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _CreateDashboardOverlay(IntPtr pchOverlayKey, IntPtr pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CreateDashboardOverlay CreateDashboardOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsDashboardVisible();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsDashboardVisible IsDashboardVisible;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsActiveDashboardOverlay(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsActiveDashboardOverlay IsActiveDashboardOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _SetDashboardOverlaySceneProcess(ulong ulOverlayHandle, uint unProcessId);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetDashboardOverlaySceneProcess SetDashboardOverlaySceneProcess;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _GetDashboardOverlaySceneProcess(ulong ulOverlayHandle, ref uint punProcessId);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDashboardOverlaySceneProcess GetDashboardOverlaySceneProcess;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _ShowDashboard(IntPtr pchOverlayToShow);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowDashboard ShowDashboard;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetPrimaryDashboardDevice();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetPrimaryDashboardDevice GetPrimaryDashboardDevice;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _ShowKeyboard(int eInputMode, int eLineInputMode, uint unFlags, IntPtr pchDescription, uint unCharMax, IntPtr pchExistingText, ulong uUserValue);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowKeyboard ShowKeyboard;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _ShowKeyboardForOverlay(ulong ulOverlayHandle, int eInputMode, int eLineInputMode, uint unFlags, IntPtr pchDescription, uint unCharMax, IntPtr pchExistingText, ulong uUserValue);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowKeyboardForOverlay ShowKeyboardForOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetKeyboardText(System.Text.StringBuilder pchText, uint cchText);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetKeyboardText GetKeyboardText;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _HideKeyboard();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _HideKeyboard HideKeyboard;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetKeyboardTransformAbsolute SetKeyboardTransformAbsolute;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetKeyboardPositionForOverlay(ulong ulOverlayHandle, HmdRect2_t avoidRect);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetKeyboardPositionForOverlay SetKeyboardPositionForOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate VRMessageOverlayResponse _ShowMessageOverlay(IntPtr pchText, IntPtr pchCaption, IntPtr pchButton0Text, IntPtr pchButton1Text, IntPtr pchButton2Text, IntPtr pchButton3Text);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowMessageOverlay ShowMessageOverlay;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _CloseMessageOverlay();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CloseMessageOverlay CloseMessageOverlay;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVROverlayView
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _AcquireOverlayView(ulong ulOverlayHandle, ref VRNativeDevice_t pNativeDevice, ref VROverlayView_t pOverlayView, uint unOverlayViewSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _AcquireOverlayView AcquireOverlayView;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVROverlayError _ReleaseOverlayView(ref VROverlayView_t pOverlayView);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReleaseOverlayView ReleaseOverlayView;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _PostOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pvrEvent);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _PostOverlayEvent PostOverlayEvent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsViewingPermitted(ulong ulOverlayHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsViewingPermitted IsViewingPermitted;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRHeadsetView
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetHeadsetViewSize(uint nWidth, uint nHeight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetHeadsetViewSize SetHeadsetViewSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetHeadsetViewSize(ref uint pnWidth, ref uint pnHeight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetHeadsetViewSize GetHeadsetViewSize;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetHeadsetViewMode(uint eHeadsetViewMode);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetHeadsetViewMode SetHeadsetViewMode;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetHeadsetViewMode();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetHeadsetViewMode GetHeadsetViewMode;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetHeadsetViewCropped(bool bCropped);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetHeadsetViewCropped SetHeadsetViewCropped;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetHeadsetViewCropped();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetHeadsetViewCropped GetHeadsetViewCropped;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate float _GetHeadsetViewAspectRatio();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetHeadsetViewAspectRatio GetHeadsetViewAspectRatio;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetHeadsetViewBlendRange(float flStartPct, float flEndPct);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetHeadsetViewBlendRange SetHeadsetViewBlendRange;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetHeadsetViewBlendRange(ref float pStartPct, ref float pEndPct);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetHeadsetViewBlendRange GetHeadsetViewBlendRange;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRRenderModels
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRRenderModelError _LoadRenderModel_Async(IntPtr pchRenderModelName, ref IntPtr ppRenderModel);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LoadRenderModel_Async LoadRenderModel_Async;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _FreeRenderModel(IntPtr pRenderModel);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _FreeRenderModel FreeRenderModel;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRRenderModelError _LoadTexture_Async(int textureId, ref IntPtr ppTexture);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LoadTexture_Async LoadTexture_Async;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _FreeTexture(IntPtr pTexture);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _FreeTexture FreeTexture;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRRenderModelError _LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LoadTextureD3D11_Async LoadTextureD3D11_Async;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRRenderModelError _LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LoadIntoTextureD3D11_Async LoadIntoTextureD3D11_Async;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _FreeTextureD3D11(IntPtr pD3D11Texture2D);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _FreeTextureD3D11 FreeTextureD3D11;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetRenderModelName GetRenderModelName;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetRenderModelCount();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetRenderModelCount GetRenderModelCount;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetComponentCount(IntPtr pchRenderModelName);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetComponentCount GetComponentCount;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetComponentName(IntPtr pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetComponentName GetComponentName;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ulong _GetComponentButtonMask(IntPtr pchRenderModelName, IntPtr pchComponentName);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetComponentButtonMask GetComponentButtonMask;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetComponentRenderModelName(IntPtr pchRenderModelName, IntPtr pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetComponentRenderModelName GetComponentRenderModelName;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetComponentStateForDevicePath(IntPtr pchRenderModelName, IntPtr pchComponentName, ulong devicePath, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetComponentStateForDevicePath GetComponentStateForDevicePath;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetComponentState(IntPtr pchRenderModelName, IntPtr pchComponentName, ref VRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetComponentState GetComponentState;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _RenderModelHasComponent(IntPtr pchRenderModelName, IntPtr pchComponentName);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _RenderModelHasComponent RenderModelHasComponent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetRenderModelThumbnailURL(IntPtr pchRenderModelName, System.Text.StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetRenderModelThumbnailURL GetRenderModelThumbnailURL;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetRenderModelOriginalPath(IntPtr pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetRenderModelOriginalPath GetRenderModelOriginalPath;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetRenderModelErrorNameFromEnum(EVRRenderModelError error);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetRenderModelErrorNameFromEnum GetRenderModelErrorNameFromEnum;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRNotifications
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRNotificationError _CreateNotification(ulong ulOverlayHandle, ulong ulUserValue, EVRNotificationType type, IntPtr pchText, EVRNotificationStyle style, ref NotificationBitmap_t pImage, ref uint pNotificationId);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CreateNotification CreateNotification;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRNotificationError _RemoveNotification(uint notificationId);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _RemoveNotification RemoveNotification;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRSettings
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetSettingsErrorNameFromEnum(EVRSettingsError eError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSettingsErrorNameFromEnum GetSettingsErrorNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetBool(IntPtr pchSection, IntPtr pchSettingsKey, bool bValue, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetBool SetBool;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetInt32(IntPtr pchSection, IntPtr pchSettingsKey, int nValue, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetInt32 SetInt32;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetFloat(IntPtr pchSection, IntPtr pchSettingsKey, float flValue, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetFloat SetFloat;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _SetString(IntPtr pchSection, IntPtr pchSettingsKey, IntPtr pchValue, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetString SetString;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetBool(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetBool GetBool;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate int _GetInt32(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetInt32 GetInt32;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate float _GetFloat(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetFloat GetFloat;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _GetString(IntPtr pchSection, IntPtr pchSettingsKey, System.Text.StringBuilder pchValue, uint unValueLen, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetString GetString;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _RemoveSection(IntPtr pchSection, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _RemoveSection RemoveSection;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate void _RemoveKeyInSection(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _RemoveKeyInSection RemoveKeyInSection;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRScreenshots
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRScreenshotError _RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, IntPtr pchPreviewFilename, IntPtr pchVRFilename);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _RequestScreenshot RequestScreenshot;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRScreenshotError _HookScreenshot([In, Out] EVRScreenshotType[] pSupportedTypes, int numTypes);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _HookScreenshot HookScreenshot;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRScreenshotType _GetScreenshotPropertyType(uint screenshotHandle, ref EVRScreenshotError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetScreenshotPropertyType GetScreenshotPropertyType;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetScreenshotPropertyFilename(uint screenshotHandle, EVRScreenshotPropertyFilenames filenameType, System.Text.StringBuilder pchFilename, uint cchFilename, ref EVRScreenshotError pError);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetScreenshotPropertyFilename GetScreenshotPropertyFilename;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRScreenshotError _UpdateScreenshotProgress(uint screenshotHandle, float flProgress);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _UpdateScreenshotProgress UpdateScreenshotProgress;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRScreenshotError _TakeStereoScreenshot(ref uint pOutScreenshotHandle, IntPtr pchPreviewFilename, IntPtr pchVRFilename);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _TakeStereoScreenshot TakeStereoScreenshot;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRScreenshotError _SubmitScreenshot(uint screenshotHandle, EVRScreenshotType type, IntPtr pchSourcePreviewFilename, IntPtr pchSourceVRFilename);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SubmitScreenshot SubmitScreenshot;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRResources
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _LoadSharedResource(IntPtr pchResourceName, string pchBuffer, uint unBufferLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _LoadSharedResource LoadSharedResource;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetResourceFullPath(IntPtr pchResourceName, IntPtr pchResourceTypeDirectory, System.Text.StringBuilder pchPathBuffer, uint unBufferLen);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetResourceFullPath GetResourceFullPath;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRDriverManager
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetDriverCount();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDriverCount GetDriverCount;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _GetDriverName(uint nDriver, System.Text.StringBuilder pchValue, uint unBufferSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDriverName GetDriverName;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ulong _GetDriverHandle(IntPtr pchDriverName);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDriverHandle GetDriverHandle;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsEnabled(uint nDriver);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsEnabled IsEnabled;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRInput
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _SetActionManifestPath(IntPtr pchActionManifestPath);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetActionManifestPath SetActionManifestPath;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetActionSetHandle(IntPtr pchActionSetName, ref ulong pHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetActionSetHandle GetActionSetHandle;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetActionHandle(IntPtr pchActionName, ref ulong pHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetActionHandle GetActionHandle;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetInputSourceHandle(IntPtr pchInputSourcePath, ref ulong pHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetInputSourceHandle GetInputSourceHandle;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _UpdateActionState([In, Out] VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, uint unSetCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _UpdateActionState UpdateActionState;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetDigitalActionData(ulong action, ref InputDigitalActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDigitalActionData GetDigitalActionData;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetAnalogActionData(ulong action, ref InputAnalogActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetAnalogActionData GetAnalogActionData;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetPoseActionDataRelativeToNow(ulong action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, ref InputPoseActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetPoseActionDataRelativeToNow GetPoseActionDataRelativeToNow;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetPoseActionDataForNextFrame(ulong action, ETrackingUniverseOrigin eOrigin, ref InputPoseActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetPoseActionDataForNextFrame GetPoseActionDataForNextFrame;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetSkeletalActionData(ulong action, ref InputSkeletalActionData_t pActionData, uint unActionDataSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSkeletalActionData GetSkeletalActionData;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetDominantHand(ref ETrackedControllerRole peDominantHand);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetDominantHand GetDominantHand;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _SetDominantHand(ETrackedControllerRole eDominantHand);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _SetDominantHand SetDominantHand;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetBoneCount(ulong action, ref uint pBoneCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetBoneCount GetBoneCount;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetBoneHierarchy(ulong action, [In, Out] int[] pParentIndices, uint unIndexArayCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetBoneHierarchy GetBoneHierarchy;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetBoneName(ulong action, int nBoneIndex, System.Text.StringBuilder pchBoneName, uint unNameBufferSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetBoneName GetBoneName;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetSkeletalReferenceTransforms(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSkeletalReferenceTransforms GetSkeletalReferenceTransforms;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetSkeletalTrackingLevel(ulong action, ref EVRSkeletalTrackingLevel pSkeletalTrackingLevel);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSkeletalTrackingLevel GetSkeletalTrackingLevel;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetSkeletalBoneData(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSkeletalBoneData GetSkeletalBoneData;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetSkeletalSummaryData(ulong action, EVRSummaryType eSummaryType, ref VRSkeletalSummaryData_t pSkeletalSummaryData);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSkeletalSummaryData GetSkeletalSummaryData;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetSkeletalBoneDataCompressed(ulong action, EVRSkeletalMotionRange eMotionRange, IntPtr pvCompressedData, uint unCompressedSize, ref uint punRequiredCompressedSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSkeletalBoneDataCompressed GetSkeletalBoneDataCompressed;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _DecompressSkeletalBoneData(IntPtr pvCompressedBuffer, uint unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _DecompressSkeletalBoneData DecompressSkeletalBoneData;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _TriggerHapticVibrationAction(ulong action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, ulong ulRestrictToDevice);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _TriggerHapticVibrationAction TriggerHapticVibrationAction;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetActionOrigins(ulong actionSetHandle, ulong digitalActionHandle, [In, Out] ulong[] originsOut, uint originOutCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetActionOrigins GetActionOrigins;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetOriginLocalizedName(ulong origin, System.Text.StringBuilder pchNameArray, uint unNameArraySize, int unStringSectionsToInclude);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOriginLocalizedName GetOriginLocalizedName;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetOriginTrackedDeviceInfo(ulong origin, ref InputOriginInfo_t pOriginInfo, uint unOriginInfoSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetOriginTrackedDeviceInfo GetOriginTrackedDeviceInfo;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetActionBindingInfo(ulong action, ref InputBindingInfo_t pOriginInfo, uint unBindingInfoSize, uint unBindingInfoCount, ref uint punReturnedBindingInfoCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetActionBindingInfo GetActionBindingInfo;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _ShowActionOrigins(ulong actionSetHandle, ulong ulActionHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowActionOrigins ShowActionOrigins;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _ShowBindingsForActionSet([In, Out] VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, uint unSetCount, ulong originToHighlight);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ShowBindingsForActionSet ShowBindingsForActionSet;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetComponentStateForBinding(IntPtr pchRenderModelName, IntPtr pchComponentName, ref InputBindingInfo_t pOriginInfo, uint unBindingInfoSize, uint unBindingInfoCount, ref RenderModel_ComponentState_t pComponentState);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetComponentStateForBinding GetComponentStateForBinding;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _IsUsingLegacyInput();
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _IsUsingLegacyInput IsUsingLegacyInput;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _OpenBindingUI(IntPtr pchAppKey, ulong ulActionSetHandle, ulong ulDeviceHandle, bool bShowOnDesktop);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _OpenBindingUI OpenBindingUI;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRInputError _GetBindingVariant(ulong ulDevicePath, System.Text.StringBuilder pchVariantArray, uint unVariantArraySize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetBindingVariant GetBindingVariant;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRIOBuffer
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EIOBufferError _Open(IntPtr pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _Open Open;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EIOBufferError _Close(ulong ulBuffer);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _Close Close;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EIOBufferError _Read(ulong ulBuffer, IntPtr pDst, uint unBytes, ref uint punRead);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _Read Read;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EIOBufferError _Write(ulong ulBuffer, IntPtr pSrc, uint unBytes);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _Write Write;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ulong _PropertyContainer(ulong ulBuffer);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _PropertyContainer PropertyContainer;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _HasReaders(ulong ulBuffer);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _HasReaders HasReaders;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRSpatialAnchors
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromDescriptor(IntPtr pchDescriptor, ref uint pHandleOut);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CreateSpatialAnchorFromDescriptor CreateSpatialAnchorFromDescriptor;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromPose(uint unDeviceIndex, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPose, ref uint pHandleOut);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _CreateSpatialAnchorFromPose CreateSpatialAnchorFromPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRSpatialAnchorError _GetSpatialAnchorPose(uint unHandle, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPoseOut);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSpatialAnchorPose GetSpatialAnchorPose;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRSpatialAnchorError _GetSpatialAnchorDescriptor(uint unHandle, System.Text.StringBuilder pchDescriptorOut, ref uint punDescriptorBufferLenInOut);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetSpatialAnchorDescriptor GetSpatialAnchorDescriptor;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRDebug
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRDebugError _EmitVrProfilerEvent(IntPtr pchMessage);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _EmitVrProfilerEvent EmitVrProfilerEvent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRDebugError _BeginVrProfilerEvent(ref ulong pHandleOut);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _BeginVrProfilerEvent BeginVrProfilerEvent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EVRDebugError _FinishVrProfilerEvent(ulong hHandle, IntPtr pchMessage);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _FinishVrProfilerEvent FinishVrProfilerEvent;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate uint _DriverDebugRequest(uint unDeviceIndex, IntPtr pchRequest, System.Text.StringBuilder pchResponseBuffer, uint unResponseBufferSize);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _DriverDebugRequest DriverDebugRequest;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRProperties
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackedPropertyError _ReadPropertyBatch(ulong ulContainerHandle, ref PropertyRead_t pBatch, uint unBatchEntryCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReadPropertyBatch ReadPropertyBatch;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackedPropertyError _WritePropertyBatch(ulong ulContainerHandle, ref PropertyWrite_t pBatch, uint unBatchEntryCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _WritePropertyBatch WritePropertyBatch;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate IntPtr _GetPropErrorNameFromEnum(ETrackedPropertyError error);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _GetPropErrorNameFromEnum GetPropErrorNameFromEnum;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ulong _TrackedDeviceToPropertyContainer(uint nDevice);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _TrackedDeviceToPropertyContainer TrackedDeviceToPropertyContainer;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRPaths
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackedPropertyError _ReadPathBatch(ulong ulRootHandle, ref PathRead_t pBatch, uint unBatchEntryCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReadPathBatch ReadPathBatch;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackedPropertyError _WritePathBatch(ulong ulRootHandle, ref PathWrite_t pBatch, uint unBatchEntryCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _WritePathBatch WritePathBatch;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackedPropertyError _StringToHandle(ref ulong pHandle, IntPtr pchPath);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _StringToHandle StringToHandle;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate ETrackedPropertyError _HandleToString(ulong pHandle, string pchBuffer, uint unBufferSize, ref uint punBufferSizeUsed);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _HandleToString HandleToString;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRBlockQueue
+{
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _Create(ref ulong pulQueueHandle, IntPtr pchPath, uint unBlockDataSize, uint unBlockHeaderSize, uint unBlockCount);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _Create Create;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _Connect(ref ulong pulQueueHandle, IntPtr pchPath);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _Connect Connect;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _Destroy(ulong ulQueueHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _Destroy Destroy;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _AcquireWriteOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _AcquireWriteOnlyBlock AcquireWriteOnlyBlock;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _ReleaseWriteOnlyBlock(ulong ulQueueHandle, ulong ulBlockHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReleaseWriteOnlyBlock ReleaseWriteOnlyBlock;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _WaitAndAcquireReadOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer, EBlockQueueReadType eReadType, uint unTimeoutMs);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _WaitAndAcquireReadOnlyBlock WaitAndAcquireReadOnlyBlock;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _AcquireReadOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer, EBlockQueueReadType eReadType);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _AcquireReadOnlyBlock AcquireReadOnlyBlock;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _ReleaseReadOnlyBlock(ulong ulQueueHandle, ulong ulBlockHandle);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _ReleaseReadOnlyBlock ReleaseReadOnlyBlock;
+
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate EBlockQueueError _QueueHasReader(ulong ulQueueHandle, ref bool pbHasReaders);
+	[MarshalAs(UnmanagedType.FunctionPtr)]
+	internal _QueueHasReader QueueHasReader;
+
+}
+
+
+public class Utils
+{
+	public static IntPtr ToUtf8(string managedString)
+	{
+		if (managedString == null)
+		{
+			return IntPtr.Zero;
+		}
+
+		int size = System.Text.Encoding.UTF8.GetByteCount(managedString) + 1;
+		if (buffer.Length < size) buffer = new byte[size];
+		int written = System.Text.Encoding.UTF8.GetBytes(managedString, 0, managedString.Length, buffer, 0);
+		buffer[written] = 0x00; // null terminate
+		IntPtr nativeUtf8 = Marshal.AllocHGlobal(written+1);
+		Marshal.Copy(buffer, 0, nativeUtf8, written+1);
+		return nativeUtf8;
+	}
+	private static byte[] buffer = new byte[1024];
+}
+
+public class CVRSystem
+{
+	IVRSystem FnTable;
+	internal CVRSystem(IntPtr pInterface)
+	{
+		FnTable = (IVRSystem)Marshal.PtrToStructure(pInterface, typeof(IVRSystem));
+	}
+	public void GetRecommendedRenderTargetSize(ref uint pnWidth,ref uint pnHeight)
+	{
+		pnWidth = 0;
+		pnHeight = 0;
+		FnTable.GetRecommendedRenderTargetSize(ref pnWidth,ref pnHeight);
+	}
+	public HmdMatrix44_t GetProjectionMatrix(EVREye eEye,float fNearZ,float fFarZ)
+	{
+		HmdMatrix44_t result = FnTable.GetProjectionMatrix(eEye,fNearZ,fFarZ);
+		return result;
+	}
+	public void GetProjectionRaw(EVREye eEye,ref float pfLeft,ref float pfRight,ref float pfTop,ref float pfBottom)
+	{
+		pfLeft = 0;
+		pfRight = 0;
+		pfTop = 0;
+		pfBottom = 0;
+		FnTable.GetProjectionRaw(eEye,ref pfLeft,ref pfRight,ref pfTop,ref pfBottom);
+	}
+	public bool ComputeDistortion(EVREye eEye,float fU,float fV,ref DistortionCoordinates_t pDistortionCoordinates)
+	{
+		bool result = FnTable.ComputeDistortion(eEye,fU,fV,ref pDistortionCoordinates);
+		return result;
+	}
+	public HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye)
+	{
+		HmdMatrix34_t result = FnTable.GetEyeToHeadTransform(eEye);
+		return result;
+	}
+	public bool GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync,ref ulong pulFrameCounter)
+	{
+		pfSecondsSinceLastVsync = 0;
+		pulFrameCounter = 0;
+		bool result = FnTable.GetTimeSinceLastVsync(ref pfSecondsSinceLastVsync,ref pulFrameCounter);
+		return result;
+	}
+	public int GetD3D9AdapterIndex()
+	{
+		int result = FnTable.GetD3D9AdapterIndex();
+		return result;
+	}
+	public void GetDXGIOutputInfo(ref int pnAdapterIndex)
+	{
+		pnAdapterIndex = 0;
+		FnTable.GetDXGIOutputInfo(ref pnAdapterIndex);
+	}
+	public void GetOutputDevice(ref ulong pnDevice,ETextureType textureType,IntPtr pInstance)
+	{
+		pnDevice = 0;
+		FnTable.GetOutputDevice(ref pnDevice,textureType,pInstance);
+	}
+	public bool IsDisplayOnDesktop()
+	{
+		bool result = FnTable.IsDisplayOnDesktop();
+		return result;
+	}
+	public bool SetDisplayVisibility(bool bIsVisibleOnDesktop)
+	{
+		bool result = FnTable.SetDisplayVisibility(bIsVisibleOnDesktop);
+		return result;
+	}
+	public void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin,float fPredictedSecondsToPhotonsFromNow,TrackedDevicePose_t [] pTrackedDevicePoseArray)
+	{
+		FnTable.GetDeviceToAbsoluteTrackingPose(eOrigin,fPredictedSecondsToPhotonsFromNow,pTrackedDevicePoseArray,(uint) pTrackedDevicePoseArray.Length);
+	}
+	public HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose()
+	{
+		HmdMatrix34_t result = FnTable.GetSeatedZeroPoseToStandingAbsoluteTrackingPose();
+		return result;
+	}
+	public HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose()
+	{
+		HmdMatrix34_t result = FnTable.GetRawZeroPoseToStandingAbsoluteTrackingPose();
+		return result;
+	}
+	public uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass,uint [] punTrackedDeviceIndexArray,uint unRelativeToTrackedDeviceIndex)
+	{
+		uint result = FnTable.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass,punTrackedDeviceIndexArray,(uint) punTrackedDeviceIndexArray.Length,unRelativeToTrackedDeviceIndex);
+		return result;
+	}
+	public EDeviceActivityLevel GetTrackedDeviceActivityLevel(uint unDeviceId)
+	{
+		EDeviceActivityLevel result = FnTable.GetTrackedDeviceActivityLevel(unDeviceId);
+		return result;
+	}
+	public void ApplyTransform(ref TrackedDevicePose_t pOutputPose,ref TrackedDevicePose_t pTrackedDevicePose,ref HmdMatrix34_t pTransform)
+	{
+		FnTable.ApplyTransform(ref pOutputPose,ref pTrackedDevicePose,ref pTransform);
+	}
+	public uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType)
+	{
+		uint result = FnTable.GetTrackedDeviceIndexForControllerRole(unDeviceType);
+		return result;
+	}
+	public ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex)
+	{
+		ETrackedControllerRole result = FnTable.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex);
+		return result;
+	}
+	public ETrackedDeviceClass GetTrackedDeviceClass(uint unDeviceIndex)
+	{
+		ETrackedDeviceClass result = FnTable.GetTrackedDeviceClass(unDeviceIndex);
+		return result;
+	}
+	public bool IsTrackedDeviceConnected(uint unDeviceIndex)
+	{
+		bool result = FnTable.IsTrackedDeviceConnected(unDeviceIndex);
+		return result;
+	}
+	public bool GetBoolTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError)
+	{
+		bool result = FnTable.GetBoolTrackedDeviceProperty(unDeviceIndex,prop,ref pError);
+		return result;
+	}
+	public float GetFloatTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError)
+	{
+		float result = FnTable.GetFloatTrackedDeviceProperty(unDeviceIndex,prop,ref pError);
+		return result;
+	}
+	public int GetInt32TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError)
+	{
+		int result = FnTable.GetInt32TrackedDeviceProperty(unDeviceIndex,prop,ref pError);
+		return result;
+	}
+	public ulong GetUint64TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError)
+	{
+		ulong result = FnTable.GetUint64TrackedDeviceProperty(unDeviceIndex,prop,ref pError);
+		return result;
+	}
+	public HmdMatrix34_t GetMatrix34TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError)
+	{
+		HmdMatrix34_t result = FnTable.GetMatrix34TrackedDeviceProperty(unDeviceIndex,prop,ref pError);
+		return result;
+	}
+	public uint GetArrayTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,uint propType,IntPtr pBuffer,uint unBufferSize,ref ETrackedPropertyError pError)
+	{
+		uint result = FnTable.GetArrayTrackedDeviceProperty(unDeviceIndex,prop,propType,pBuffer,unBufferSize,ref pError);
+		return result;
+	}
+	public uint GetStringTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,System.Text.StringBuilder pchValue,uint unBufferSize,ref ETrackedPropertyError pError)
+	{
+		uint result = FnTable.GetStringTrackedDeviceProperty(unDeviceIndex,prop,pchValue,unBufferSize,ref pError);
+		return result;
+	}
+	public string GetPropErrorNameFromEnum(ETrackedPropertyError error)
+	{
+		IntPtr result = FnTable.GetPropErrorNameFromEnum(error);
+		return Marshal.PtrToStringAnsi(result);
+	}
+// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were
+// originally mis-compiled with the wrong packing for Linux and OSX.
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _PollNextEventPacked(ref VREvent_t_Packed pEvent,uint uncbVREvent);
+	[StructLayout(LayoutKind.Explicit)]
+	struct PollNextEventUnion
+	{
+		[FieldOffset(0)]
+		public IVRSystem._PollNextEvent pPollNextEvent;
+		[FieldOffset(0)]
+		public _PollNextEventPacked pPollNextEventPacked;
+	}
+	public bool PollNextEvent(ref VREvent_t pEvent,uint uncbVREvent)
+	{
+#if !UNITY_METRO
+		if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) ||
+				(System.Environment.OSVersion.Platform == System.PlatformID.Unix))
+		{
+			PollNextEventUnion u;
+			VREvent_t_Packed event_packed = new VREvent_t_Packed();
+			u.pPollNextEventPacked = null;
+			u.pPollNextEvent = FnTable.PollNextEvent;
+			bool packed_result = u.pPollNextEventPacked(ref event_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed)));
+
+			event_packed.Unpack(ref pEvent);
+			return packed_result;
+		}
+#endif
+		bool result = FnTable.PollNextEvent(ref pEvent,uncbVREvent);
+		return result;
+	}
+	public bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,ref VREvent_t pEvent,uint uncbVREvent,ref TrackedDevicePose_t pTrackedDevicePose)
+	{
+		bool result = FnTable.PollNextEventWithPose(eOrigin,ref pEvent,uncbVREvent,ref pTrackedDevicePose);
+		return result;
+	}
+	public string GetEventTypeNameFromEnum(EVREventType eType)
+	{
+		IntPtr result = FnTable.GetEventTypeNameFromEnum(eType);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye,EHiddenAreaMeshType type)
+	{
+		HiddenAreaMesh_t result = FnTable.GetHiddenAreaMesh(eEye,type);
+		return result;
+	}
+// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were
+// originally mis-compiled with the wrong packing for Linux and OSX.
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetControllerStatePacked(uint unControllerDeviceIndex,ref VRControllerState_t_Packed pControllerState,uint unControllerStateSize);
+	[StructLayout(LayoutKind.Explicit)]
+	struct GetControllerStateUnion
+	{
+		[FieldOffset(0)]
+		public IVRSystem._GetControllerState pGetControllerState;
+		[FieldOffset(0)]
+		public _GetControllerStatePacked pGetControllerStatePacked;
+	}
+	public bool GetControllerState(uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,uint unControllerStateSize)
+	{
+#if !UNITY_METRO
+		if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) ||
+				(System.Environment.OSVersion.Platform == System.PlatformID.Unix))
+		{
+			GetControllerStateUnion u;
+			VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState);
+			u.pGetControllerStatePacked = null;
+			u.pGetControllerState = FnTable.GetControllerState;
+			bool packed_result = u.pGetControllerStatePacked(unControllerDeviceIndex,ref state_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed)));
+
+			state_packed.Unpack(ref pControllerState);
+			return packed_result;
+		}
+#endif
+		bool result = FnTable.GetControllerState(unControllerDeviceIndex,ref pControllerState,unControllerStateSize);
+		return result;
+	}
+// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were
+// originally mis-compiled with the wrong packing for Linux and OSX.
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetControllerStateWithPosePacked(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t_Packed pControllerState,uint unControllerStateSize,ref TrackedDevicePose_t pTrackedDevicePose);
+	[StructLayout(LayoutKind.Explicit)]
+	struct GetControllerStateWithPoseUnion
+	{
+		[FieldOffset(0)]
+		public IVRSystem._GetControllerStateWithPose pGetControllerStateWithPose;
+		[FieldOffset(0)]
+		public _GetControllerStateWithPosePacked pGetControllerStateWithPosePacked;
+	}
+	public bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,uint unControllerStateSize,ref TrackedDevicePose_t pTrackedDevicePose)
+	{
+#if !UNITY_METRO
+		if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) ||
+				(System.Environment.OSVersion.Platform == System.PlatformID.Unix))
+		{
+			GetControllerStateWithPoseUnion u;
+			VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState);
+			u.pGetControllerStateWithPosePacked = null;
+			u.pGetControllerStateWithPose = FnTable.GetControllerStateWithPose;
+			bool packed_result = u.pGetControllerStateWithPosePacked(eOrigin,unControllerDeviceIndex,ref state_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed)),ref pTrackedDevicePose);
+
+			state_packed.Unpack(ref pControllerState);
+			return packed_result;
+		}
+#endif
+		bool result = FnTable.GetControllerStateWithPose(eOrigin,unControllerDeviceIndex,ref pControllerState,unControllerStateSize,ref pTrackedDevicePose);
+		return result;
+	}
+	public void TriggerHapticPulse(uint unControllerDeviceIndex,uint unAxisId,ushort usDurationMicroSec)
+	{
+		FnTable.TriggerHapticPulse(unControllerDeviceIndex,unAxisId,usDurationMicroSec);
+	}
+	public string GetButtonIdNameFromEnum(EVRButtonId eButtonId)
+	{
+		IntPtr result = FnTable.GetButtonIdNameFromEnum(eButtonId);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public string GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType)
+	{
+		IntPtr result = FnTable.GetControllerAxisTypeNameFromEnum(eAxisType);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public bool IsInputAvailable()
+	{
+		bool result = FnTable.IsInputAvailable();
+		return result;
+	}
+	public bool IsSteamVRDrawingControllers()
+	{
+		bool result = FnTable.IsSteamVRDrawingControllers();
+		return result;
+	}
+	public bool ShouldApplicationPause()
+	{
+		bool result = FnTable.ShouldApplicationPause();
+		return result;
+	}
+	public bool ShouldApplicationReduceRenderingWork()
+	{
+		bool result = FnTable.ShouldApplicationReduceRenderingWork();
+		return result;
+	}
+	public EVRFirmwareError PerformFirmwareUpdate(uint unDeviceIndex)
+	{
+		EVRFirmwareError result = FnTable.PerformFirmwareUpdate(unDeviceIndex);
+		return result;
+	}
+	public void AcknowledgeQuit_Exiting()
+	{
+		FnTable.AcknowledgeQuit_Exiting();
+	}
+	public uint GetAppContainerFilePaths(System.Text.StringBuilder pchBuffer,uint unBufferSize)
+	{
+		uint result = FnTable.GetAppContainerFilePaths(pchBuffer,unBufferSize);
+		return result;
+	}
+	public string GetRuntimeVersion()
+	{
+		IntPtr result = FnTable.GetRuntimeVersion();
+		return Marshal.PtrToStringAnsi(result);
+	}
+}
+
+
+public class CVRExtendedDisplay
+{
+	IVRExtendedDisplay FnTable;
+	internal CVRExtendedDisplay(IntPtr pInterface)
+	{
+		FnTable = (IVRExtendedDisplay)Marshal.PtrToStructure(pInterface, typeof(IVRExtendedDisplay));
+	}
+	public void GetWindowBounds(ref int pnX,ref int pnY,ref uint pnWidth,ref uint pnHeight)
+	{
+		pnX = 0;
+		pnY = 0;
+		pnWidth = 0;
+		pnHeight = 0;
+		FnTable.GetWindowBounds(ref pnX,ref pnY,ref pnWidth,ref pnHeight);
+	}
+	public void GetEyeOutputViewport(EVREye eEye,ref uint pnX,ref uint pnY,ref uint pnWidth,ref uint pnHeight)
+	{
+		pnX = 0;
+		pnY = 0;
+		pnWidth = 0;
+		pnHeight = 0;
+		FnTable.GetEyeOutputViewport(eEye,ref pnX,ref pnY,ref pnWidth,ref pnHeight);
+	}
+	public void GetDXGIOutputInfo(ref int pnAdapterIndex,ref int pnAdapterOutputIndex)
+	{
+		pnAdapterIndex = 0;
+		pnAdapterOutputIndex = 0;
+		FnTable.GetDXGIOutputInfo(ref pnAdapterIndex,ref pnAdapterOutputIndex);
+	}
+}
+
+
+public class CVRTrackedCamera
+{
+	IVRTrackedCamera FnTable;
+	internal CVRTrackedCamera(IntPtr pInterface)
+	{
+		FnTable = (IVRTrackedCamera)Marshal.PtrToStructure(pInterface, typeof(IVRTrackedCamera));
+	}
+	public string GetCameraErrorNameFromEnum(EVRTrackedCameraError eCameraError)
+	{
+		IntPtr result = FnTable.GetCameraErrorNameFromEnum(eCameraError);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public EVRTrackedCameraError HasCamera(uint nDeviceIndex,ref bool pHasCamera)
+	{
+		pHasCamera = false;
+		EVRTrackedCameraError result = FnTable.HasCamera(nDeviceIndex,ref pHasCamera);
+		return result;
+	}
+	public EVRTrackedCameraError GetCameraFrameSize(uint nDeviceIndex,EVRTrackedCameraFrameType eFrameType,ref uint pnWidth,ref uint pnHeight,ref uint pnFrameBufferSize)
+	{
+		pnWidth = 0;
+		pnHeight = 0;
+		pnFrameBufferSize = 0;
+		EVRTrackedCameraError result = FnTable.GetCameraFrameSize(nDeviceIndex,eFrameType,ref pnWidth,ref pnHeight,ref pnFrameBufferSize);
+		return result;
+	}
+	public EVRTrackedCameraError GetCameraIntrinsics(uint nDeviceIndex,uint nCameraIndex,EVRTrackedCameraFrameType eFrameType,ref HmdVector2_t pFocalLength,ref HmdVector2_t pCenter)
+	{
+		EVRTrackedCameraError result = FnTable.GetCameraIntrinsics(nDeviceIndex,nCameraIndex,eFrameType,ref pFocalLength,ref pCenter);
+		return result;
+	}
+	public EVRTrackedCameraError GetCameraProjection(uint nDeviceIndex,uint nCameraIndex,EVRTrackedCameraFrameType eFrameType,float flZNear,float flZFar,ref HmdMatrix44_t pProjection)
+	{
+		EVRTrackedCameraError result = FnTable.GetCameraProjection(nDeviceIndex,nCameraIndex,eFrameType,flZNear,flZFar,ref pProjection);
+		return result;
+	}
+	public EVRTrackedCameraError AcquireVideoStreamingService(uint nDeviceIndex,ref ulong pHandle)
+	{
+		pHandle = 0;
+		EVRTrackedCameraError result = FnTable.AcquireVideoStreamingService(nDeviceIndex,ref pHandle);
+		return result;
+	}
+	public EVRTrackedCameraError ReleaseVideoStreamingService(ulong hTrackedCamera)
+	{
+		EVRTrackedCameraError result = FnTable.ReleaseVideoStreamingService(hTrackedCamera);
+		return result;
+	}
+	public EVRTrackedCameraError GetVideoStreamFrameBuffer(ulong hTrackedCamera,EVRTrackedCameraFrameType eFrameType,IntPtr pFrameBuffer,uint nFrameBufferSize,ref CameraVideoStreamFrameHeader_t pFrameHeader,uint nFrameHeaderSize)
+	{
+		EVRTrackedCameraError result = FnTable.GetVideoStreamFrameBuffer(hTrackedCamera,eFrameType,pFrameBuffer,nFrameBufferSize,ref pFrameHeader,nFrameHeaderSize);
+		return result;
+	}
+	public EVRTrackedCameraError GetVideoStreamTextureSize(uint nDeviceIndex,EVRTrackedCameraFrameType eFrameType,ref VRTextureBounds_t pTextureBounds,ref uint pnWidth,ref uint pnHeight)
+	{
+		pnWidth = 0;
+		pnHeight = 0;
+		EVRTrackedCameraError result = FnTable.GetVideoStreamTextureSize(nDeviceIndex,eFrameType,ref pTextureBounds,ref pnWidth,ref pnHeight);
+		return result;
+	}
+	public EVRTrackedCameraError GetVideoStreamTextureD3D11(ulong hTrackedCamera,EVRTrackedCameraFrameType eFrameType,IntPtr pD3D11DeviceOrResource,ref IntPtr ppD3D11ShaderResourceView,ref CameraVideoStreamFrameHeader_t pFrameHeader,uint nFrameHeaderSize)
+	{
+		EVRTrackedCameraError result = FnTable.GetVideoStreamTextureD3D11(hTrackedCamera,eFrameType,pD3D11DeviceOrResource,ref ppD3D11ShaderResourceView,ref pFrameHeader,nFrameHeaderSize);
+		return result;
+	}
+	public EVRTrackedCameraError GetVideoStreamTextureGL(ulong hTrackedCamera,EVRTrackedCameraFrameType eFrameType,ref uint pglTextureId,ref CameraVideoStreamFrameHeader_t pFrameHeader,uint nFrameHeaderSize)
+	{
+		pglTextureId = 0;
+		EVRTrackedCameraError result = FnTable.GetVideoStreamTextureGL(hTrackedCamera,eFrameType,ref pglTextureId,ref pFrameHeader,nFrameHeaderSize);
+		return result;
+	}
+	public EVRTrackedCameraError ReleaseVideoStreamTextureGL(ulong hTrackedCamera,uint glTextureId)
+	{
+		EVRTrackedCameraError result = FnTable.ReleaseVideoStreamTextureGL(hTrackedCamera,glTextureId);
+		return result;
+	}
+	public void SetCameraTrackingSpace(ETrackingUniverseOrigin eUniverse)
+	{
+		FnTable.SetCameraTrackingSpace(eUniverse);
+	}
+	public ETrackingUniverseOrigin GetCameraTrackingSpace()
+	{
+		ETrackingUniverseOrigin result = FnTable.GetCameraTrackingSpace();
+		return result;
+	}
+}
+
+
+public class CVRApplications
+{
+	IVRApplications FnTable;
+	internal CVRApplications(IntPtr pInterface)
+	{
+		FnTable = (IVRApplications)Marshal.PtrToStructure(pInterface, typeof(IVRApplications));
+	}
+	public EVRApplicationError AddApplicationManifest(string pchApplicationManifestFullPath,bool bTemporary)
+	{
+		IntPtr pchApplicationManifestFullPathUtf8 = Utils.ToUtf8(pchApplicationManifestFullPath);
+		EVRApplicationError result = FnTable.AddApplicationManifest(pchApplicationManifestFullPathUtf8,bTemporary);
+		Marshal.FreeHGlobal(pchApplicationManifestFullPathUtf8);
+		return result;
+	}
+	public EVRApplicationError RemoveApplicationManifest(string pchApplicationManifestFullPath)
+	{
+		IntPtr pchApplicationManifestFullPathUtf8 = Utils.ToUtf8(pchApplicationManifestFullPath);
+		EVRApplicationError result = FnTable.RemoveApplicationManifest(pchApplicationManifestFullPathUtf8);
+		Marshal.FreeHGlobal(pchApplicationManifestFullPathUtf8);
+		return result;
+	}
+	public bool IsApplicationInstalled(string pchAppKey)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		bool result = FnTable.IsApplicationInstalled(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public uint GetApplicationCount()
+	{
+		uint result = FnTable.GetApplicationCount();
+		return result;
+	}
+	public EVRApplicationError GetApplicationKeyByIndex(uint unApplicationIndex,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen)
+	{
+		EVRApplicationError result = FnTable.GetApplicationKeyByIndex(unApplicationIndex,pchAppKeyBuffer,unAppKeyBufferLen);
+		return result;
+	}
+	public EVRApplicationError GetApplicationKeyByProcessId(uint unProcessId,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen)
+	{
+		EVRApplicationError result = FnTable.GetApplicationKeyByProcessId(unProcessId,pchAppKeyBuffer,unAppKeyBufferLen);
+		return result;
+	}
+	public EVRApplicationError LaunchApplication(string pchAppKey)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.LaunchApplication(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public EVRApplicationError LaunchTemplateApplication(string pchTemplateAppKey,string pchNewAppKey,AppOverrideKeys_t [] pKeys)
+	{
+		IntPtr pchTemplateAppKeyUtf8 = Utils.ToUtf8(pchTemplateAppKey);
+		IntPtr pchNewAppKeyUtf8 = Utils.ToUtf8(pchNewAppKey);
+		EVRApplicationError result = FnTable.LaunchTemplateApplication(pchTemplateAppKeyUtf8,pchNewAppKeyUtf8,pKeys,(uint) pKeys.Length);
+		Marshal.FreeHGlobal(pchTemplateAppKeyUtf8);
+		Marshal.FreeHGlobal(pchNewAppKeyUtf8);
+		return result;
+	}
+	public EVRApplicationError LaunchApplicationFromMimeType(string pchMimeType,string pchArgs)
+	{
+		IntPtr pchMimeTypeUtf8 = Utils.ToUtf8(pchMimeType);
+		IntPtr pchArgsUtf8 = Utils.ToUtf8(pchArgs);
+		EVRApplicationError result = FnTable.LaunchApplicationFromMimeType(pchMimeTypeUtf8,pchArgsUtf8);
+		Marshal.FreeHGlobal(pchMimeTypeUtf8);
+		Marshal.FreeHGlobal(pchArgsUtf8);
+		return result;
+	}
+	public EVRApplicationError LaunchDashboardOverlay(string pchAppKey)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.LaunchDashboardOverlay(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public bool CancelApplicationLaunch(string pchAppKey)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		bool result = FnTable.CancelApplicationLaunch(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public EVRApplicationError IdentifyApplication(uint unProcessId,string pchAppKey)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.IdentifyApplication(unProcessId,pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public uint GetApplicationProcessId(string pchAppKey)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		uint result = FnTable.GetApplicationProcessId(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public string GetApplicationsErrorNameFromEnum(EVRApplicationError error)
+	{
+		IntPtr result = FnTable.GetApplicationsErrorNameFromEnum(error);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public uint GetApplicationPropertyString(string pchAppKey,EVRApplicationProperty eProperty,System.Text.StringBuilder pchPropertyValueBuffer,uint unPropertyValueBufferLen,ref EVRApplicationError peError)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		uint result = FnTable.GetApplicationPropertyString(pchAppKeyUtf8,eProperty,pchPropertyValueBuffer,unPropertyValueBufferLen,ref peError);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public bool GetApplicationPropertyBool(string pchAppKey,EVRApplicationProperty eProperty,ref EVRApplicationError peError)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		bool result = FnTable.GetApplicationPropertyBool(pchAppKeyUtf8,eProperty,ref peError);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public ulong GetApplicationPropertyUint64(string pchAppKey,EVRApplicationProperty eProperty,ref EVRApplicationError peError)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		ulong result = FnTable.GetApplicationPropertyUint64(pchAppKeyUtf8,eProperty,ref peError);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public EVRApplicationError SetApplicationAutoLaunch(string pchAppKey,bool bAutoLaunch)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.SetApplicationAutoLaunch(pchAppKeyUtf8,bAutoLaunch);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public bool GetApplicationAutoLaunch(string pchAppKey)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		bool result = FnTable.GetApplicationAutoLaunch(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public EVRApplicationError SetDefaultApplicationForMimeType(string pchAppKey,string pchMimeType)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		IntPtr pchMimeTypeUtf8 = Utils.ToUtf8(pchMimeType);
+		EVRApplicationError result = FnTable.SetDefaultApplicationForMimeType(pchAppKeyUtf8,pchMimeTypeUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchMimeTypeUtf8);
+		return result;
+	}
+	public bool GetDefaultApplicationForMimeType(string pchMimeType,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen)
+	{
+		IntPtr pchMimeTypeUtf8 = Utils.ToUtf8(pchMimeType);
+		bool result = FnTable.GetDefaultApplicationForMimeType(pchMimeTypeUtf8,pchAppKeyBuffer,unAppKeyBufferLen);
+		Marshal.FreeHGlobal(pchMimeTypeUtf8);
+		return result;
+	}
+	public bool GetApplicationSupportedMimeTypes(string pchAppKey,System.Text.StringBuilder pchMimeTypesBuffer,uint unMimeTypesBuffer)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		bool result = FnTable.GetApplicationSupportedMimeTypes(pchAppKeyUtf8,pchMimeTypesBuffer,unMimeTypesBuffer);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public uint GetApplicationsThatSupportMimeType(string pchMimeType,System.Text.StringBuilder pchAppKeysThatSupportBuffer,uint unAppKeysThatSupportBuffer)
+	{
+		IntPtr pchMimeTypeUtf8 = Utils.ToUtf8(pchMimeType);
+		uint result = FnTable.GetApplicationsThatSupportMimeType(pchMimeTypeUtf8,pchAppKeysThatSupportBuffer,unAppKeysThatSupportBuffer);
+		Marshal.FreeHGlobal(pchMimeTypeUtf8);
+		return result;
+	}
+	public uint GetApplicationLaunchArguments(uint unHandle,System.Text.StringBuilder pchArgs,uint unArgs)
+	{
+		uint result = FnTable.GetApplicationLaunchArguments(unHandle,pchArgs,unArgs);
+		return result;
+	}
+	public EVRApplicationError GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen)
+	{
+		EVRApplicationError result = FnTable.GetStartingApplication(pchAppKeyBuffer,unAppKeyBufferLen);
+		return result;
+	}
+	public EVRSceneApplicationState GetSceneApplicationState()
+	{
+		EVRSceneApplicationState result = FnTable.GetSceneApplicationState();
+		return result;
+	}
+	public EVRApplicationError PerformApplicationPrelaunchCheck(string pchAppKey)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.PerformApplicationPrelaunchCheck(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public string GetSceneApplicationStateNameFromEnum(EVRSceneApplicationState state)
+	{
+		IntPtr result = FnTable.GetSceneApplicationStateNameFromEnum(state);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public EVRApplicationError LaunchInternalProcess(string pchBinaryPath,string pchArguments,string pchWorkingDirectory)
+	{
+		IntPtr pchBinaryPathUtf8 = Utils.ToUtf8(pchBinaryPath);
+		IntPtr pchArgumentsUtf8 = Utils.ToUtf8(pchArguments);
+		IntPtr pchWorkingDirectoryUtf8 = Utils.ToUtf8(pchWorkingDirectory);
+		EVRApplicationError result = FnTable.LaunchInternalProcess(pchBinaryPathUtf8,pchArgumentsUtf8,pchWorkingDirectoryUtf8);
+		Marshal.FreeHGlobal(pchBinaryPathUtf8);
+		Marshal.FreeHGlobal(pchArgumentsUtf8);
+		Marshal.FreeHGlobal(pchWorkingDirectoryUtf8);
+		return result;
+	}
+	public uint GetCurrentSceneProcessId()
+	{
+		uint result = FnTable.GetCurrentSceneProcessId();
+		return result;
+	}
+}
+
+
+public class CVRChaperone
+{
+	IVRChaperone FnTable;
+	internal CVRChaperone(IntPtr pInterface)
+	{
+		FnTable = (IVRChaperone)Marshal.PtrToStructure(pInterface, typeof(IVRChaperone));
+	}
+	public ChaperoneCalibrationState GetCalibrationState()
+	{
+		ChaperoneCalibrationState result = FnTable.GetCalibrationState();
+		return result;
+	}
+	public bool GetPlayAreaSize(ref float pSizeX,ref float pSizeZ)
+	{
+		pSizeX = 0;
+		pSizeZ = 0;
+		bool result = FnTable.GetPlayAreaSize(ref pSizeX,ref pSizeZ);
+		return result;
+	}
+	public bool GetPlayAreaRect(ref HmdQuad_t rect)
+	{
+		bool result = FnTable.GetPlayAreaRect(ref rect);
+		return result;
+	}
+	public void ReloadInfo()
+	{
+		FnTable.ReloadInfo();
+	}
+	public void SetSceneColor(HmdColor_t color)
+	{
+		FnTable.SetSceneColor(color);
+	}
+	public void GetBoundsColor(ref HmdColor_t pOutputColorArray,int nNumOutputColors,float flCollisionBoundsFadeDistance,ref HmdColor_t pOutputCameraColor)
+	{
+		FnTable.GetBoundsColor(ref pOutputColorArray,nNumOutputColors,flCollisionBoundsFadeDistance,ref pOutputCameraColor);
+	}
+	public bool AreBoundsVisible()
+	{
+		bool result = FnTable.AreBoundsVisible();
+		return result;
+	}
+	public void ForceBoundsVisible(bool bForce)
+	{
+		FnTable.ForceBoundsVisible(bForce);
+	}
+	public void ResetZeroPose(ETrackingUniverseOrigin eTrackingUniverseOrigin)
+	{
+		FnTable.ResetZeroPose(eTrackingUniverseOrigin);
+	}
+}
+
+
+public class CVRChaperoneSetup
+{
+	IVRChaperoneSetup FnTable;
+	internal CVRChaperoneSetup(IntPtr pInterface)
+	{
+		FnTable = (IVRChaperoneSetup)Marshal.PtrToStructure(pInterface, typeof(IVRChaperoneSetup));
+	}
+	public bool CommitWorkingCopy(EChaperoneConfigFile configFile)
+	{
+		bool result = FnTable.CommitWorkingCopy(configFile);
+		return result;
+	}
+	public void RevertWorkingCopy()
+	{
+		FnTable.RevertWorkingCopy();
+	}
+	public bool GetWorkingPlayAreaSize(ref float pSizeX,ref float pSizeZ)
+	{
+		pSizeX = 0;
+		pSizeZ = 0;
+		bool result = FnTable.GetWorkingPlayAreaSize(ref pSizeX,ref pSizeZ);
+		return result;
+	}
+	public bool GetWorkingPlayAreaRect(ref HmdQuad_t rect)
+	{
+		bool result = FnTable.GetWorkingPlayAreaRect(ref rect);
+		return result;
+	}
+	public bool GetWorkingCollisionBoundsInfo(out HmdQuad_t [] pQuadsBuffer)
+	{
+		uint punQuadsCount = 0;
+		bool result = FnTable.GetWorkingCollisionBoundsInfo(null,ref punQuadsCount);
+		pQuadsBuffer= new HmdQuad_t[punQuadsCount];
+		result = FnTable.GetWorkingCollisionBoundsInfo(pQuadsBuffer,ref punQuadsCount);
+		return result;
+	}
+	public bool GetLiveCollisionBoundsInfo(out HmdQuad_t [] pQuadsBuffer)
+	{
+		uint punQuadsCount = 0;
+		bool result = FnTable.GetLiveCollisionBoundsInfo(null,ref punQuadsCount);
+		pQuadsBuffer= new HmdQuad_t[punQuadsCount];
+		result = FnTable.GetLiveCollisionBoundsInfo(pQuadsBuffer,ref punQuadsCount);
+		return result;
+	}
+	public bool GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose)
+	{
+		bool result = FnTable.GetWorkingSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose);
+		return result;
+	}
+	public bool GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose)
+	{
+		bool result = FnTable.GetWorkingStandingZeroPoseToRawTrackingPose(ref pmatStandingZeroPoseToRawTrackingPose);
+		return result;
+	}
+	public void SetWorkingPlayAreaSize(float sizeX,float sizeZ)
+	{
+		FnTable.SetWorkingPlayAreaSize(sizeX,sizeZ);
+	}
+	public void SetWorkingCollisionBoundsInfo(HmdQuad_t [] pQuadsBuffer)
+	{
+		FnTable.SetWorkingCollisionBoundsInfo(pQuadsBuffer,(uint) pQuadsBuffer.Length);
+	}
+	public void SetWorkingPerimeter(HmdVector2_t [] pPointBuffer)
+	{
+		FnTable.SetWorkingPerimeter(pPointBuffer,(uint) pPointBuffer.Length);
+	}
+	public void SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose)
+	{
+		FnTable.SetWorkingSeatedZeroPoseToRawTrackingPose(ref pMatSeatedZeroPoseToRawTrackingPose);
+	}
+	public void SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose)
+	{
+		FnTable.SetWorkingStandingZeroPoseToRawTrackingPose(ref pMatStandingZeroPoseToRawTrackingPose);
+	}
+	public void ReloadFromDisk(EChaperoneConfigFile configFile)
+	{
+		FnTable.ReloadFromDisk(configFile);
+	}
+	public bool GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose)
+	{
+		bool result = FnTable.GetLiveSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose);
+		return result;
+	}
+	public bool ExportLiveToBuffer(System.Text.StringBuilder pBuffer,ref uint pnBufferLength)
+	{
+		pnBufferLength = 0;
+		bool result = FnTable.ExportLiveToBuffer(pBuffer,ref pnBufferLength);
+		return result;
+	}
+	public bool ImportFromBufferToWorking(string pBuffer,uint nImportFlags)
+	{
+		IntPtr pBufferUtf8 = Utils.ToUtf8(pBuffer);
+		bool result = FnTable.ImportFromBufferToWorking(pBufferUtf8,nImportFlags);
+		Marshal.FreeHGlobal(pBufferUtf8);
+		return result;
+	}
+	public void ShowWorkingSetPreview()
+	{
+		FnTable.ShowWorkingSetPreview();
+	}
+	public void HideWorkingSetPreview()
+	{
+		FnTable.HideWorkingSetPreview();
+	}
+	public void RoomSetupStarting()
+	{
+		FnTable.RoomSetupStarting();
+	}
+}
+
+
+public class CVRCompositor
+{
+	IVRCompositor FnTable;
+	internal CVRCompositor(IntPtr pInterface)
+	{
+		FnTable = (IVRCompositor)Marshal.PtrToStructure(pInterface, typeof(IVRCompositor));
+	}
+	public void SetTrackingSpace(ETrackingUniverseOrigin eOrigin)
+	{
+		FnTable.SetTrackingSpace(eOrigin);
+	}
+	public ETrackingUniverseOrigin GetTrackingSpace()
+	{
+		ETrackingUniverseOrigin result = FnTable.GetTrackingSpace();
+		return result;
+	}
+	public EVRCompositorError WaitGetPoses(TrackedDevicePose_t [] pRenderPoseArray,TrackedDevicePose_t [] pGamePoseArray)
+	{
+		EVRCompositorError result = FnTable.WaitGetPoses(pRenderPoseArray,(uint) pRenderPoseArray.Length,pGamePoseArray,(uint) pGamePoseArray.Length);
+		return result;
+	}
+	public EVRCompositorError GetLastPoses(TrackedDevicePose_t [] pRenderPoseArray,TrackedDevicePose_t [] pGamePoseArray)
+	{
+		EVRCompositorError result = FnTable.GetLastPoses(pRenderPoseArray,(uint) pRenderPoseArray.Length,pGamePoseArray,(uint) pGamePoseArray.Length);
+		return result;
+	}
+	public EVRCompositorError GetLastPoseForTrackedDeviceIndex(uint unDeviceIndex,ref TrackedDevicePose_t pOutputPose,ref TrackedDevicePose_t pOutputGamePose)
+	{
+		EVRCompositorError result = FnTable.GetLastPoseForTrackedDeviceIndex(unDeviceIndex,ref pOutputPose,ref pOutputGamePose);
+		return result;
+	}
+	public EVRCompositorError Submit(EVREye eEye,ref Texture_t pTexture,ref VRTextureBounds_t pBounds,EVRSubmitFlags nSubmitFlags)
+	{
+		EVRCompositorError result = FnTable.Submit(eEye,ref pTexture,ref pBounds,nSubmitFlags);
+		return result;
+	}
+	public void ClearLastSubmittedFrame()
+	{
+		FnTable.ClearLastSubmittedFrame();
+	}
+	public void PostPresentHandoff()
+	{
+		FnTable.PostPresentHandoff();
+	}
+	public bool GetFrameTiming(ref Compositor_FrameTiming pTiming,uint unFramesAgo)
+	{
+		bool result = FnTable.GetFrameTiming(ref pTiming,unFramesAgo);
+		return result;
+	}
+	public uint GetFrameTimings(Compositor_FrameTiming [] pTiming)
+	{
+		uint result = FnTable.GetFrameTimings(pTiming,(uint) pTiming.Length);
+		return result;
+	}
+	public float GetFrameTimeRemaining()
+	{
+		float result = FnTable.GetFrameTimeRemaining();
+		return result;
+	}
+	public void GetCumulativeStats(ref Compositor_CumulativeStats pStats,uint nStatsSizeInBytes)
+	{
+		FnTable.GetCumulativeStats(ref pStats,nStatsSizeInBytes);
+	}
+	public void FadeToColor(float fSeconds,float fRed,float fGreen,float fBlue,float fAlpha,bool bBackground)
+	{
+		FnTable.FadeToColor(fSeconds,fRed,fGreen,fBlue,fAlpha,bBackground);
+	}
+	public HmdColor_t GetCurrentFadeColor(bool bBackground)
+	{
+		HmdColor_t result = FnTable.GetCurrentFadeColor(bBackground);
+		return result;
+	}
+	public void FadeGrid(float fSeconds,bool bFadeGridIn)
+	{
+		FnTable.FadeGrid(fSeconds,bFadeGridIn);
+	}
+	public float GetCurrentGridAlpha()
+	{
+		float result = FnTable.GetCurrentGridAlpha();
+		return result;
+	}
+	public EVRCompositorError SetSkyboxOverride(Texture_t [] pTextures)
+	{
+		EVRCompositorError result = FnTable.SetSkyboxOverride(pTextures,(uint) pTextures.Length);
+		return result;
+	}
+	public void ClearSkyboxOverride()
+	{
+		FnTable.ClearSkyboxOverride();
+	}
+	public void CompositorBringToFront()
+	{
+		FnTable.CompositorBringToFront();
+	}
+	public void CompositorGoToBack()
+	{
+		FnTable.CompositorGoToBack();
+	}
+	public void CompositorQuit()
+	{
+		FnTable.CompositorQuit();
+	}
+	public bool IsFullscreen()
+	{
+		bool result = FnTable.IsFullscreen();
+		return result;
+	}
+	public uint GetCurrentSceneFocusProcess()
+	{
+		uint result = FnTable.GetCurrentSceneFocusProcess();
+		return result;
+	}
+	public uint GetLastFrameRenderer()
+	{
+		uint result = FnTable.GetLastFrameRenderer();
+		return result;
+	}
+	public bool CanRenderScene()
+	{
+		bool result = FnTable.CanRenderScene();
+		return result;
+	}
+	public void ShowMirrorWindow()
+	{
+		FnTable.ShowMirrorWindow();
+	}
+	public void HideMirrorWindow()
+	{
+		FnTable.HideMirrorWindow();
+	}
+	public bool IsMirrorWindowVisible()
+	{
+		bool result = FnTable.IsMirrorWindowVisible();
+		return result;
+	}
+	public void CompositorDumpImages()
+	{
+		FnTable.CompositorDumpImages();
+	}
+	public bool ShouldAppRenderWithLowResources()
+	{
+		bool result = FnTable.ShouldAppRenderWithLowResources();
+		return result;
+	}
+	public void ForceInterleavedReprojectionOn(bool bOverride)
+	{
+		FnTable.ForceInterleavedReprojectionOn(bOverride);
+	}
+	public void ForceReconnectProcess()
+	{
+		FnTable.ForceReconnectProcess();
+	}
+	public void SuspendRendering(bool bSuspend)
+	{
+		FnTable.SuspendRendering(bSuspend);
+	}
+	public EVRCompositorError GetMirrorTextureD3D11(EVREye eEye,IntPtr pD3D11DeviceOrResource,ref IntPtr ppD3D11ShaderResourceView)
+	{
+		EVRCompositorError result = FnTable.GetMirrorTextureD3D11(eEye,pD3D11DeviceOrResource,ref ppD3D11ShaderResourceView);
+		return result;
+	}
+	public void ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView)
+	{
+		FnTable.ReleaseMirrorTextureD3D11(pD3D11ShaderResourceView);
+	}
+	public EVRCompositorError GetMirrorTextureGL(EVREye eEye,ref uint pglTextureId,IntPtr pglSharedTextureHandle)
+	{
+		pglTextureId = 0;
+		EVRCompositorError result = FnTable.GetMirrorTextureGL(eEye,ref pglTextureId,pglSharedTextureHandle);
+		return result;
+	}
+	public bool ReleaseSharedGLTexture(uint glTextureId,IntPtr glSharedTextureHandle)
+	{
+		bool result = FnTable.ReleaseSharedGLTexture(glTextureId,glSharedTextureHandle);
+		return result;
+	}
+	public void LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle)
+	{
+		FnTable.LockGLSharedTextureForAccess(glSharedTextureHandle);
+	}
+	public void UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle)
+	{
+		FnTable.UnlockGLSharedTextureForAccess(glSharedTextureHandle);
+	}
+	public uint GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue,uint unBufferSize)
+	{
+		uint result = FnTable.GetVulkanInstanceExtensionsRequired(pchValue,unBufferSize);
+		return result;
+	}
+	public uint GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice,System.Text.StringBuilder pchValue,uint unBufferSize)
+	{
+		uint result = FnTable.GetVulkanDeviceExtensionsRequired(pPhysicalDevice,pchValue,unBufferSize);
+		return result;
+	}
+	public void SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode)
+	{
+		FnTable.SetExplicitTimingMode(eTimingMode);
+	}
+	public EVRCompositorError SubmitExplicitTimingData()
+	{
+		EVRCompositorError result = FnTable.SubmitExplicitTimingData();
+		return result;
+	}
+	public bool IsMotionSmoothingEnabled()
+	{
+		bool result = FnTable.IsMotionSmoothingEnabled();
+		return result;
+	}
+	public bool IsMotionSmoothingSupported()
+	{
+		bool result = FnTable.IsMotionSmoothingSupported();
+		return result;
+	}
+	public bool IsCurrentSceneFocusAppLoading()
+	{
+		bool result = FnTable.IsCurrentSceneFocusAppLoading();
+		return result;
+	}
+	public EVRCompositorError SetStageOverride_Async(string pchRenderModelPath,ref HmdMatrix34_t pTransform,ref Compositor_StageRenderSettings pRenderSettings,uint nSizeOfRenderSettings)
+	{
+		IntPtr pchRenderModelPathUtf8 = Utils.ToUtf8(pchRenderModelPath);
+		EVRCompositorError result = FnTable.SetStageOverride_Async(pchRenderModelPathUtf8,ref pTransform,ref pRenderSettings,nSizeOfRenderSettings);
+		Marshal.FreeHGlobal(pchRenderModelPathUtf8);
+		return result;
+	}
+	public void ClearStageOverride()
+	{
+		FnTable.ClearStageOverride();
+	}
+	public bool GetCompositorBenchmarkResults(ref Compositor_BenchmarkResults pBenchmarkResults,uint nSizeOfBenchmarkResults)
+	{
+		bool result = FnTable.GetCompositorBenchmarkResults(ref pBenchmarkResults,nSizeOfBenchmarkResults);
+		return result;
+	}
+	public EVRCompositorError GetLastPosePredictionIDs(ref uint pRenderPosePredictionID,ref uint pGamePosePredictionID)
+	{
+		pRenderPosePredictionID = 0;
+		pGamePosePredictionID = 0;
+		EVRCompositorError result = FnTable.GetLastPosePredictionIDs(ref pRenderPosePredictionID,ref pGamePosePredictionID);
+		return result;
+	}
+	public EVRCompositorError GetPosesForFrame(uint unPosePredictionID,TrackedDevicePose_t [] pPoseArray)
+	{
+		EVRCompositorError result = FnTable.GetPosesForFrame(unPosePredictionID,pPoseArray,(uint) pPoseArray.Length);
+		return result;
+	}
+}
+
+
+public class CVROverlay
+{
+	IVROverlay FnTable;
+	internal CVROverlay(IntPtr pInterface)
+	{
+		FnTable = (IVROverlay)Marshal.PtrToStructure(pInterface, typeof(IVROverlay));
+	}
+	public EVROverlayError FindOverlay(string pchOverlayKey,ref ulong pOverlayHandle)
+	{
+		IntPtr pchOverlayKeyUtf8 = Utils.ToUtf8(pchOverlayKey);
+		pOverlayHandle = 0;
+		EVROverlayError result = FnTable.FindOverlay(pchOverlayKeyUtf8,ref pOverlayHandle);
+		Marshal.FreeHGlobal(pchOverlayKeyUtf8);
+		return result;
+	}
+	public EVROverlayError CreateOverlay(string pchOverlayKey,string pchOverlayName,ref ulong pOverlayHandle)
+	{
+		IntPtr pchOverlayKeyUtf8 = Utils.ToUtf8(pchOverlayKey);
+		IntPtr pchOverlayNameUtf8 = Utils.ToUtf8(pchOverlayName);
+		pOverlayHandle = 0;
+		EVROverlayError result = FnTable.CreateOverlay(pchOverlayKeyUtf8,pchOverlayNameUtf8,ref pOverlayHandle);
+		Marshal.FreeHGlobal(pchOverlayKeyUtf8);
+		Marshal.FreeHGlobal(pchOverlayNameUtf8);
+		return result;
+	}
+	public EVROverlayError DestroyOverlay(ulong ulOverlayHandle)
+	{
+		EVROverlayError result = FnTable.DestroyOverlay(ulOverlayHandle);
+		return result;
+	}
+	public uint GetOverlayKey(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError)
+	{
+		uint result = FnTable.GetOverlayKey(ulOverlayHandle,pchValue,unBufferSize,ref pError);
+		return result;
+	}
+	public uint GetOverlayName(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError)
+	{
+		uint result = FnTable.GetOverlayName(ulOverlayHandle,pchValue,unBufferSize,ref pError);
+		return result;
+	}
+	public EVROverlayError SetOverlayName(ulong ulOverlayHandle,string pchName)
+	{
+		IntPtr pchNameUtf8 = Utils.ToUtf8(pchName);
+		EVROverlayError result = FnTable.SetOverlayName(ulOverlayHandle,pchNameUtf8);
+		Marshal.FreeHGlobal(pchNameUtf8);
+		return result;
+	}
+	public EVROverlayError GetOverlayImageData(ulong ulOverlayHandle,IntPtr pvBuffer,uint unBufferSize,ref uint punWidth,ref uint punHeight)
+	{
+		punWidth = 0;
+		punHeight = 0;
+		EVROverlayError result = FnTable.GetOverlayImageData(ulOverlayHandle,pvBuffer,unBufferSize,ref punWidth,ref punHeight);
+		return result;
+	}
+	public string GetOverlayErrorNameFromEnum(EVROverlayError error)
+	{
+		IntPtr result = FnTable.GetOverlayErrorNameFromEnum(error);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public EVROverlayError SetOverlayRenderingPid(ulong ulOverlayHandle,uint unPID)
+	{
+		EVROverlayError result = FnTable.SetOverlayRenderingPid(ulOverlayHandle,unPID);
+		return result;
+	}
+	public uint GetOverlayRenderingPid(ulong ulOverlayHandle)
+	{
+		uint result = FnTable.GetOverlayRenderingPid(ulOverlayHandle);
+		return result;
+	}
+	public EVROverlayError SetOverlayFlag(ulong ulOverlayHandle,VROverlayFlags eOverlayFlag,bool bEnabled)
+	{
+		EVROverlayError result = FnTable.SetOverlayFlag(ulOverlayHandle,eOverlayFlag,bEnabled);
+		return result;
+	}
+	public EVROverlayError GetOverlayFlag(ulong ulOverlayHandle,VROverlayFlags eOverlayFlag,ref bool pbEnabled)
+	{
+		pbEnabled = false;
+		EVROverlayError result = FnTable.GetOverlayFlag(ulOverlayHandle,eOverlayFlag,ref pbEnabled);
+		return result;
+	}
+	public EVROverlayError GetOverlayFlags(ulong ulOverlayHandle,ref uint pFlags)
+	{
+		pFlags = 0;
+		EVROverlayError result = FnTable.GetOverlayFlags(ulOverlayHandle,ref pFlags);
+		return result;
+	}
+	public EVROverlayError SetOverlayColor(ulong ulOverlayHandle,float fRed,float fGreen,float fBlue)
+	{
+		EVROverlayError result = FnTable.SetOverlayColor(ulOverlayHandle,fRed,fGreen,fBlue);
+		return result;
+	}
+	public EVROverlayError GetOverlayColor(ulong ulOverlayHandle,ref float pfRed,ref float pfGreen,ref float pfBlue)
+	{
+		pfRed = 0;
+		pfGreen = 0;
+		pfBlue = 0;
+		EVROverlayError result = FnTable.GetOverlayColor(ulOverlayHandle,ref pfRed,ref pfGreen,ref pfBlue);
+		return result;
+	}
+	public EVROverlayError SetOverlayAlpha(ulong ulOverlayHandle,float fAlpha)
+	{
+		EVROverlayError result = FnTable.SetOverlayAlpha(ulOverlayHandle,fAlpha);
+		return result;
+	}
+	public EVROverlayError GetOverlayAlpha(ulong ulOverlayHandle,ref float pfAlpha)
+	{
+		pfAlpha = 0;
+		EVROverlayError result = FnTable.GetOverlayAlpha(ulOverlayHandle,ref pfAlpha);
+		return result;
+	}
+	public EVROverlayError SetOverlayTexelAspect(ulong ulOverlayHandle,float fTexelAspect)
+	{
+		EVROverlayError result = FnTable.SetOverlayTexelAspect(ulOverlayHandle,fTexelAspect);
+		return result;
+	}
+	public EVROverlayError GetOverlayTexelAspect(ulong ulOverlayHandle,ref float pfTexelAspect)
+	{
+		pfTexelAspect = 0;
+		EVROverlayError result = FnTable.GetOverlayTexelAspect(ulOverlayHandle,ref pfTexelAspect);
+		return result;
+	}
+	public EVROverlayError SetOverlaySortOrder(ulong ulOverlayHandle,uint unSortOrder)
+	{
+		EVROverlayError result = FnTable.SetOverlaySortOrder(ulOverlayHandle,unSortOrder);
+		return result;
+	}
+	public EVROverlayError GetOverlaySortOrder(ulong ulOverlayHandle,ref uint punSortOrder)
+	{
+		punSortOrder = 0;
+		EVROverlayError result = FnTable.GetOverlaySortOrder(ulOverlayHandle,ref punSortOrder);
+		return result;
+	}
+	public EVROverlayError SetOverlayWidthInMeters(ulong ulOverlayHandle,float fWidthInMeters)
+	{
+		EVROverlayError result = FnTable.SetOverlayWidthInMeters(ulOverlayHandle,fWidthInMeters);
+		return result;
+	}
+	public EVROverlayError GetOverlayWidthInMeters(ulong ulOverlayHandle,ref float pfWidthInMeters)
+	{
+		pfWidthInMeters = 0;
+		EVROverlayError result = FnTable.GetOverlayWidthInMeters(ulOverlayHandle,ref pfWidthInMeters);
+		return result;
+	}
+	public EVROverlayError SetOverlayCurvature(ulong ulOverlayHandle,float fCurvature)
+	{
+		EVROverlayError result = FnTable.SetOverlayCurvature(ulOverlayHandle,fCurvature);
+		return result;
+	}
+	public EVROverlayError GetOverlayCurvature(ulong ulOverlayHandle,ref float pfCurvature)
+	{
+		pfCurvature = 0;
+		EVROverlayError result = FnTable.GetOverlayCurvature(ulOverlayHandle,ref pfCurvature);
+		return result;
+	}
+	public EVROverlayError SetOverlayTextureColorSpace(ulong ulOverlayHandle,EColorSpace eTextureColorSpace)
+	{
+		EVROverlayError result = FnTable.SetOverlayTextureColorSpace(ulOverlayHandle,eTextureColorSpace);
+		return result;
+	}
+	public EVROverlayError GetOverlayTextureColorSpace(ulong ulOverlayHandle,ref EColorSpace peTextureColorSpace)
+	{
+		EVROverlayError result = FnTable.GetOverlayTextureColorSpace(ulOverlayHandle,ref peTextureColorSpace);
+		return result;
+	}
+	public EVROverlayError SetOverlayTextureBounds(ulong ulOverlayHandle,ref VRTextureBounds_t pOverlayTextureBounds)
+	{
+		EVROverlayError result = FnTable.SetOverlayTextureBounds(ulOverlayHandle,ref pOverlayTextureBounds);
+		return result;
+	}
+	public EVROverlayError GetOverlayTextureBounds(ulong ulOverlayHandle,ref VRTextureBounds_t pOverlayTextureBounds)
+	{
+		EVROverlayError result = FnTable.GetOverlayTextureBounds(ulOverlayHandle,ref pOverlayTextureBounds);
+		return result;
+	}
+	public EVROverlayError GetOverlayTransformType(ulong ulOverlayHandle,ref VROverlayTransformType peTransformType)
+	{
+		EVROverlayError result = FnTable.GetOverlayTransformType(ulOverlayHandle,ref peTransformType);
+		return result;
+	}
+	public EVROverlayError SetOverlayTransformAbsolute(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform)
+	{
+		EVROverlayError result = FnTable.SetOverlayTransformAbsolute(ulOverlayHandle,eTrackingOrigin,ref pmatTrackingOriginToOverlayTransform);
+		return result;
+	}
+	public EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle,ref ETrackingUniverseOrigin peTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform)
+	{
+		EVROverlayError result = FnTable.GetOverlayTransformAbsolute(ulOverlayHandle,ref peTrackingOrigin,ref pmatTrackingOriginToOverlayTransform);
+		return result;
+	}
+	public EVROverlayError SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle,uint unTrackedDevice,ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform)
+	{
+		EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceRelative(ulOverlayHandle,unTrackedDevice,ref pmatTrackedDeviceToOverlayTransform);
+		return result;
+	}
+	public EVROverlayError GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle,ref uint punTrackedDevice,ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform)
+	{
+		punTrackedDevice = 0;
+		EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceRelative(ulOverlayHandle,ref punTrackedDevice,ref pmatTrackedDeviceToOverlayTransform);
+		return result;
+	}
+	public EVROverlayError SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,uint unDeviceIndex,string pchComponentName)
+	{
+		IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName);
+		EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,unDeviceIndex,pchComponentNameUtf8);
+		Marshal.FreeHGlobal(pchComponentNameUtf8);
+		return result;
+	}
+	public EVROverlayError GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,ref uint punDeviceIndex,System.Text.StringBuilder pchComponentName,uint unComponentNameSize)
+	{
+		punDeviceIndex = 0;
+		EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,ref punDeviceIndex,pchComponentName,unComponentNameSize);
+		return result;
+	}
+	public EVROverlayError GetOverlayTransformOverlayRelative(ulong ulOverlayHandle,ref ulong ulOverlayHandleParent,ref HmdMatrix34_t pmatParentOverlayToOverlayTransform)
+	{
+		ulOverlayHandleParent = 0;
+		EVROverlayError result = FnTable.GetOverlayTransformOverlayRelative(ulOverlayHandle,ref ulOverlayHandleParent,ref pmatParentOverlayToOverlayTransform);
+		return result;
+	}
+	public EVROverlayError SetOverlayTransformOverlayRelative(ulong ulOverlayHandle,ulong ulOverlayHandleParent,ref HmdMatrix34_t pmatParentOverlayToOverlayTransform)
+	{
+		EVROverlayError result = FnTable.SetOverlayTransformOverlayRelative(ulOverlayHandle,ulOverlayHandleParent,ref pmatParentOverlayToOverlayTransform);
+		return result;
+	}
+	public EVROverlayError SetOverlayTransformCursor(ulong ulCursorOverlayHandle,ref HmdVector2_t pvHotspot)
+	{
+		EVROverlayError result = FnTable.SetOverlayTransformCursor(ulCursorOverlayHandle,ref pvHotspot);
+		return result;
+	}
+	public EVROverlayError GetOverlayTransformCursor(ulong ulOverlayHandle,ref HmdVector2_t pvHotspot)
+	{
+		EVROverlayError result = FnTable.GetOverlayTransformCursor(ulOverlayHandle,ref pvHotspot);
+		return result;
+	}
+	public EVROverlayError SetOverlayTransformProjection(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform,ref VROverlayProjection_t pProjection,EVREye eEye)
+	{
+		EVROverlayError result = FnTable.SetOverlayTransformProjection(ulOverlayHandle,eTrackingOrigin,ref pmatTrackingOriginToOverlayTransform,ref pProjection,eEye);
+		return result;
+	}
+	public EVROverlayError ShowOverlay(ulong ulOverlayHandle)
+	{
+		EVROverlayError result = FnTable.ShowOverlay(ulOverlayHandle);
+		return result;
+	}
+	public EVROverlayError HideOverlay(ulong ulOverlayHandle)
+	{
+		EVROverlayError result = FnTable.HideOverlay(ulOverlayHandle);
+		return result;
+	}
+	public bool IsOverlayVisible(ulong ulOverlayHandle)
+	{
+		bool result = FnTable.IsOverlayVisible(ulOverlayHandle);
+		return result;
+	}
+	public EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,HmdVector2_t coordinatesInOverlay,ref HmdMatrix34_t pmatTransform)
+	{
+		EVROverlayError result = FnTable.GetTransformForOverlayCoordinates(ulOverlayHandle,eTrackingOrigin,coordinatesInOverlay,ref pmatTransform);
+		return result;
+	}
+// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were
+// originally mis-compiled with the wrong packing for Linux and OSX.
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _PollNextOverlayEventPacked(ulong ulOverlayHandle,ref VREvent_t_Packed pEvent,uint uncbVREvent);
+	[StructLayout(LayoutKind.Explicit)]
+	struct PollNextOverlayEventUnion
+	{
+		[FieldOffset(0)]
+		public IVROverlay._PollNextOverlayEvent pPollNextOverlayEvent;
+		[FieldOffset(0)]
+		public _PollNextOverlayEventPacked pPollNextOverlayEventPacked;
+	}
+	public bool PollNextOverlayEvent(ulong ulOverlayHandle,ref VREvent_t pEvent,uint uncbVREvent)
+	{
+#if !UNITY_METRO
+		if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) ||
+				(System.Environment.OSVersion.Platform == System.PlatformID.Unix))
+		{
+			PollNextOverlayEventUnion u;
+			VREvent_t_Packed event_packed = new VREvent_t_Packed();
+			u.pPollNextOverlayEventPacked = null;
+			u.pPollNextOverlayEvent = FnTable.PollNextOverlayEvent;
+			bool packed_result = u.pPollNextOverlayEventPacked(ulOverlayHandle,ref event_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed)));
+
+			event_packed.Unpack(ref pEvent);
+			return packed_result;
+		}
+#endif
+		bool result = FnTable.PollNextOverlayEvent(ulOverlayHandle,ref pEvent,uncbVREvent);
+		return result;
+	}
+	public EVROverlayError GetOverlayInputMethod(ulong ulOverlayHandle,ref VROverlayInputMethod peInputMethod)
+	{
+		EVROverlayError result = FnTable.GetOverlayInputMethod(ulOverlayHandle,ref peInputMethod);
+		return result;
+	}
+	public EVROverlayError SetOverlayInputMethod(ulong ulOverlayHandle,VROverlayInputMethod eInputMethod)
+	{
+		EVROverlayError result = FnTable.SetOverlayInputMethod(ulOverlayHandle,eInputMethod);
+		return result;
+	}
+	public EVROverlayError GetOverlayMouseScale(ulong ulOverlayHandle,ref HmdVector2_t pvecMouseScale)
+	{
+		EVROverlayError result = FnTable.GetOverlayMouseScale(ulOverlayHandle,ref pvecMouseScale);
+		return result;
+	}
+	public EVROverlayError SetOverlayMouseScale(ulong ulOverlayHandle,ref HmdVector2_t pvecMouseScale)
+	{
+		EVROverlayError result = FnTable.SetOverlayMouseScale(ulOverlayHandle,ref pvecMouseScale);
+		return result;
+	}
+	public bool ComputeOverlayIntersection(ulong ulOverlayHandle,ref VROverlayIntersectionParams_t pParams,ref VROverlayIntersectionResults_t pResults)
+	{
+		bool result = FnTable.ComputeOverlayIntersection(ulOverlayHandle,ref pParams,ref pResults);
+		return result;
+	}
+	public bool IsHoverTargetOverlay(ulong ulOverlayHandle)
+	{
+		bool result = FnTable.IsHoverTargetOverlay(ulOverlayHandle);
+		return result;
+	}
+	public EVROverlayError SetOverlayIntersectionMask(ulong ulOverlayHandle,ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives,uint unNumMaskPrimitives,uint unPrimitiveSize)
+	{
+		EVROverlayError result = FnTable.SetOverlayIntersectionMask(ulOverlayHandle,ref pMaskPrimitives,unNumMaskPrimitives,unPrimitiveSize);
+		return result;
+	}
+	public EVROverlayError TriggerLaserMouseHapticVibration(ulong ulOverlayHandle,float fDurationSeconds,float fFrequency,float fAmplitude)
+	{
+		EVROverlayError result = FnTable.TriggerLaserMouseHapticVibration(ulOverlayHandle,fDurationSeconds,fFrequency,fAmplitude);
+		return result;
+	}
+	public EVROverlayError SetOverlayCursor(ulong ulOverlayHandle,ulong ulCursorHandle)
+	{
+		EVROverlayError result = FnTable.SetOverlayCursor(ulOverlayHandle,ulCursorHandle);
+		return result;
+	}
+	public EVROverlayError SetOverlayCursorPositionOverride(ulong ulOverlayHandle,ref HmdVector2_t pvCursor)
+	{
+		EVROverlayError result = FnTable.SetOverlayCursorPositionOverride(ulOverlayHandle,ref pvCursor);
+		return result;
+	}
+	public EVROverlayError ClearOverlayCursorPositionOverride(ulong ulOverlayHandle)
+	{
+		EVROverlayError result = FnTable.ClearOverlayCursorPositionOverride(ulOverlayHandle);
+		return result;
+	}
+	public EVROverlayError SetOverlayTexture(ulong ulOverlayHandle,ref Texture_t pTexture)
+	{
+		EVROverlayError result = FnTable.SetOverlayTexture(ulOverlayHandle,ref pTexture);
+		return result;
+	}
+	public EVROverlayError ClearOverlayTexture(ulong ulOverlayHandle)
+	{
+		EVROverlayError result = FnTable.ClearOverlayTexture(ulOverlayHandle);
+		return result;
+	}
+	public EVROverlayError SetOverlayRaw(ulong ulOverlayHandle,IntPtr pvBuffer,uint unWidth,uint unHeight,uint unBytesPerPixel)
+	{
+		EVROverlayError result = FnTable.SetOverlayRaw(ulOverlayHandle,pvBuffer,unWidth,unHeight,unBytesPerPixel);
+		return result;
+	}
+	public EVROverlayError SetOverlayFromFile(ulong ulOverlayHandle,string pchFilePath)
+	{
+		IntPtr pchFilePathUtf8 = Utils.ToUtf8(pchFilePath);
+		EVROverlayError result = FnTable.SetOverlayFromFile(ulOverlayHandle,pchFilePathUtf8);
+		Marshal.FreeHGlobal(pchFilePathUtf8);
+		return result;
+	}
+	public EVROverlayError GetOverlayTexture(ulong ulOverlayHandle,ref IntPtr pNativeTextureHandle,IntPtr pNativeTextureRef,ref uint pWidth,ref uint pHeight,ref uint pNativeFormat,ref ETextureType pAPIType,ref EColorSpace pColorSpace,ref VRTextureBounds_t pTextureBounds)
+	{
+		pWidth = 0;
+		pHeight = 0;
+		pNativeFormat = 0;
+		EVROverlayError result = FnTable.GetOverlayTexture(ulOverlayHandle,ref pNativeTextureHandle,pNativeTextureRef,ref pWidth,ref pHeight,ref pNativeFormat,ref pAPIType,ref pColorSpace,ref pTextureBounds);
+		return result;
+	}
+	public EVROverlayError ReleaseNativeOverlayHandle(ulong ulOverlayHandle,IntPtr pNativeTextureHandle)
+	{
+		EVROverlayError result = FnTable.ReleaseNativeOverlayHandle(ulOverlayHandle,pNativeTextureHandle);
+		return result;
+	}
+	public EVROverlayError GetOverlayTextureSize(ulong ulOverlayHandle,ref uint pWidth,ref uint pHeight)
+	{
+		pWidth = 0;
+		pHeight = 0;
+		EVROverlayError result = FnTable.GetOverlayTextureSize(ulOverlayHandle,ref pWidth,ref pHeight);
+		return result;
+	}
+	public EVROverlayError CreateDashboardOverlay(string pchOverlayKey,string pchOverlayFriendlyName,ref ulong pMainHandle,ref ulong pThumbnailHandle)
+	{
+		IntPtr pchOverlayKeyUtf8 = Utils.ToUtf8(pchOverlayKey);
+		IntPtr pchOverlayFriendlyNameUtf8 = Utils.ToUtf8(pchOverlayFriendlyName);
+		pMainHandle = 0;
+		pThumbnailHandle = 0;
+		EVROverlayError result = FnTable.CreateDashboardOverlay(pchOverlayKeyUtf8,pchOverlayFriendlyNameUtf8,ref pMainHandle,ref pThumbnailHandle);
+		Marshal.FreeHGlobal(pchOverlayKeyUtf8);
+		Marshal.FreeHGlobal(pchOverlayFriendlyNameUtf8);
+		return result;
+	}
+	public bool IsDashboardVisible()
+	{
+		bool result = FnTable.IsDashboardVisible();
+		return result;
+	}
+	public bool IsActiveDashboardOverlay(ulong ulOverlayHandle)
+	{
+		bool result = FnTable.IsActiveDashboardOverlay(ulOverlayHandle);
+		return result;
+	}
+	public EVROverlayError SetDashboardOverlaySceneProcess(ulong ulOverlayHandle,uint unProcessId)
+	{
+		EVROverlayError result = FnTable.SetDashboardOverlaySceneProcess(ulOverlayHandle,unProcessId);
+		return result;
+	}
+	public EVROverlayError GetDashboardOverlaySceneProcess(ulong ulOverlayHandle,ref uint punProcessId)
+	{
+		punProcessId = 0;
+		EVROverlayError result = FnTable.GetDashboardOverlaySceneProcess(ulOverlayHandle,ref punProcessId);
+		return result;
+	}
+	public void ShowDashboard(string pchOverlayToShow)
+	{
+		IntPtr pchOverlayToShowUtf8 = Utils.ToUtf8(pchOverlayToShow);
+		FnTable.ShowDashboard(pchOverlayToShowUtf8);
+		Marshal.FreeHGlobal(pchOverlayToShowUtf8);
+	}
+	public uint GetPrimaryDashboardDevice()
+	{
+		uint result = FnTable.GetPrimaryDashboardDevice();
+		return result;
+	}
+	public EVROverlayError ShowKeyboard(int eInputMode,int eLineInputMode,uint unFlags,string pchDescription,uint unCharMax,string pchExistingText,ulong uUserValue)
+	{
+		IntPtr pchDescriptionUtf8 = Utils.ToUtf8(pchDescription);
+		IntPtr pchExistingTextUtf8 = Utils.ToUtf8(pchExistingText);
+		EVROverlayError result = FnTable.ShowKeyboard(eInputMode,eLineInputMode,unFlags,pchDescriptionUtf8,unCharMax,pchExistingTextUtf8,uUserValue);
+		Marshal.FreeHGlobal(pchDescriptionUtf8);
+		Marshal.FreeHGlobal(pchExistingTextUtf8);
+		return result;
+	}
+	public EVROverlayError ShowKeyboardForOverlay(ulong ulOverlayHandle,int eInputMode,int eLineInputMode,uint unFlags,string pchDescription,uint unCharMax,string pchExistingText,ulong uUserValue)
+	{
+		IntPtr pchDescriptionUtf8 = Utils.ToUtf8(pchDescription);
+		IntPtr pchExistingTextUtf8 = Utils.ToUtf8(pchExistingText);
+		EVROverlayError result = FnTable.ShowKeyboardForOverlay(ulOverlayHandle,eInputMode,eLineInputMode,unFlags,pchDescriptionUtf8,unCharMax,pchExistingTextUtf8,uUserValue);
+		Marshal.FreeHGlobal(pchDescriptionUtf8);
+		Marshal.FreeHGlobal(pchExistingTextUtf8);
+		return result;
+	}
+	public uint GetKeyboardText(System.Text.StringBuilder pchText,uint cchText)
+	{
+		uint result = FnTable.GetKeyboardText(pchText,cchText);
+		return result;
+	}
+	public void HideKeyboard()
+	{
+		FnTable.HideKeyboard();
+	}
+	public void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform)
+	{
+		FnTable.SetKeyboardTransformAbsolute(eTrackingOrigin,ref pmatTrackingOriginToKeyboardTransform);
+	}
+	public void SetKeyboardPositionForOverlay(ulong ulOverlayHandle,HmdRect2_t avoidRect)
+	{
+		FnTable.SetKeyboardPositionForOverlay(ulOverlayHandle,avoidRect);
+	}
+	public VRMessageOverlayResponse ShowMessageOverlay(string pchText,string pchCaption,string pchButton0Text,string pchButton1Text,string pchButton2Text,string pchButton3Text)
+	{
+		IntPtr pchTextUtf8 = Utils.ToUtf8(pchText);
+		IntPtr pchCaptionUtf8 = Utils.ToUtf8(pchCaption);
+		IntPtr pchButton0TextUtf8 = Utils.ToUtf8(pchButton0Text);
+		IntPtr pchButton1TextUtf8 = Utils.ToUtf8(pchButton1Text);
+		IntPtr pchButton2TextUtf8 = Utils.ToUtf8(pchButton2Text);
+		IntPtr pchButton3TextUtf8 = Utils.ToUtf8(pchButton3Text);
+		VRMessageOverlayResponse result = FnTable.ShowMessageOverlay(pchTextUtf8,pchCaptionUtf8,pchButton0TextUtf8,pchButton1TextUtf8,pchButton2TextUtf8,pchButton3TextUtf8);
+		Marshal.FreeHGlobal(pchTextUtf8);
+		Marshal.FreeHGlobal(pchCaptionUtf8);
+		Marshal.FreeHGlobal(pchButton0TextUtf8);
+		Marshal.FreeHGlobal(pchButton1TextUtf8);
+		Marshal.FreeHGlobal(pchButton2TextUtf8);
+		Marshal.FreeHGlobal(pchButton3TextUtf8);
+		return result;
+	}
+	public void CloseMessageOverlay()
+	{
+		FnTable.CloseMessageOverlay();
+	}
+}
+
+
+public class CVROverlayView
+{
+	IVROverlayView FnTable;
+	internal CVROverlayView(IntPtr pInterface)
+	{
+		FnTable = (IVROverlayView)Marshal.PtrToStructure(pInterface, typeof(IVROverlayView));
+	}
+	public EVROverlayError AcquireOverlayView(ulong ulOverlayHandle,ref VRNativeDevice_t pNativeDevice,ref VROverlayView_t pOverlayView,uint unOverlayViewSize)
+	{
+		EVROverlayError result = FnTable.AcquireOverlayView(ulOverlayHandle,ref pNativeDevice,ref pOverlayView,unOverlayViewSize);
+		return result;
+	}
+	public EVROverlayError ReleaseOverlayView(ref VROverlayView_t pOverlayView)
+	{
+		EVROverlayError result = FnTable.ReleaseOverlayView(ref pOverlayView);
+		return result;
+	}
+	public void PostOverlayEvent(ulong ulOverlayHandle,ref VREvent_t pvrEvent)
+	{
+		FnTable.PostOverlayEvent(ulOverlayHandle,ref pvrEvent);
+	}
+	public bool IsViewingPermitted(ulong ulOverlayHandle)
+	{
+		bool result = FnTable.IsViewingPermitted(ulOverlayHandle);
+		return result;
+	}
+}
+
+
+public class CVRHeadsetView
+{
+	IVRHeadsetView FnTable;
+	internal CVRHeadsetView(IntPtr pInterface)
+	{
+		FnTable = (IVRHeadsetView)Marshal.PtrToStructure(pInterface, typeof(IVRHeadsetView));
+	}
+	public void SetHeadsetViewSize(uint nWidth,uint nHeight)
+	{
+		FnTable.SetHeadsetViewSize(nWidth,nHeight);
+	}
+	public void GetHeadsetViewSize(ref uint pnWidth,ref uint pnHeight)
+	{
+		pnWidth = 0;
+		pnHeight = 0;
+		FnTable.GetHeadsetViewSize(ref pnWidth,ref pnHeight);
+	}
+	public void SetHeadsetViewMode(uint eHeadsetViewMode)
+	{
+		FnTable.SetHeadsetViewMode(eHeadsetViewMode);
+	}
+	public uint GetHeadsetViewMode()
+	{
+		uint result = FnTable.GetHeadsetViewMode();
+		return result;
+	}
+	public void SetHeadsetViewCropped(bool bCropped)
+	{
+		FnTable.SetHeadsetViewCropped(bCropped);
+	}
+	public bool GetHeadsetViewCropped()
+	{
+		bool result = FnTable.GetHeadsetViewCropped();
+		return result;
+	}
+	public float GetHeadsetViewAspectRatio()
+	{
+		float result = FnTable.GetHeadsetViewAspectRatio();
+		return result;
+	}
+	public void SetHeadsetViewBlendRange(float flStartPct,float flEndPct)
+	{
+		FnTable.SetHeadsetViewBlendRange(flStartPct,flEndPct);
+	}
+	public void GetHeadsetViewBlendRange(ref float pStartPct,ref float pEndPct)
+	{
+		pStartPct = 0;
+		pEndPct = 0;
+		FnTable.GetHeadsetViewBlendRange(ref pStartPct,ref pEndPct);
+	}
+}
+
+
+public class CVRRenderModels
+{
+	IVRRenderModels FnTable;
+	internal CVRRenderModels(IntPtr pInterface)
+	{
+		FnTable = (IVRRenderModels)Marshal.PtrToStructure(pInterface, typeof(IVRRenderModels));
+	}
+	public EVRRenderModelError LoadRenderModel_Async(string pchRenderModelName,ref IntPtr ppRenderModel)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		EVRRenderModelError result = FnTable.LoadRenderModel_Async(pchRenderModelNameUtf8,ref ppRenderModel);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		return result;
+	}
+	public void FreeRenderModel(IntPtr pRenderModel)
+	{
+		FnTable.FreeRenderModel(pRenderModel);
+	}
+	public EVRRenderModelError LoadTexture_Async(int textureId,ref IntPtr ppTexture)
+	{
+		EVRRenderModelError result = FnTable.LoadTexture_Async(textureId,ref ppTexture);
+		return result;
+	}
+	public void FreeTexture(IntPtr pTexture)
+	{
+		FnTable.FreeTexture(pTexture);
+	}
+	public EVRRenderModelError LoadTextureD3D11_Async(int textureId,IntPtr pD3D11Device,ref IntPtr ppD3D11Texture2D)
+	{
+		EVRRenderModelError result = FnTable.LoadTextureD3D11_Async(textureId,pD3D11Device,ref ppD3D11Texture2D);
+		return result;
+	}
+	public EVRRenderModelError LoadIntoTextureD3D11_Async(int textureId,IntPtr pDstTexture)
+	{
+		EVRRenderModelError result = FnTable.LoadIntoTextureD3D11_Async(textureId,pDstTexture);
+		return result;
+	}
+	public void FreeTextureD3D11(IntPtr pD3D11Texture2D)
+	{
+		FnTable.FreeTextureD3D11(pD3D11Texture2D);
+	}
+	public uint GetRenderModelName(uint unRenderModelIndex,System.Text.StringBuilder pchRenderModelName,uint unRenderModelNameLen)
+	{
+		uint result = FnTable.GetRenderModelName(unRenderModelIndex,pchRenderModelName,unRenderModelNameLen);
+		return result;
+	}
+	public uint GetRenderModelCount()
+	{
+		uint result = FnTable.GetRenderModelCount();
+		return result;
+	}
+	public uint GetComponentCount(string pchRenderModelName)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		uint result = FnTable.GetComponentCount(pchRenderModelNameUtf8);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		return result;
+	}
+	public uint GetComponentName(string pchRenderModelName,uint unComponentIndex,System.Text.StringBuilder pchComponentName,uint unComponentNameLen)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		uint result = FnTable.GetComponentName(pchRenderModelNameUtf8,unComponentIndex,pchComponentName,unComponentNameLen);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		return result;
+	}
+	public ulong GetComponentButtonMask(string pchRenderModelName,string pchComponentName)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName);
+		ulong result = FnTable.GetComponentButtonMask(pchRenderModelNameUtf8,pchComponentNameUtf8);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		Marshal.FreeHGlobal(pchComponentNameUtf8);
+		return result;
+	}
+	public uint GetComponentRenderModelName(string pchRenderModelName,string pchComponentName,System.Text.StringBuilder pchComponentRenderModelName,uint unComponentRenderModelNameLen)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName);
+		uint result = FnTable.GetComponentRenderModelName(pchRenderModelNameUtf8,pchComponentNameUtf8,pchComponentRenderModelName,unComponentRenderModelNameLen);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		Marshal.FreeHGlobal(pchComponentNameUtf8);
+		return result;
+	}
+	public bool GetComponentStateForDevicePath(string pchRenderModelName,string pchComponentName,ulong devicePath,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName);
+		bool result = FnTable.GetComponentStateForDevicePath(pchRenderModelNameUtf8,pchComponentNameUtf8,devicePath,ref pState,ref pComponentState);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		Marshal.FreeHGlobal(pchComponentNameUtf8);
+		return result;
+	}
+// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were
+// originally mis-compiled with the wrong packing for Linux and OSX.
+	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+	internal delegate bool _GetComponentStatePacked(IntPtr pchRenderModelName,IntPtr pchComponentName,ref VRControllerState_t_Packed pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState);
+	[StructLayout(LayoutKind.Explicit)]
+	struct GetComponentStateUnion
+	{
+		[FieldOffset(0)]
+		public IVRRenderModels._GetComponentState pGetComponentState;
+		[FieldOffset(0)]
+		public _GetComponentStatePacked pGetComponentStatePacked;
+	}
+	public bool GetComponentState(string pchRenderModelName,string pchComponentName,ref VRControllerState_t pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName);
+#if !UNITY_METRO
+		if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) ||
+				(System.Environment.OSVersion.Platform == System.PlatformID.Unix))
+		{
+			GetComponentStateUnion u;
+			VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState);
+			u.pGetComponentStatePacked = null;
+			u.pGetComponentState = FnTable.GetComponentState;
+			bool packed_result = u.pGetComponentStatePacked(pchRenderModelNameUtf8,pchComponentNameUtf8,ref state_packed,ref pState,ref pComponentState);
+
+			state_packed.Unpack(ref pControllerState);
+			return packed_result;
+		}
+#endif
+		bool result = FnTable.GetComponentState(pchRenderModelNameUtf8,pchComponentNameUtf8,ref pControllerState,ref pState,ref pComponentState);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		Marshal.FreeHGlobal(pchComponentNameUtf8);
+		return result;
+	}
+	public bool RenderModelHasComponent(string pchRenderModelName,string pchComponentName)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName);
+		bool result = FnTable.RenderModelHasComponent(pchRenderModelNameUtf8,pchComponentNameUtf8);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		Marshal.FreeHGlobal(pchComponentNameUtf8);
+		return result;
+	}
+	public uint GetRenderModelThumbnailURL(string pchRenderModelName,System.Text.StringBuilder pchThumbnailURL,uint unThumbnailURLLen,ref EVRRenderModelError peError)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		uint result = FnTable.GetRenderModelThumbnailURL(pchRenderModelNameUtf8,pchThumbnailURL,unThumbnailURLLen,ref peError);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		return result;
+	}
+	public uint GetRenderModelOriginalPath(string pchRenderModelName,System.Text.StringBuilder pchOriginalPath,uint unOriginalPathLen,ref EVRRenderModelError peError)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		uint result = FnTable.GetRenderModelOriginalPath(pchRenderModelNameUtf8,pchOriginalPath,unOriginalPathLen,ref peError);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		return result;
+	}
+	public string GetRenderModelErrorNameFromEnum(EVRRenderModelError error)
+	{
+		IntPtr result = FnTable.GetRenderModelErrorNameFromEnum(error);
+		return Marshal.PtrToStringAnsi(result);
+	}
+}
+
+
+public class CVRNotifications
+{
+	IVRNotifications FnTable;
+	internal CVRNotifications(IntPtr pInterface)
+	{
+		FnTable = (IVRNotifications)Marshal.PtrToStructure(pInterface, typeof(IVRNotifications));
+	}
+	public EVRNotificationError CreateNotification(ulong ulOverlayHandle,ulong ulUserValue,EVRNotificationType type,string pchText,EVRNotificationStyle style,ref NotificationBitmap_t pImage,ref uint pNotificationId)
+	{
+		IntPtr pchTextUtf8 = Utils.ToUtf8(pchText);
+		pNotificationId = 0;
+		EVRNotificationError result = FnTable.CreateNotification(ulOverlayHandle,ulUserValue,type,pchTextUtf8,style,ref pImage,ref pNotificationId);
+		Marshal.FreeHGlobal(pchTextUtf8);
+		return result;
+	}
+	public EVRNotificationError RemoveNotification(uint notificationId)
+	{
+		EVRNotificationError result = FnTable.RemoveNotification(notificationId);
+		return result;
+	}
+}
+
+
+public class CVRSettings
+{
+	IVRSettings FnTable;
+	internal CVRSettings(IntPtr pInterface)
+	{
+		FnTable = (IVRSettings)Marshal.PtrToStructure(pInterface, typeof(IVRSettings));
+	}
+	public string GetSettingsErrorNameFromEnum(EVRSettingsError eError)
+	{
+		IntPtr result = FnTable.GetSettingsErrorNameFromEnum(eError);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public void SetBool(string pchSection,string pchSettingsKey,bool bValue,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		FnTable.SetBool(pchSectionUtf8,pchSettingsKeyUtf8,bValue,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+	}
+	public void SetInt32(string pchSection,string pchSettingsKey,int nValue,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		FnTable.SetInt32(pchSectionUtf8,pchSettingsKeyUtf8,nValue,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+	}
+	public void SetFloat(string pchSection,string pchSettingsKey,float flValue,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		FnTable.SetFloat(pchSectionUtf8,pchSettingsKeyUtf8,flValue,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+	}
+	public void SetString(string pchSection,string pchSettingsKey,string pchValue,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		IntPtr pchValueUtf8 = Utils.ToUtf8(pchValue);
+		FnTable.SetString(pchSectionUtf8,pchSettingsKeyUtf8,pchValueUtf8,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+		Marshal.FreeHGlobal(pchValueUtf8);
+	}
+	public bool GetBool(string pchSection,string pchSettingsKey,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		bool result = FnTable.GetBool(pchSectionUtf8,pchSettingsKeyUtf8,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+		return result;
+	}
+	public int GetInt32(string pchSection,string pchSettingsKey,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		int result = FnTable.GetInt32(pchSectionUtf8,pchSettingsKeyUtf8,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+		return result;
+	}
+	public float GetFloat(string pchSection,string pchSettingsKey,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		float result = FnTable.GetFloat(pchSectionUtf8,pchSettingsKeyUtf8,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+		return result;
+	}
+	public void GetString(string pchSection,string pchSettingsKey,System.Text.StringBuilder pchValue,uint unValueLen,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		FnTable.GetString(pchSectionUtf8,pchSettingsKeyUtf8,pchValue,unValueLen,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+	}
+	public void RemoveSection(string pchSection,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		FnTable.RemoveSection(pchSectionUtf8,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+	}
+	public void RemoveKeyInSection(string pchSection,string pchSettingsKey,ref EVRSettingsError peError)
+	{
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		FnTable.RemoveKeyInSection(pchSectionUtf8,pchSettingsKeyUtf8,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
+	}
+}
+
+
+public class CVRScreenshots
+{
+	IVRScreenshots FnTable;
+	internal CVRScreenshots(IntPtr pInterface)
+	{
+		FnTable = (IVRScreenshots)Marshal.PtrToStructure(pInterface, typeof(IVRScreenshots));
+	}
+	public EVRScreenshotError RequestScreenshot(ref uint pOutScreenshotHandle,EVRScreenshotType type,string pchPreviewFilename,string pchVRFilename)
+	{
+		pOutScreenshotHandle = 0;
+		IntPtr pchPreviewFilenameUtf8 = Utils.ToUtf8(pchPreviewFilename);
+		IntPtr pchVRFilenameUtf8 = Utils.ToUtf8(pchVRFilename);
+		EVRScreenshotError result = FnTable.RequestScreenshot(ref pOutScreenshotHandle,type,pchPreviewFilenameUtf8,pchVRFilenameUtf8);
+		Marshal.FreeHGlobal(pchPreviewFilenameUtf8);
+		Marshal.FreeHGlobal(pchVRFilenameUtf8);
+		return result;
+	}
+	public EVRScreenshotError HookScreenshot(EVRScreenshotType [] pSupportedTypes)
+	{
+		EVRScreenshotError result = FnTable.HookScreenshot(pSupportedTypes,(int) pSupportedTypes.Length);
+		return result;
+	}
+	public EVRScreenshotType GetScreenshotPropertyType(uint screenshotHandle,ref EVRScreenshotError pError)
+	{
+		EVRScreenshotType result = FnTable.GetScreenshotPropertyType(screenshotHandle,ref pError);
+		return result;
+	}
+	public uint GetScreenshotPropertyFilename(uint screenshotHandle,EVRScreenshotPropertyFilenames filenameType,System.Text.StringBuilder pchFilename,uint cchFilename,ref EVRScreenshotError pError)
+	{
+		uint result = FnTable.GetScreenshotPropertyFilename(screenshotHandle,filenameType,pchFilename,cchFilename,ref pError);
+		return result;
+	}
+	public EVRScreenshotError UpdateScreenshotProgress(uint screenshotHandle,float flProgress)
+	{
+		EVRScreenshotError result = FnTable.UpdateScreenshotProgress(screenshotHandle,flProgress);
+		return result;
+	}
+	public EVRScreenshotError TakeStereoScreenshot(ref uint pOutScreenshotHandle,string pchPreviewFilename,string pchVRFilename)
+	{
+		pOutScreenshotHandle = 0;
+		IntPtr pchPreviewFilenameUtf8 = Utils.ToUtf8(pchPreviewFilename);
+		IntPtr pchVRFilenameUtf8 = Utils.ToUtf8(pchVRFilename);
+		EVRScreenshotError result = FnTable.TakeStereoScreenshot(ref pOutScreenshotHandle,pchPreviewFilenameUtf8,pchVRFilenameUtf8);
+		Marshal.FreeHGlobal(pchPreviewFilenameUtf8);
+		Marshal.FreeHGlobal(pchVRFilenameUtf8);
+		return result;
+	}
+	public EVRScreenshotError SubmitScreenshot(uint screenshotHandle,EVRScreenshotType type,string pchSourcePreviewFilename,string pchSourceVRFilename)
+	{
+		IntPtr pchSourcePreviewFilenameUtf8 = Utils.ToUtf8(pchSourcePreviewFilename);
+		IntPtr pchSourceVRFilenameUtf8 = Utils.ToUtf8(pchSourceVRFilename);
+		EVRScreenshotError result = FnTable.SubmitScreenshot(screenshotHandle,type,pchSourcePreviewFilenameUtf8,pchSourceVRFilenameUtf8);
+		Marshal.FreeHGlobal(pchSourcePreviewFilenameUtf8);
+		Marshal.FreeHGlobal(pchSourceVRFilenameUtf8);
+		return result;
+	}
+}
+
+
+public class CVRResources
+{
+	IVRResources FnTable;
+	internal CVRResources(IntPtr pInterface)
+	{
+		FnTable = (IVRResources)Marshal.PtrToStructure(pInterface, typeof(IVRResources));
+	}
+	public uint LoadSharedResource(string pchResourceName,string pchBuffer,uint unBufferLen)
+	{
+		IntPtr pchResourceNameUtf8 = Utils.ToUtf8(pchResourceName);
+		uint result = FnTable.LoadSharedResource(pchResourceNameUtf8,pchBuffer,unBufferLen);
+		Marshal.FreeHGlobal(pchResourceNameUtf8);
+		return result;
+	}
+	public uint GetResourceFullPath(string pchResourceName,string pchResourceTypeDirectory,System.Text.StringBuilder pchPathBuffer,uint unBufferLen)
+	{
+		IntPtr pchResourceNameUtf8 = Utils.ToUtf8(pchResourceName);
+		IntPtr pchResourceTypeDirectoryUtf8 = Utils.ToUtf8(pchResourceTypeDirectory);
+		uint result = FnTable.GetResourceFullPath(pchResourceNameUtf8,pchResourceTypeDirectoryUtf8,pchPathBuffer,unBufferLen);
+		Marshal.FreeHGlobal(pchResourceNameUtf8);
+		Marshal.FreeHGlobal(pchResourceTypeDirectoryUtf8);
+		return result;
+	}
+}
+
+
+public class CVRDriverManager
+{
+	IVRDriverManager FnTable;
+	internal CVRDriverManager(IntPtr pInterface)
+	{
+		FnTable = (IVRDriverManager)Marshal.PtrToStructure(pInterface, typeof(IVRDriverManager));
+	}
+	public uint GetDriverCount()
+	{
+		uint result = FnTable.GetDriverCount();
+		return result;
+	}
+	public uint GetDriverName(uint nDriver,System.Text.StringBuilder pchValue,uint unBufferSize)
+	{
+		uint result = FnTable.GetDriverName(nDriver,pchValue,unBufferSize);
+		return result;
+	}
+	public ulong GetDriverHandle(string pchDriverName)
+	{
+		IntPtr pchDriverNameUtf8 = Utils.ToUtf8(pchDriverName);
+		ulong result = FnTable.GetDriverHandle(pchDriverNameUtf8);
+		Marshal.FreeHGlobal(pchDriverNameUtf8);
+		return result;
+	}
+	public bool IsEnabled(uint nDriver)
+	{
+		bool result = FnTable.IsEnabled(nDriver);
+		return result;
+	}
+}
+
+
+public class CVRInput
+{
+	IVRInput FnTable;
+	internal CVRInput(IntPtr pInterface)
+	{
+		FnTable = (IVRInput)Marshal.PtrToStructure(pInterface, typeof(IVRInput));
+	}
+	public EVRInputError SetActionManifestPath(string pchActionManifestPath)
+	{
+		IntPtr pchActionManifestPathUtf8 = Utils.ToUtf8(pchActionManifestPath);
+		EVRInputError result = FnTable.SetActionManifestPath(pchActionManifestPathUtf8);
+		Marshal.FreeHGlobal(pchActionManifestPathUtf8);
+		return result;
+	}
+	public EVRInputError GetActionSetHandle(string pchActionSetName,ref ulong pHandle)
+	{
+		IntPtr pchActionSetNameUtf8 = Utils.ToUtf8(pchActionSetName);
+		pHandle = 0;
+		EVRInputError result = FnTable.GetActionSetHandle(pchActionSetNameUtf8,ref pHandle);
+		Marshal.FreeHGlobal(pchActionSetNameUtf8);
+		return result;
+	}
+	public EVRInputError GetActionHandle(string pchActionName,ref ulong pHandle)
+	{
+		IntPtr pchActionNameUtf8 = Utils.ToUtf8(pchActionName);
+		pHandle = 0;
+		EVRInputError result = FnTable.GetActionHandle(pchActionNameUtf8,ref pHandle);
+		Marshal.FreeHGlobal(pchActionNameUtf8);
+		return result;
+	}
+	public EVRInputError GetInputSourceHandle(string pchInputSourcePath,ref ulong pHandle)
+	{
+		IntPtr pchInputSourcePathUtf8 = Utils.ToUtf8(pchInputSourcePath);
+		pHandle = 0;
+		EVRInputError result = FnTable.GetInputSourceHandle(pchInputSourcePathUtf8,ref pHandle);
+		Marshal.FreeHGlobal(pchInputSourcePathUtf8);
+		return result;
+	}
+	public EVRInputError UpdateActionState(VRActiveActionSet_t [] pSets,uint unSizeOfVRSelectedActionSet_t)
+	{
+		EVRInputError result = FnTable.UpdateActionState(pSets,unSizeOfVRSelectedActionSet_t,(uint) pSets.Length);
+		return result;
+	}
+	public EVRInputError GetDigitalActionData(ulong action,ref InputDigitalActionData_t pActionData,uint unActionDataSize,ulong ulRestrictToDevice)
+	{
+		EVRInputError result = FnTable.GetDigitalActionData(action,ref pActionData,unActionDataSize,ulRestrictToDevice);
+		return result;
+	}
+	public EVRInputError GetAnalogActionData(ulong action,ref InputAnalogActionData_t pActionData,uint unActionDataSize,ulong ulRestrictToDevice)
+	{
+		EVRInputError result = FnTable.GetAnalogActionData(action,ref pActionData,unActionDataSize,ulRestrictToDevice);
+		return result;
+	}
+	public EVRInputError GetPoseActionDataRelativeToNow(ulong action,ETrackingUniverseOrigin eOrigin,float fPredictedSecondsFromNow,ref InputPoseActionData_t pActionData,uint unActionDataSize,ulong ulRestrictToDevice)
+	{
+		EVRInputError result = FnTable.GetPoseActionDataRelativeToNow(action,eOrigin,fPredictedSecondsFromNow,ref pActionData,unActionDataSize,ulRestrictToDevice);
+		return result;
+	}
+	public EVRInputError GetPoseActionDataForNextFrame(ulong action,ETrackingUniverseOrigin eOrigin,ref InputPoseActionData_t pActionData,uint unActionDataSize,ulong ulRestrictToDevice)
+	{
+		EVRInputError result = FnTable.GetPoseActionDataForNextFrame(action,eOrigin,ref pActionData,unActionDataSize,ulRestrictToDevice);
+		return result;
+	}
+	public EVRInputError GetSkeletalActionData(ulong action,ref InputSkeletalActionData_t pActionData,uint unActionDataSize)
+	{
+		EVRInputError result = FnTable.GetSkeletalActionData(action,ref pActionData,unActionDataSize);
+		return result;
+	}
+	public EVRInputError GetDominantHand(ref ETrackedControllerRole peDominantHand)
+	{
+		EVRInputError result = FnTable.GetDominantHand(ref peDominantHand);
+		return result;
+	}
+	public EVRInputError SetDominantHand(ETrackedControllerRole eDominantHand)
+	{
+		EVRInputError result = FnTable.SetDominantHand(eDominantHand);
+		return result;
+	}
+	public EVRInputError GetBoneCount(ulong action,ref uint pBoneCount)
+	{
+		pBoneCount = 0;
+		EVRInputError result = FnTable.GetBoneCount(action,ref pBoneCount);
+		return result;
+	}
+	public EVRInputError GetBoneHierarchy(ulong action,int [] pParentIndices)
+	{
+		EVRInputError result = FnTable.GetBoneHierarchy(action,pParentIndices,(uint) pParentIndices.Length);
+		return result;
+	}
+	public EVRInputError GetBoneName(ulong action,int nBoneIndex,System.Text.StringBuilder pchBoneName,uint unNameBufferSize)
+	{
+		EVRInputError result = FnTable.GetBoneName(action,nBoneIndex,pchBoneName,unNameBufferSize);
+		return result;
+	}
+	public EVRInputError GetSkeletalReferenceTransforms(ulong action,EVRSkeletalTransformSpace eTransformSpace,EVRSkeletalReferencePose eReferencePose,VRBoneTransform_t [] pTransformArray)
+	{
+		EVRInputError result = FnTable.GetSkeletalReferenceTransforms(action,eTransformSpace,eReferencePose,pTransformArray,(uint) pTransformArray.Length);
+		return result;
+	}
+	public EVRInputError GetSkeletalTrackingLevel(ulong action,ref EVRSkeletalTrackingLevel pSkeletalTrackingLevel)
+	{
+		EVRInputError result = FnTable.GetSkeletalTrackingLevel(action,ref pSkeletalTrackingLevel);
+		return result;
+	}
+	public EVRInputError GetSkeletalBoneData(ulong action,EVRSkeletalTransformSpace eTransformSpace,EVRSkeletalMotionRange eMotionRange,VRBoneTransform_t [] pTransformArray)
+	{
+		EVRInputError result = FnTable.GetSkeletalBoneData(action,eTransformSpace,eMotionRange,pTransformArray,(uint) pTransformArray.Length);
+		return result;
+	}
+	public EVRInputError GetSkeletalSummaryData(ulong action,EVRSummaryType eSummaryType,ref VRSkeletalSummaryData_t pSkeletalSummaryData)
+	{
+		EVRInputError result = FnTable.GetSkeletalSummaryData(action,eSummaryType,ref pSkeletalSummaryData);
+		return result;
+	}
+	public EVRInputError GetSkeletalBoneDataCompressed(ulong action,EVRSkeletalMotionRange eMotionRange,IntPtr pvCompressedData,uint unCompressedSize,ref uint punRequiredCompressedSize)
+	{
+		punRequiredCompressedSize = 0;
+		EVRInputError result = FnTable.GetSkeletalBoneDataCompressed(action,eMotionRange,pvCompressedData,unCompressedSize,ref punRequiredCompressedSize);
+		return result;
+	}
+	public EVRInputError DecompressSkeletalBoneData(IntPtr pvCompressedBuffer,uint unCompressedBufferSize,EVRSkeletalTransformSpace eTransformSpace,VRBoneTransform_t [] pTransformArray)
+	{
+		EVRInputError result = FnTable.DecompressSkeletalBoneData(pvCompressedBuffer,unCompressedBufferSize,eTransformSpace,pTransformArray,(uint) pTransformArray.Length);
+		return result;
+	}
+	public EVRInputError TriggerHapticVibrationAction(ulong action,float fStartSecondsFromNow,float fDurationSeconds,float fFrequency,float fAmplitude,ulong ulRestrictToDevice)
+	{
+		EVRInputError result = FnTable.TriggerHapticVibrationAction(action,fStartSecondsFromNow,fDurationSeconds,fFrequency,fAmplitude,ulRestrictToDevice);
+		return result;
+	}
+	public EVRInputError GetActionOrigins(ulong actionSetHandle,ulong digitalActionHandle,ulong [] originsOut)
+	{
+		EVRInputError result = FnTable.GetActionOrigins(actionSetHandle,digitalActionHandle,originsOut,(uint) originsOut.Length);
+		return result;
+	}
+	public EVRInputError GetOriginLocalizedName(ulong origin,System.Text.StringBuilder pchNameArray,uint unNameArraySize,int unStringSectionsToInclude)
+	{
+		EVRInputError result = FnTable.GetOriginLocalizedName(origin,pchNameArray,unNameArraySize,unStringSectionsToInclude);
+		return result;
+	}
+	public EVRInputError GetOriginTrackedDeviceInfo(ulong origin,ref InputOriginInfo_t pOriginInfo,uint unOriginInfoSize)
+	{
+		EVRInputError result = FnTable.GetOriginTrackedDeviceInfo(origin,ref pOriginInfo,unOriginInfoSize);
+		return result;
+	}
+	public EVRInputError GetActionBindingInfo(ulong action,ref InputBindingInfo_t pOriginInfo,uint unBindingInfoSize,uint unBindingInfoCount,ref uint punReturnedBindingInfoCount)
+	{
+		punReturnedBindingInfoCount = 0;
+		EVRInputError result = FnTable.GetActionBindingInfo(action,ref pOriginInfo,unBindingInfoSize,unBindingInfoCount,ref punReturnedBindingInfoCount);
+		return result;
+	}
+	public EVRInputError ShowActionOrigins(ulong actionSetHandle,ulong ulActionHandle)
+	{
+		EVRInputError result = FnTable.ShowActionOrigins(actionSetHandle,ulActionHandle);
+		return result;
+	}
+	public EVRInputError ShowBindingsForActionSet(VRActiveActionSet_t [] pSets,uint unSizeOfVRSelectedActionSet_t,ulong originToHighlight)
+	{
+		EVRInputError result = FnTable.ShowBindingsForActionSet(pSets,unSizeOfVRSelectedActionSet_t,(uint) pSets.Length,originToHighlight);
+		return result;
+	}
+	public EVRInputError GetComponentStateForBinding(string pchRenderModelName,string pchComponentName,ref InputBindingInfo_t pOriginInfo,uint unBindingInfoSize,uint unBindingInfoCount,ref RenderModel_ComponentState_t pComponentState)
+	{
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName);
+		EVRInputError result = FnTable.GetComponentStateForBinding(pchRenderModelNameUtf8,pchComponentNameUtf8,ref pOriginInfo,unBindingInfoSize,unBindingInfoCount,ref pComponentState);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
+		Marshal.FreeHGlobal(pchComponentNameUtf8);
+		return result;
+	}
+	public bool IsUsingLegacyInput()
+	{
+		bool result = FnTable.IsUsingLegacyInput();
+		return result;
+	}
+	public EVRInputError OpenBindingUI(string pchAppKey,ulong ulActionSetHandle,ulong ulDeviceHandle,bool bShowOnDesktop)
+	{
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRInputError result = FnTable.OpenBindingUI(pchAppKeyUtf8,ulActionSetHandle,ulDeviceHandle,bShowOnDesktop);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
+		return result;
+	}
+	public EVRInputError GetBindingVariant(ulong ulDevicePath,System.Text.StringBuilder pchVariantArray,uint unVariantArraySize)
+	{
+		EVRInputError result = FnTable.GetBindingVariant(ulDevicePath,pchVariantArray,unVariantArraySize);
+		return result;
+	}
+}
+
+
+public class CVRIOBuffer
+{
+	IVRIOBuffer FnTable;
+	internal CVRIOBuffer(IntPtr pInterface)
+	{
+		FnTable = (IVRIOBuffer)Marshal.PtrToStructure(pInterface, typeof(IVRIOBuffer));
+	}
+	public EIOBufferError Open(string pchPath,EIOBufferMode mode,uint unElementSize,uint unElements,ref ulong pulBuffer)
+	{
+		IntPtr pchPathUtf8 = Utils.ToUtf8(pchPath);
+		pulBuffer = 0;
+		EIOBufferError result = FnTable.Open(pchPathUtf8,mode,unElementSize,unElements,ref pulBuffer);
+		Marshal.FreeHGlobal(pchPathUtf8);
+		return result;
+	}
+	public EIOBufferError Close(ulong ulBuffer)
+	{
+		EIOBufferError result = FnTable.Close(ulBuffer);
+		return result;
+	}
+	public EIOBufferError Read(ulong ulBuffer,IntPtr pDst,uint unBytes,ref uint punRead)
+	{
+		punRead = 0;
+		EIOBufferError result = FnTable.Read(ulBuffer,pDst,unBytes,ref punRead);
+		return result;
+	}
+	public EIOBufferError Write(ulong ulBuffer,IntPtr pSrc,uint unBytes)
+	{
+		EIOBufferError result = FnTable.Write(ulBuffer,pSrc,unBytes);
+		return result;
+	}
+	public ulong PropertyContainer(ulong ulBuffer)
+	{
+		ulong result = FnTable.PropertyContainer(ulBuffer);
+		return result;
+	}
+	public bool HasReaders(ulong ulBuffer)
+	{
+		bool result = FnTable.HasReaders(ulBuffer);
+		return result;
+	}
+}
+
+
+public class CVRSpatialAnchors
+{
+	IVRSpatialAnchors FnTable;
+	internal CVRSpatialAnchors(IntPtr pInterface)
+	{
+		FnTable = (IVRSpatialAnchors)Marshal.PtrToStructure(pInterface, typeof(IVRSpatialAnchors));
+	}
+	public EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor(string pchDescriptor,ref uint pHandleOut)
+	{
+		IntPtr pchDescriptorUtf8 = Utils.ToUtf8(pchDescriptor);
+		pHandleOut = 0;
+		EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromDescriptor(pchDescriptorUtf8,ref pHandleOut);
+		Marshal.FreeHGlobal(pchDescriptorUtf8);
+		return result;
+	}
+	public EVRSpatialAnchorError CreateSpatialAnchorFromPose(uint unDeviceIndex,ETrackingUniverseOrigin eOrigin,ref SpatialAnchorPose_t pPose,ref uint pHandleOut)
+	{
+		pHandleOut = 0;
+		EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromPose(unDeviceIndex,eOrigin,ref pPose,ref pHandleOut);
+		return result;
+	}
+	public EVRSpatialAnchorError GetSpatialAnchorPose(uint unHandle,ETrackingUniverseOrigin eOrigin,ref SpatialAnchorPose_t pPoseOut)
+	{
+		EVRSpatialAnchorError result = FnTable.GetSpatialAnchorPose(unHandle,eOrigin,ref pPoseOut);
+		return result;
+	}
+	public EVRSpatialAnchorError GetSpatialAnchorDescriptor(uint unHandle,System.Text.StringBuilder pchDescriptorOut,ref uint punDescriptorBufferLenInOut)
+	{
+		punDescriptorBufferLenInOut = 0;
+		EVRSpatialAnchorError result = FnTable.GetSpatialAnchorDescriptor(unHandle,pchDescriptorOut,ref punDescriptorBufferLenInOut);
+		return result;
+	}
+}
+
+
+public class CVRDebug
+{
+	IVRDebug FnTable;
+	internal CVRDebug(IntPtr pInterface)
+	{
+		FnTable = (IVRDebug)Marshal.PtrToStructure(pInterface, typeof(IVRDebug));
+	}
+	public EVRDebugError EmitVrProfilerEvent(string pchMessage)
+	{
+		IntPtr pchMessageUtf8 = Utils.ToUtf8(pchMessage);
+		EVRDebugError result = FnTable.EmitVrProfilerEvent(pchMessageUtf8);
+		Marshal.FreeHGlobal(pchMessageUtf8);
+		return result;
+	}
+	public EVRDebugError BeginVrProfilerEvent(ref ulong pHandleOut)
+	{
+		pHandleOut = 0;
+		EVRDebugError result = FnTable.BeginVrProfilerEvent(ref pHandleOut);
+		return result;
+	}
+	public EVRDebugError FinishVrProfilerEvent(ulong hHandle,string pchMessage)
+	{
+		IntPtr pchMessageUtf8 = Utils.ToUtf8(pchMessage);
+		EVRDebugError result = FnTable.FinishVrProfilerEvent(hHandle,pchMessageUtf8);
+		Marshal.FreeHGlobal(pchMessageUtf8);
+		return result;
+	}
+	public uint DriverDebugRequest(uint unDeviceIndex,string pchRequest,System.Text.StringBuilder pchResponseBuffer,uint unResponseBufferSize)
+	{
+		IntPtr pchRequestUtf8 = Utils.ToUtf8(pchRequest);
+		uint result = FnTable.DriverDebugRequest(unDeviceIndex,pchRequestUtf8,pchResponseBuffer,unResponseBufferSize);
+		Marshal.FreeHGlobal(pchRequestUtf8);
+		return result;
+	}
+}
+
+
+public class CVRProperties
+{
+	IVRProperties FnTable;
+	internal CVRProperties(IntPtr pInterface)
+	{
+		FnTable = (IVRProperties)Marshal.PtrToStructure(pInterface, typeof(IVRProperties));
+	}
+	public ETrackedPropertyError ReadPropertyBatch(ulong ulContainerHandle,ref PropertyRead_t pBatch,uint unBatchEntryCount)
+	{
+		ETrackedPropertyError result = FnTable.ReadPropertyBatch(ulContainerHandle,ref pBatch,unBatchEntryCount);
+		return result;
+	}
+	public ETrackedPropertyError WritePropertyBatch(ulong ulContainerHandle,ref PropertyWrite_t pBatch,uint unBatchEntryCount)
+	{
+		ETrackedPropertyError result = FnTable.WritePropertyBatch(ulContainerHandle,ref pBatch,unBatchEntryCount);
+		return result;
+	}
+	public string GetPropErrorNameFromEnum(ETrackedPropertyError error)
+	{
+		IntPtr result = FnTable.GetPropErrorNameFromEnum(error);
+		return Marshal.PtrToStringAnsi(result);
+	}
+	public ulong TrackedDeviceToPropertyContainer(uint nDevice)
+	{
+		ulong result = FnTable.TrackedDeviceToPropertyContainer(nDevice);
+		return result;
+	}
+}
+
+
+public class CVRPaths
+{
+	IVRPaths FnTable;
+	internal CVRPaths(IntPtr pInterface)
+	{
+		FnTable = (IVRPaths)Marshal.PtrToStructure(pInterface, typeof(IVRPaths));
+	}
+	public ETrackedPropertyError ReadPathBatch(ulong ulRootHandle,ref PathRead_t pBatch,uint unBatchEntryCount)
+	{
+		ETrackedPropertyError result = FnTable.ReadPathBatch(ulRootHandle,ref pBatch,unBatchEntryCount);
+		return result;
+	}
+	public ETrackedPropertyError WritePathBatch(ulong ulRootHandle,ref PathWrite_t pBatch,uint unBatchEntryCount)
+	{
+		ETrackedPropertyError result = FnTable.WritePathBatch(ulRootHandle,ref pBatch,unBatchEntryCount);
+		return result;
+	}
+	public ETrackedPropertyError StringToHandle(ref ulong pHandle,string pchPath)
+	{
+		pHandle = 0;
+		IntPtr pchPathUtf8 = Utils.ToUtf8(pchPath);
+		ETrackedPropertyError result = FnTable.StringToHandle(ref pHandle,pchPathUtf8);
+		Marshal.FreeHGlobal(pchPathUtf8);
+		return result;
+	}
+	public ETrackedPropertyError HandleToString(ulong pHandle,string pchBuffer,uint unBufferSize,ref uint punBufferSizeUsed)
+	{
+		punBufferSizeUsed = 0;
+		ETrackedPropertyError result = FnTable.HandleToString(pHandle,pchBuffer,unBufferSize,ref punBufferSizeUsed);
+		return result;
+	}
+}
+
+
+public class CVRBlockQueue
+{
+	IVRBlockQueue FnTable;
+	internal CVRBlockQueue(IntPtr pInterface)
+	{
+		FnTable = (IVRBlockQueue)Marshal.PtrToStructure(pInterface, typeof(IVRBlockQueue));
+	}
+	public EBlockQueueError Create(ref ulong pulQueueHandle,string pchPath,uint unBlockDataSize,uint unBlockHeaderSize,uint unBlockCount)
+	{
+		pulQueueHandle = 0;
+		IntPtr pchPathUtf8 = Utils.ToUtf8(pchPath);
+		EBlockQueueError result = FnTable.Create(ref pulQueueHandle,pchPathUtf8,unBlockDataSize,unBlockHeaderSize,unBlockCount);
+		Marshal.FreeHGlobal(pchPathUtf8);
+		return result;
+	}
+	public EBlockQueueError Connect(ref ulong pulQueueHandle,string pchPath)
+	{
+		pulQueueHandle = 0;
+		IntPtr pchPathUtf8 = Utils.ToUtf8(pchPath);
+		EBlockQueueError result = FnTable.Connect(ref pulQueueHandle,pchPathUtf8);
+		Marshal.FreeHGlobal(pchPathUtf8);
+		return result;
+	}
+	public EBlockQueueError Destroy(ulong ulQueueHandle)
+	{
+		EBlockQueueError result = FnTable.Destroy(ulQueueHandle);
+		return result;
+	}
+	public EBlockQueueError AcquireWriteOnlyBlock(ulong ulQueueHandle,ref ulong pulBlockHandle,ref IntPtr ppvBuffer)
+	{
+		pulBlockHandle = 0;
+		EBlockQueueError result = FnTable.AcquireWriteOnlyBlock(ulQueueHandle,ref pulBlockHandle,ref ppvBuffer);
+		return result;
+	}
+	public EBlockQueueError ReleaseWriteOnlyBlock(ulong ulQueueHandle,ulong ulBlockHandle)
+	{
+		EBlockQueueError result = FnTable.ReleaseWriteOnlyBlock(ulQueueHandle,ulBlockHandle);
+		return result;
+	}
+	public EBlockQueueError WaitAndAcquireReadOnlyBlock(ulong ulQueueHandle,ref ulong pulBlockHandle,ref IntPtr ppvBuffer,EBlockQueueReadType eReadType,uint unTimeoutMs)
+	{
+		pulBlockHandle = 0;
+		EBlockQueueError result = FnTable.WaitAndAcquireReadOnlyBlock(ulQueueHandle,ref pulBlockHandle,ref ppvBuffer,eReadType,unTimeoutMs);
+		return result;
+	}
+	public EBlockQueueError AcquireReadOnlyBlock(ulong ulQueueHandle,ref ulong pulBlockHandle,ref IntPtr ppvBuffer,EBlockQueueReadType eReadType)
+	{
+		pulBlockHandle = 0;
+		EBlockQueueError result = FnTable.AcquireReadOnlyBlock(ulQueueHandle,ref pulBlockHandle,ref ppvBuffer,eReadType);
+		return result;
+	}
+	public EBlockQueueError ReleaseReadOnlyBlock(ulong ulQueueHandle,ulong ulBlockHandle)
+	{
+		EBlockQueueError result = FnTable.ReleaseReadOnlyBlock(ulQueueHandle,ulBlockHandle);
+		return result;
+	}
+	public EBlockQueueError QueueHasReader(ulong ulQueueHandle,ref bool pbHasReaders)
+	{
+		pbHasReaders = false;
+		EBlockQueueError result = FnTable.QueueHasReader(ulQueueHandle,ref pbHasReaders);
+		return result;
+	}
+}
+
+
+public class OpenVRInterop
+{
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType);
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal2", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType,[In, MarshalAs(UnmanagedType.LPStr)] string pStartupInfo);
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_ShutdownInternal", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern void ShutdownInternal();
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_IsHmdPresent", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern bool IsHmdPresent();
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_IsRuntimeInstalled", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern bool IsRuntimeInstalled();
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_RuntimePath", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern string RuntimePath();
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_GetRuntimePath", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern bool GetRuntimePath(System.Text.StringBuilder pchPathBuffer, uint unBufferSize, ref uint punRequiredBufferSize);
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_GetStringForHmdError", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern IntPtr GetStringForHmdError(EVRInitError error);
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_GetGenericInterface", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern IntPtr GetGenericInterface([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion, ref EVRInitError peError);
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_IsInterfaceVersionValid", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern bool IsInterfaceVersionValid([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion);
+	[DllImportAttribute("openvr_api", EntryPoint = "VR_GetInitToken", CallingConvention = CallingConvention.Cdecl)]
+	internal static extern uint GetInitToken();
+}
+
+
+public enum EVREye
+{
+	Eye_Left = 0,
+	Eye_Right = 1,
+}
+public enum ETextureType
+{
+	Invalid = -1,
+	DirectX = 0,
+	OpenGL = 1,
+	Vulkan = 2,
+	IOSurface = 3,
+	DirectX12 = 4,
+	DXGISharedHandle = 5,
+	Metal = 6,
+}
+public enum EColorSpace
+{
+	Auto = 0,
+	Gamma = 1,
+	Linear = 2,
+}
+public enum ETrackingResult
+{
+	Uninitialized = 1,
+	Calibrating_InProgress = 100,
+	Calibrating_OutOfRange = 101,
+	Running_OK = 200,
+	Running_OutOfRange = 201,
+	Fallback_RotationOnly = 300,
+}
+public enum ETrackedDeviceClass
+{
+	Invalid = 0,
+	HMD = 1,
+	Controller = 2,
+	GenericTracker = 3,
+	TrackingReference = 4,
+	DisplayRedirect = 5,
+	Max = 6,
+}
+public enum ETrackedControllerRole
+{
+	Invalid = 0,
+	LeftHand = 1,
+	RightHand = 2,
+	OptOut = 3,
+	Treadmill = 4,
+	Stylus = 5,
+	Max = 5,
+}
+public enum ETrackingUniverseOrigin
+{
+	TrackingUniverseSeated = 0,
+	TrackingUniverseStanding = 1,
+	TrackingUniverseRawAndUncalibrated = 2,
+}
+public enum EAdditionalRadioFeatures
+{
+	None = 0,
+	HTCLinkBox = 1,
+	InternalDongle = 2,
+	ExternalDongle = 4,
+}
+public enum ETrackedDeviceProperty
+{
+	Prop_Invalid = 0,
+	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,
+	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,
+	Prop_NeverTracked_Bool = 1038,
+	Prop_NumCameras_Int32 = 1039,
+	Prop_CameraFrameLayout_Int32 = 1040,
+	Prop_CameraStreamFormat_Int32 = 1041,
+	Prop_AdditionalDeviceSettingsPath_String = 1042,
+	Prop_Identifiable_Bool = 1043,
+	Prop_BootloaderVersion_Uint64 = 1044,
+	Prop_AdditionalSystemReportData_String = 1045,
+	Prop_CompositeFirmwareVersion_String = 1046,
+	Prop_Firmware_RemindUpdate_Bool = 1047,
+	Prop_PeripheralApplicationVersion_Uint64 = 1048,
+	Prop_ManufacturerSerialNumber_String = 1049,
+	Prop_ComputedSerialNumber_String = 1050,
+	Prop_EstimatedDeviceFirstUseTime_Int32 = 1051,
+	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,
+	Prop_ExpectedControllerCount_Int32 = 2050,
+	Prop_NamedIconPathControllerLeftDeviceOff_String = 2051,
+	Prop_NamedIconPathControllerRightDeviceOff_String = 2052,
+	Prop_NamedIconPathTrackingReferenceDeviceOff_String = 2053,
+	Prop_DoNotApplyPrediction_Bool = 2054,
+	Prop_CameraToHeadTransforms_Matrix34_Array = 2055,
+	Prop_DistortionMeshResolution_Int32 = 2056,
+	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,
+	Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069,
+	Prop_AdditionalRadioFeatures_Uint64 = 2070,
+	Prop_CameraWhiteBalance_Vector4_Array = 2071,
+	Prop_CameraDistortionFunction_Int32_Array = 2072,
+	Prop_CameraDistortionCoefficients_Float_Array = 2073,
+	Prop_ExpectedControllerType_String = 2074,
+	Prop_HmdTrackingStyle_Int32 = 2075,
+	Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
+	Prop_HmdColumnCorrectionSettingPrefix_String = 2077,
+	Prop_CameraSupportsCompatibilityModes_Bool = 2078,
+	Prop_SupportsRoomViewDepthProjection_Bool = 2079,
+	Prop_DisplayAvailableFrameRates_Float_Array = 2080,
+	Prop_DisplaySupportsMultipleFramerates_Bool = 2081,
+	Prop_DisplayColorMultLeft_Vector3 = 2082,
+	Prop_DisplayColorMultRight_Vector3 = 2083,
+	Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084,
+	Prop_DisplaySupportsAnalogGain_Bool = 2085,
+	Prop_DisplayMinAnalogGain_Float = 2086,
+	Prop_DisplayMaxAnalogGain_Float = 2087,
+	Prop_CameraExposureTime_Float = 2088,
+	Prop_CameraGlobalGain_Float = 2089,
+	Prop_DashboardScale_Float = 2091,
+	Prop_IpdUIRangeMinMeters_Float = 2100,
+	Prop_IpdUIRangeMaxMeters_Float = 2101,
+	Prop_Hmd_SupportsHDCP14LegacyCompat_Bool = 2102,
+	Prop_Hmd_SupportsMicMonitoring_Bool = 2103,
+	Prop_DriverRequestedMuraCorrectionMode_Int32 = 2200,
+	Prop_DriverRequestedMuraFeather_InnerLeft_Int32 = 2201,
+	Prop_DriverRequestedMuraFeather_InnerRight_Int32 = 2202,
+	Prop_DriverRequestedMuraFeather_InnerTop_Int32 = 2203,
+	Prop_DriverRequestedMuraFeather_InnerBottom_Int32 = 2204,
+	Prop_DriverRequestedMuraFeather_OuterLeft_Int32 = 2205,
+	Prop_DriverRequestedMuraFeather_OuterRight_Int32 = 2206,
+	Prop_DriverRequestedMuraFeather_OuterTop_Int32 = 2207,
+	Prop_DriverRequestedMuraFeather_OuterBottom_Int32 = 2208,
+	Prop_Audio_DefaultPlaybackDeviceId_String = 2300,
+	Prop_Audio_DefaultRecordingDeviceId_String = 2301,
+	Prop_Audio_DefaultPlaybackDeviceVolume_Float = 2302,
+	Prop_Audio_SupportsDualSpeakerAndJackOutput_Bool = 2303,
+	Prop_AttachedDeviceId_String = 3000,
+	Prop_SupportedButtons_Uint64 = 3001,
+	Prop_Axis0Type_Int32 = 3002,
+	Prop_Axis1Type_Int32 = 3003,
+	Prop_Axis2Type_Int32 = 3004,
+	Prop_Axis3Type_Int32 = 3005,
+	Prop_Axis4Type_Int32 = 3006,
+	Prop_ControllerRoleHint_Int32 = 3007,
+	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,
+	Prop_Nonce_Int32 = 4008,
+	Prop_IconPathName_String = 5000,
+	Prop_NamedIconPathDeviceOff_String = 5001,
+	Prop_NamedIconPathDeviceSearching_String = 5002,
+	Prop_NamedIconPathDeviceSearchingAlert_String = 5003,
+	Prop_NamedIconPathDeviceReady_String = 5004,
+	Prop_NamedIconPathDeviceReadyAlert_String = 5005,
+	Prop_NamedIconPathDeviceNotReady_String = 5006,
+	Prop_NamedIconPathDeviceStandby_String = 5007,
+	Prop_NamedIconPathDeviceAlertLow_String = 5008,
+	Prop_NamedIconPathDeviceStandbyAlert_String = 5009,
+	Prop_DisplayHiddenArea_Binary_Start = 5100,
+	Prop_DisplayHiddenArea_Binary_End = 5150,
+	Prop_ParentContainer = 5151,
+	Prop_OverrideContainer_Uint64 = 5152,
+	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,
+	Prop_ControllerType_String = 7000,
+	Prop_ControllerHandSelectionPriority_Int32 = 7002,
+	Prop_VendorSpecific_Reserved_Start = 10000,
+	Prop_VendorSpecific_Reserved_End = 10999,
+	Prop_TrackedDeviceProperty_Max = 1000000,
+}
+public enum ETrackedPropertyError
+{
+	TrackedProp_Success = 0,
+	TrackedProp_WrongDataType = 1,
+	TrackedProp_WrongDeviceClass = 2,
+	TrackedProp_BufferTooSmall = 3,
+	TrackedProp_UnknownProperty = 4,
+	TrackedProp_InvalidDevice = 5,
+	TrackedProp_CouldNotContactServer = 6,
+	TrackedProp_ValueNotProvidedByDevice = 7,
+	TrackedProp_StringExceedsMaximumLength = 8,
+	TrackedProp_NotYetAvailable = 9,
+	TrackedProp_PermissionDenied = 10,
+	TrackedProp_InvalidOperation = 11,
+	TrackedProp_CannotWriteToWildcards = 12,
+	TrackedProp_IPCReadFailure = 13,
+	TrackedProp_OutOfMemory = 14,
+	TrackedProp_InvalidContainer = 15,
+}
+public enum EHmdTrackingStyle
+{
+	Unknown = 0,
+	Lighthouse = 1,
+	OutsideInCameras = 2,
+	InsideOutCameras = 3,
+}
+public enum EVRSubmitFlags
+{
+	Submit_Default = 0,
+	Submit_LensDistortionAlreadyApplied = 1,
+	Submit_GlRenderBuffer = 2,
+	Submit_Reserved = 4,
+	Submit_TextureWithPose = 8,
+	Submit_TextureWithDepth = 16,
+	Submit_FrameDiscontinuty = 32,
+	Submit_VulkanTextureWithArrayData = 64,
+	Submit_GlArrayTexture = 128,
+	Submit_Reserved2 = 32768,
+}
+public enum EVRState
+{
+	Undefined = -1,
+	Off = 0,
+	Searching = 1,
+	Searching_Alert = 2,
+	Ready = 3,
+	Ready_Alert = 4,
+	NotReady = 5,
+	Standby = 6,
+	Ready_Alert_Low = 7,
+}
+public 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,
+	VREvent_ButtonUnpress = 201,
+	VREvent_ButtonTouch = 202,
+	VREvent_ButtonUntouch = 203,
+	VREvent_Modal_Cancel = 257,
+	VREvent_MouseMove = 300,
+	VREvent_MouseButtonDown = 301,
+	VREvent_MouseButtonUp = 302,
+	VREvent_FocusEnter = 303,
+	VREvent_FocusLeave = 304,
+	VREvent_ScrollDiscrete = 305,
+	VREvent_TouchPadMove = 306,
+	VREvent_OverlayFocusChanged = 307,
+	VREvent_ReloadOverlays = 308,
+	VREvent_ScrollSmooth = 309,
+	VREvent_LockMousePosition = 310,
+	VREvent_UnlockMousePosition = 311,
+	VREvent_InputFocusCaptured = 400,
+	VREvent_InputFocusReleased = 401,
+	VREvent_SceneApplicationChanged = 404,
+	VREvent_SceneFocusChanged = 405,
+	VREvent_InputFocusChanged = 406,
+	VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408,
+	VREvent_ActionBindingReloaded = 409,
+	VREvent_HideRenderModels = 410,
+	VREvent_ShowRenderModels = 411,
+	VREvent_SceneApplicationStateChanged = 412,
+	VREvent_ConsoleOpened = 420,
+	VREvent_ConsoleClosed = 421,
+	VREvent_OverlayShown = 500,
+	VREvent_OverlayHidden = 501,
+	VREvent_DashboardActivated = 502,
+	VREvent_DashboardDeactivated = 503,
+	VREvent_DashboardRequested = 505,
+	VREvent_ResetDashboard = 506,
+	VREvent_ImageLoaded = 508,
+	VREvent_ShowKeyboard = 509,
+	VREvent_HideKeyboard = 510,
+	VREvent_OverlayGamepadFocusGained = 511,
+	VREvent_OverlayGamepadFocusLost = 512,
+	VREvent_OverlaySharedTextureChanged = 513,
+	VREvent_ScreenshotTriggered = 516,
+	VREvent_ImageFailed = 517,
+	VREvent_DashboardOverlayCreated = 518,
+	VREvent_SwitchGamepadFocus = 519,
+	VREvent_RequestScreenshot = 520,
+	VREvent_ScreenshotTaken = 521,
+	VREvent_ScreenshotFailed = 522,
+	VREvent_SubmitScreenshotToDashboard = 523,
+	VREvent_ScreenshotProgressToDashboard = 524,
+	VREvent_PrimaryDashboardDeviceChanged = 525,
+	VREvent_RoomViewShown = 526,
+	VREvent_RoomViewHidden = 527,
+	VREvent_ShowUI = 528,
+	VREvent_ShowDevTools = 529,
+	VREvent_DesktopViewUpdating = 530,
+	VREvent_DesktopViewReady = 531,
+	VREvent_Notification_Shown = 600,
+	VREvent_Notification_Hidden = 601,
+	VREvent_Notification_BeginInteraction = 602,
+	VREvent_Notification_Destroyed = 603,
+	VREvent_Quit = 700,
+	VREvent_ProcessQuit = 701,
+	VREvent_QuitAcknowledged = 703,
+	VREvent_DriverRequestedQuit = 704,
+	VREvent_RestartRequested = 705,
+	VREvent_ChaperoneDataHasChanged = 800,
+	VREvent_ChaperoneUniverseHasChanged = 801,
+	VREvent_ChaperoneTempDataHasChanged = 802,
+	VREvent_ChaperoneSettingsHaveChanged = 803,
+	VREvent_SeatedZeroPoseReset = 804,
+	VREvent_ChaperoneFlushCache = 805,
+	VREvent_ChaperoneRoomSetupStarting = 806,
+	VREvent_ChaperoneRoomSetupFinished = 807,
+	VREvent_StandingZeroPoseReset = 808,
+	VREvent_AudioSettingsHaveChanged = 820,
+	VREvent_BackgroundSettingHasChanged = 850,
+	VREvent_CameraSettingsHaveChanged = 851,
+	VREvent_ReprojectionSettingHasChanged = 852,
+	VREvent_ModelSkinSettingsHaveChanged = 853,
+	VREvent_EnvironmentSettingsHaveChanged = 854,
+	VREvent_PowerSettingsHaveChanged = 855,
+	VREvent_EnableHomeAppSettingsHaveChanged = 856,
+	VREvent_SteamVRSectionSettingChanged = 857,
+	VREvent_LighthouseSectionSettingChanged = 858,
+	VREvent_NullSectionSettingChanged = 859,
+	VREvent_UserInterfaceSectionSettingChanged = 860,
+	VREvent_NotificationsSectionSettingChanged = 861,
+	VREvent_KeyboardSectionSettingChanged = 862,
+	VREvent_PerfSectionSettingChanged = 863,
+	VREvent_DashboardSectionSettingChanged = 864,
+	VREvent_WebInterfaceSectionSettingChanged = 865,
+	VREvent_TrackersSectionSettingChanged = 866,
+	VREvent_LastKnownSectionSettingChanged = 867,
+	VREvent_DismissedWarningsSectionSettingChanged = 868,
+	VREvent_GpuSpeedSectionSettingChanged = 869,
+	VREvent_WindowsMRSectionSettingChanged = 870,
+	VREvent_OtherSectionSettingChanged = 871,
+	VREvent_StatusUpdate = 900,
+	VREvent_WebInterface_InstallDriverCompleted = 950,
+	VREvent_MCImageUpdated = 1000,
+	VREvent_FirmwareUpdateStarted = 1100,
+	VREvent_FirmwareUpdateFinished = 1101,
+	VREvent_KeyboardClosed = 1200,
+	VREvent_KeyboardCharInput = 1201,
+	VREvent_KeyboardDone = 1202,
+	VREvent_ApplicationListUpdated = 1303,
+	VREvent_ApplicationMimeTypeLoad = 1304,
+	VREvent_ProcessConnected = 1306,
+	VREvent_ProcessDisconnected = 1307,
+	VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+	VREvent_Compositor_DisplayDisconnected = 1412,
+	VREvent_Compositor_DisplayReconnected = 1413,
+	VREvent_Compositor_HDCPError = 1414,
+	VREvent_Compositor_ApplicationNotResponding = 1415,
+	VREvent_Compositor_ApplicationResumed = 1416,
+	VREvent_Compositor_OutOfVideoMemory = 1417,
+	VREvent_Compositor_DisplayModeNotSupported = 1418,
+	VREvent_Compositor_StageOverrideReady = 1419,
+	VREvent_TrackedCamera_StartVideoStream = 1500,
+	VREvent_TrackedCamera_StopVideoStream = 1501,
+	VREvent_TrackedCamera_PauseVideoStream = 1502,
+	VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	VREvent_TrackedCamera_EditingSurface = 1550,
+	VREvent_PerformanceTest_EnableCapture = 1600,
+	VREvent_PerformanceTest_DisableCapture = 1601,
+	VREvent_PerformanceTest_FidelityLevel = 1602,
+	VREvent_MessageOverlay_Closed = 1650,
+	VREvent_MessageOverlayCloseRequested = 1651,
+	VREvent_Input_HapticVibration = 1700,
+	VREvent_Input_BindingLoadFailed = 1701,
+	VREvent_Input_BindingLoadSuccessful = 1702,
+	VREvent_Input_ActionManifestReloaded = 1703,
+	VREvent_Input_ActionManifestLoadFailed = 1704,
+	VREvent_Input_ProgressUpdate = 1705,
+	VREvent_Input_TrackerActivated = 1706,
+	VREvent_Input_BindingsUpdated = 1707,
+	VREvent_Input_BindingSubscriptionChanged = 1708,
+	VREvent_SpatialAnchors_PoseUpdated = 1800,
+	VREvent_SpatialAnchors_DescriptorUpdated = 1801,
+	VREvent_SpatialAnchors_RequestPoseUpdate = 1802,
+	VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803,
+	VREvent_SystemReport_Started = 1900,
+	VREvent_Monitor_ShowHeadsetView = 2000,
+	VREvent_Monitor_HideHeadsetView = 2001,
+	VREvent_VendorSpecific_Reserved_Start = 10000,
+	VREvent_VendorSpecific_Reserved_End = 19999,
+}
+public enum EDeviceActivityLevel
+{
+	k_EDeviceActivityLevel_Unknown = -1,
+	k_EDeviceActivityLevel_Idle = 0,
+	k_EDeviceActivityLevel_UserInteraction = 1,
+	k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
+	k_EDeviceActivityLevel_Standby = 3,
+	k_EDeviceActivityLevel_Idle_Timeout = 4,
+}
+public 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,
+	k_EButton_SteamVR_Touchpad = 32,
+	k_EButton_SteamVR_Trigger = 33,
+	k_EButton_Dashboard_Back = 2,
+	k_EButton_IndexController_A = 2,
+	k_EButton_IndexController_B = 1,
+	k_EButton_IndexController_JoyStick = 35,
+	k_EButton_Max = 64,
+}
+public enum EVRMouseButton
+{
+	Left = 1,
+	Right = 2,
+	Middle = 4,
+}
+public enum EShowUIType
+{
+	ShowUI_ControllerBinding = 0,
+	ShowUI_ManageTrackers = 1,
+	ShowUI_Pairing = 3,
+	ShowUI_Settings = 4,
+	ShowUI_DebugCommands = 5,
+	ShowUI_FullControllerBinding = 6,
+	ShowUI_ManageDrivers = 7,
+}
+public enum EHDCPError
+{
+	None = 0,
+	LinkLost = 1,
+	Tampered = 2,
+	DeviceRevoked = 3,
+	Unknown = 4,
+}
+public enum EVRComponentProperty
+{
+	IsStatic = 1,
+	IsVisible = 2,
+	IsTouched = 4,
+	IsPressed = 8,
+	IsScrolled = 16,
+	IsHighlighted = 32,
+}
+public enum EVRInputError
+{
+	None = 0,
+	NameNotFound = 1,
+	WrongType = 2,
+	InvalidHandle = 3,
+	InvalidParam = 4,
+	NoSteam = 5,
+	MaxCapacityReached = 6,
+	IPCError = 7,
+	NoActiveActionSet = 8,
+	InvalidDevice = 9,
+	InvalidSkeleton = 10,
+	InvalidBoneCount = 11,
+	InvalidCompressedData = 12,
+	NoData = 13,
+	BufferTooSmall = 14,
+	MismatchedActionManifest = 15,
+	MissingSkeletonData = 16,
+	InvalidBoneIndex = 17,
+	InvalidPriority = 18,
+	PermissionDenied = 19,
+	InvalidRenderModel = 20,
+}
+public enum EVRSpatialAnchorError
+{
+	Success = 0,
+	Internal = 1,
+	UnknownHandle = 2,
+	ArrayTooSmall = 3,
+	InvalidDescriptorChar = 4,
+	NotYetAvailable = 5,
+	NotAvailableInThisUniverse = 6,
+	PermanentlyUnavailable = 7,
+	WrongDriver = 8,
+	DescriptorTooLong = 9,
+	Unknown = 10,
+	NoRoomCalibration = 11,
+	InvalidArgument = 12,
+	UnknownDriver = 13,
+}
+public enum EHiddenAreaMeshType
+{
+	k_eHiddenAreaMesh_Standard = 0,
+	k_eHiddenAreaMesh_Inverse = 1,
+	k_eHiddenAreaMesh_LineLoop = 2,
+	k_eHiddenAreaMesh_Max = 3,
+}
+public enum EVRControllerAxisType
+{
+	k_eControllerAxis_None = 0,
+	k_eControllerAxis_TrackPad = 1,
+	k_eControllerAxis_Joystick = 2,
+	k_eControllerAxis_Trigger = 3,
+}
+public enum EVRControllerEventOutputType
+{
+	ControllerEventOutput_OSEvents = 0,
+	ControllerEventOutput_VREvents = 1,
+}
+public enum ECollisionBoundsStyle
+{
+	COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1,
+	COLLISION_BOUNDS_STYLE_SQUARES = 2,
+	COLLISION_BOUNDS_STYLE_ADVANCED = 3,
+	COLLISION_BOUNDS_STYLE_NONE = 4,
+	COLLISION_BOUNDS_STYLE_COUNT = 5,
+}
+public enum EVROverlayError
+{
+	None = 0,
+	UnknownOverlay = 10,
+	InvalidHandle = 11,
+	PermissionDenied = 12,
+	OverlayLimitExceeded = 13,
+	WrongVisibilityType = 14,
+	KeyTooLong = 15,
+	NameTooLong = 16,
+	KeyInUse = 17,
+	WrongTransformType = 18,
+	InvalidTrackedDevice = 19,
+	InvalidParameter = 20,
+	ThumbnailCantBeDestroyed = 21,
+	ArrayTooSmall = 22,
+	RequestFailed = 23,
+	InvalidTexture = 24,
+	UnableToLoadFile = 25,
+	KeyboardAlreadyInUse = 26,
+	NoNeighbor = 27,
+	TooManyMaskPrimitives = 29,
+	BadMaskPrimitive = 30,
+	TextureAlreadyLocked = 31,
+	TextureLockCapacityReached = 32,
+	TextureNotLocked = 33,
+}
+public enum EVRApplicationType
+{
+	VRApplication_Other = 0,
+	VRApplication_Scene = 1,
+	VRApplication_Overlay = 2,
+	VRApplication_Background = 3,
+	VRApplication_Utility = 4,
+	VRApplication_VRMonitor = 5,
+	VRApplication_SteamWatchdog = 6,
+	VRApplication_Bootstrapper = 7,
+	VRApplication_WebHelper = 8,
+	VRApplication_OpenXRInstance = 9,
+	VRApplication_OpenXRScene = 10,
+	VRApplication_OpenXROverlay = 11,
+	VRApplication_Prism = 12,
+	VRApplication_Max = 13,
+}
+public enum EVRFirmwareError
+{
+	None = 0,
+	Success = 1,
+	Fail = 2,
+}
+public enum EVRNotificationError
+{
+	OK = 0,
+	InvalidNotificationId = 100,
+	NotificationQueueFull = 101,
+	InvalidOverlayHandle = 102,
+	SystemWithUserValueAlreadyExists = 103,
+}
+public enum EVRSkeletalMotionRange
+{
+	WithController = 0,
+	WithoutController = 1,
+}
+public enum EVRSkeletalTrackingLevel
+{
+	VRSkeletalTracking_Estimated = 0,
+	VRSkeletalTracking_Partial = 1,
+	VRSkeletalTracking_Full = 2,
+	Count = 3,
+	Max = 2,
+}
+public enum EVRInitError
+{
+	None = 0,
+	Unknown = 1,
+	Init_InstallationNotFound = 100,
+	Init_InstallationCorrupt = 101,
+	Init_VRClientDLLNotFound = 102,
+	Init_FileNotFound = 103,
+	Init_FactoryNotFound = 104,
+	Init_InterfaceNotFound = 105,
+	Init_InvalidInterface = 106,
+	Init_UserConfigDirectoryInvalid = 107,
+	Init_HmdNotFound = 108,
+	Init_NotInitialized = 109,
+	Init_PathRegistryNotFound = 110,
+	Init_NoConfigPath = 111,
+	Init_NoLogPath = 112,
+	Init_PathRegistryNotWritable = 113,
+	Init_AppInfoInitFailed = 114,
+	Init_Retry = 115,
+	Init_InitCanceledByUser = 116,
+	Init_AnotherAppLaunching = 117,
+	Init_SettingsInitFailed = 118,
+	Init_ShuttingDown = 119,
+	Init_TooManyObjects = 120,
+	Init_NoServerForBackgroundApp = 121,
+	Init_NotSupportedWithCompositor = 122,
+	Init_NotAvailableToUtilityApps = 123,
+	Init_Internal = 124,
+	Init_HmdDriverIdIsNone = 125,
+	Init_HmdNotFoundPresenceFailed = 126,
+	Init_VRMonitorNotFound = 127,
+	Init_VRMonitorStartupFailed = 128,
+	Init_LowPowerWatchdogNotSupported = 129,
+	Init_InvalidApplicationType = 130,
+	Init_NotAvailableToWatchdogApps = 131,
+	Init_WatchdogDisabledInSettings = 132,
+	Init_VRDashboardNotFound = 133,
+	Init_VRDashboardStartupFailed = 134,
+	Init_VRHomeNotFound = 135,
+	Init_VRHomeStartupFailed = 136,
+	Init_RebootingBusy = 137,
+	Init_FirmwareUpdateBusy = 138,
+	Init_FirmwareRecoveryBusy = 139,
+	Init_USBServiceBusy = 140,
+	Init_VRWebHelperStartupFailed = 141,
+	Init_TrackerManagerInitFailed = 142,
+	Init_AlreadyRunning = 143,
+	Init_FailedForVrMonitor = 144,
+	Init_PropertyManagerInitFailed = 145,
+	Init_WebServerFailed = 146,
+	Init_IllegalTypeTransition = 147,
+	Init_MismatchedRuntimes = 148,
+	Init_InvalidProcessId = 149,
+	Init_VRServiceStartupFailed = 150,
+	Init_PrismNeedsNewDrivers = 151,
+	Init_PrismStartupTimedOut = 152,
+	Init_CouldNotStartPrism = 153,
+	Init_CreateDriverDirectDeviceFailed = 154,
+	Init_PrismExitedUnexpectedly = 155,
+	Driver_Failed = 200,
+	Driver_Unknown = 201,
+	Driver_HmdUnknown = 202,
+	Driver_NotLoaded = 203,
+	Driver_RuntimeOutOfDate = 204,
+	Driver_HmdInUse = 205,
+	Driver_NotCalibrated = 206,
+	Driver_CalibrationInvalid = 207,
+	Driver_HmdDisplayNotFound = 208,
+	Driver_TrackedDeviceInterfaceUnknown = 209,
+	Driver_HmdDriverIdOutOfBounds = 211,
+	Driver_HmdDisplayMirrored = 212,
+	Driver_HmdDisplayNotFoundLaptop = 213,
+	IPC_ServerInitFailed = 300,
+	IPC_ConnectFailed = 301,
+	IPC_SharedStateInitFailed = 302,
+	IPC_CompositorInitFailed = 303,
+	IPC_MutexInitFailed = 304,
+	IPC_Failed = 305,
+	IPC_CompositorConnectFailed = 306,
+	IPC_CompositorInvalidConnectResponse = 307,
+	IPC_ConnectFailedAfterMultipleAttempts = 308,
+	IPC_ConnectFailedAfterTargetExited = 309,
+	IPC_NamespaceUnavailable = 310,
+	Compositor_Failed = 400,
+	Compositor_D3D11HardwareRequired = 401,
+	Compositor_FirmwareRequiresUpdate = 402,
+	Compositor_OverlayInitFailed = 403,
+	Compositor_ScreenshotsInitFailed = 404,
+	Compositor_UnableToCreateDevice = 405,
+	Compositor_SharedStateIsNull = 406,
+	Compositor_NotificationManagerIsNull = 407,
+	Compositor_ResourceManagerClientIsNull = 408,
+	Compositor_MessageOverlaySharedStateInitFailure = 409,
+	Compositor_PropertiesInterfaceIsNull = 410,
+	Compositor_CreateFullscreenWindowFailed = 411,
+	Compositor_SettingsInterfaceIsNull = 412,
+	Compositor_FailedToShowWindow = 413,
+	Compositor_DistortInterfaceIsNull = 414,
+	Compositor_DisplayFrequencyFailure = 415,
+	Compositor_RendererInitializationFailed = 416,
+	Compositor_DXGIFactoryInterfaceIsNull = 417,
+	Compositor_DXGIFactoryCreateFailed = 418,
+	Compositor_DXGIFactoryQueryFailed = 419,
+	Compositor_InvalidAdapterDesktop = 420,
+	Compositor_InvalidHmdAttachment = 421,
+	Compositor_InvalidOutputDesktop = 422,
+	Compositor_InvalidDeviceProvided = 423,
+	Compositor_D3D11RendererInitializationFailed = 424,
+	Compositor_FailedToFindDisplayMode = 425,
+	Compositor_FailedToCreateSwapChain = 426,
+	Compositor_FailedToGetBackBuffer = 427,
+	Compositor_FailedToCreateRenderTarget = 428,
+	Compositor_FailedToCreateDXGI2SwapChain = 429,
+	Compositor_FailedtoGetDXGI2BackBuffer = 430,
+	Compositor_FailedToCreateDXGI2RenderTarget = 431,
+	Compositor_FailedToGetDXGIDeviceInterface = 432,
+	Compositor_SelectDisplayMode = 433,
+	Compositor_FailedToCreateNvAPIRenderTargets = 434,
+	Compositor_NvAPISetDisplayMode = 435,
+	Compositor_FailedToCreateDirectModeDisplay = 436,
+	Compositor_InvalidHmdPropertyContainer = 437,
+	Compositor_UpdateDisplayFrequency = 438,
+	Compositor_CreateRasterizerState = 439,
+	Compositor_CreateWireframeRasterizerState = 440,
+	Compositor_CreateSamplerState = 441,
+	Compositor_CreateClampToBorderSamplerState = 442,
+	Compositor_CreateAnisoSamplerState = 443,
+	Compositor_CreateOverlaySamplerState = 444,
+	Compositor_CreatePanoramaSamplerState = 445,
+	Compositor_CreateFontSamplerState = 446,
+	Compositor_CreateNoBlendState = 447,
+	Compositor_CreateBlendState = 448,
+	Compositor_CreateAlphaBlendState = 449,
+	Compositor_CreateBlendStateMaskR = 450,
+	Compositor_CreateBlendStateMaskG = 451,
+	Compositor_CreateBlendStateMaskB = 452,
+	Compositor_CreateDepthStencilState = 453,
+	Compositor_CreateDepthStencilStateNoWrite = 454,
+	Compositor_CreateDepthStencilStateNoDepth = 455,
+	Compositor_CreateFlushTexture = 456,
+	Compositor_CreateDistortionSurfaces = 457,
+	Compositor_CreateConstantBuffer = 458,
+	Compositor_CreateHmdPoseConstantBuffer = 459,
+	Compositor_CreateHmdPoseStagingConstantBuffer = 460,
+	Compositor_CreateSharedFrameInfoConstantBuffer = 461,
+	Compositor_CreateOverlayConstantBuffer = 462,
+	Compositor_CreateSceneTextureIndexConstantBuffer = 463,
+	Compositor_CreateReadableSceneTextureIndexConstantBuffer = 464,
+	Compositor_CreateLayerGraphicsTextureIndexConstantBuffer = 465,
+	Compositor_CreateLayerComputeTextureIndexConstantBuffer = 466,
+	Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer = 467,
+	Compositor_CreateComputeHmdPoseConstantBuffer = 468,
+	Compositor_CreateGeomConstantBuffer = 469,
+	Compositor_CreatePanelMaskConstantBuffer = 470,
+	Compositor_CreatePixelSimUBO = 471,
+	Compositor_CreateMSAARenderTextures = 472,
+	Compositor_CreateResolveRenderTextures = 473,
+	Compositor_CreateComputeResolveRenderTextures = 474,
+	Compositor_CreateDriverDirectModeResolveTextures = 475,
+	Compositor_OpenDriverDirectModeResolveTextures = 476,
+	Compositor_CreateFallbackSyncTexture = 477,
+	Compositor_ShareFallbackSyncTexture = 478,
+	Compositor_CreateOverlayIndexBuffer = 479,
+	Compositor_CreateOverlayVertexBuffer = 480,
+	Compositor_CreateTextVertexBuffer = 481,
+	Compositor_CreateTextIndexBuffer = 482,
+	Compositor_CreateMirrorTextures = 483,
+	Compositor_CreateLastFrameRenderTexture = 484,
+	Compositor_CreateMirrorOverlay = 485,
+	Compositor_FailedToCreateVirtualDisplayBackbuffer = 486,
+	Compositor_DisplayModeNotSupported = 487,
+	Compositor_CreateOverlayInvalidCall = 488,
+	Compositor_CreateOverlayAlreadyInitialized = 489,
+	Compositor_FailedToCreateMailbox = 490,
+	Compositor_WindowInterfaceIsNull = 491,
+	Compositor_SystemLayerCreateInstance = 492,
+	Compositor_SystemLayerCreateSession = 493,
+	VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+	VendorSpecific_WindowsNotInDevMode = 1001,
+	VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	VendorSpecific_HmdFound_UserDataError = 1112,
+	VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+	VendorSpecific_OculusRuntimeBadInstall = 1114,
+	Steam_SteamInstallationNotFound = 2000,
+	LastError = 2001,
+}
+public enum EVRScreenshotType
+{
+	None = 0,
+	Mono = 1,
+	Stereo = 2,
+	Cubemap = 3,
+	MonoPanorama = 4,
+	StereoPanorama = 5,
+}
+public enum EVRScreenshotPropertyFilenames
+{
+	Preview = 0,
+	VR = 1,
+}
+public enum EVRTrackedCameraError
+{
+	None = 0,
+	OperationFailed = 100,
+	InvalidHandle = 101,
+	InvalidFrameHeaderVersion = 102,
+	OutOfHandles = 103,
+	IPCFailure = 104,
+	NotSupportedForThisDevice = 105,
+	SharedMemoryFailure = 106,
+	FrameBufferingFailure = 107,
+	StreamSetupFailure = 108,
+	InvalidGLTextureId = 109,
+	InvalidSharedTextureHandle = 110,
+	FailedToGetGLTextureId = 111,
+	SharedTextureFailure = 112,
+	NoFrameAvailable = 113,
+	InvalidArgument = 114,
+	InvalidFrameBufferSize = 115,
+}
+public enum EVRTrackedCameraFrameLayout
+{
+	Mono = 1,
+	Stereo = 2,
+	VerticalLayout = 16,
+	HorizontalLayout = 32,
+}
+public enum EVRTrackedCameraFrameType
+{
+	Distorted = 0,
+	Undistorted = 1,
+	MaximumUndistorted = 2,
+	MAX_CAMERA_FRAME_TYPES = 3,
+}
+public enum EVRDistortionFunctionType
+{
+	None = 0,
+	FTheta = 1,
+	Extended_FTheta = 2,
+	MAX_DISTORTION_FUNCTION_TYPES = 3,
+}
+public enum EVSync
+{
+	None = 0,
+	WaitRender = 1,
+	NoWaitRender = 2,
+}
+public enum EVRMuraCorrectionMode
+{
+	Default = 0,
+	NoCorrection = 1,
+}
+public enum Imu_OffScaleFlags
+{
+	OffScale_AccelX = 1,
+	OffScale_AccelY = 2,
+	OffScale_AccelZ = 4,
+	OffScale_GyroX = 8,
+	OffScale_GyroY = 16,
+	OffScale_GyroZ = 32,
+}
+public enum EVRApplicationError
+{
+	None = 0,
+	AppKeyAlreadyExists = 100,
+	NoManifest = 101,
+	NoApplication = 102,
+	InvalidIndex = 103,
+	UnknownApplication = 104,
+	IPCFailed = 105,
+	ApplicationAlreadyRunning = 106,
+	InvalidManifest = 107,
+	InvalidApplication = 108,
+	LaunchFailed = 109,
+	ApplicationAlreadyStarting = 110,
+	LaunchInProgress = 111,
+	OldApplicationQuitting = 112,
+	TransitionAborted = 113,
+	IsTemplate = 114,
+	SteamVRIsExiting = 115,
+	BufferTooSmall = 200,
+	PropertyNotSet = 201,
+	UnknownProperty = 202,
+	InvalidParameter = 203,
+	NotImplemented = 300,
+}
+public enum EVRApplicationProperty
+{
+	Name_String = 0,
+	LaunchType_String = 11,
+	WorkingDirectory_String = 12,
+	BinaryPath_String = 13,
+	Arguments_String = 14,
+	URL_String = 15,
+	Description_String = 50,
+	NewsURL_String = 51,
+	ImagePath_String = 52,
+	Source_String = 53,
+	ActionManifestURL_String = 54,
+	IsDashboardOverlay_Bool = 60,
+	IsTemplate_Bool = 61,
+	IsInstanced_Bool = 62,
+	IsInternal_Bool = 63,
+	WantsCompositorPauseInStandby_Bool = 64,
+	IsHidden_Bool = 65,
+	LastLaunchTime_Uint64 = 70,
+}
+public enum EVRSceneApplicationState
+{
+	None = 0,
+	Starting = 1,
+	Quitting = 2,
+	Running = 3,
+	Waiting = 4,
+}
+public enum ChaperoneCalibrationState
+{
+	OK = 1,
+	Warning = 100,
+	Warning_BaseStationMayHaveMoved = 101,
+	Warning_BaseStationRemoved = 102,
+	Warning_SeatedBoundsInvalid = 103,
+	Error = 200,
+	Error_BaseStationUninitialized = 201,
+	Error_BaseStationConflict = 202,
+	Error_PlayAreaInvalid = 203,
+	Error_CollisionBoundsInvalid = 204,
+}
+public enum EChaperoneConfigFile
+{
+	Live = 1,
+	Temp = 2,
+}
+public enum EChaperoneImportFlags
+{
+	EChaperoneImport_BoundsOnly = 1,
+}
+public enum EVRCompositorError
+{
+	None = 0,
+	RequestFailed = 1,
+	IncompatibleVersion = 100,
+	DoNotHaveFocus = 101,
+	InvalidTexture = 102,
+	IsNotSceneApplication = 103,
+	TextureIsOnWrongDevice = 104,
+	TextureUsesUnsupportedFormat = 105,
+	SharedTexturesNotSupported = 106,
+	IndexOutOfRange = 107,
+	AlreadySubmitted = 108,
+	InvalidBounds = 109,
+	AlreadySet = 110,
+}
+public enum EVRCompositorTimingMode
+{
+	Implicit = 0,
+	Explicit_RuntimePerformsPostPresentHandoff = 1,
+	Explicit_ApplicationPerformsPostPresentHandoff = 2,
+}
+public enum VROverlayInputMethod
+{
+	None = 0,
+	Mouse = 1,
+}
+public enum VROverlayTransformType
+{
+	VROverlayTransform_Invalid = -1,
+	VROverlayTransform_Absolute = 0,
+	VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransform_TrackedComponent = 3,
+	VROverlayTransform_Cursor = 4,
+	VROverlayTransform_DashboardTab = 5,
+	VROverlayTransform_DashboardThumb = 6,
+	VROverlayTransform_Mountable = 7,
+	VROverlayTransform_Projection = 8,
+}
+public enum VROverlayFlags
+{
+	NoDashboardTab = 8,
+	SendVRDiscreteScrollEvents = 64,
+	SendVRTouchpadEvents = 128,
+	ShowTouchPadScrollWheel = 256,
+	TransferOwnershipToInternalProcess = 512,
+	SideBySide_Parallel = 1024,
+	SideBySide_Crossed = 2048,
+	Panorama = 4096,
+	StereoPanorama = 8192,
+	SortWithNonSceneOverlays = 16384,
+	VisibleInDashboard = 32768,
+	MakeOverlaysInteractiveIfVisible = 65536,
+	SendVRSmoothScrollEvents = 131072,
+	ProtectedContent = 262144,
+	HideLaserIntersection = 524288,
+	WantsModalBehavior = 1048576,
+	IsPremultiplied = 2097152,
+}
+public enum VRMessageOverlayResponse
+{
+	ButtonPress_0 = 0,
+	ButtonPress_1 = 1,
+	ButtonPress_2 = 2,
+	ButtonPress_3 = 3,
+	CouldntFindSystemOverlay = 4,
+	CouldntFindOrCreateClientOverlay = 5,
+	ApplicationQuit = 6,
+}
+public enum EGamepadTextInputMode
+{
+	k_EGamepadTextInputModeNormal = 0,
+	k_EGamepadTextInputModePassword = 1,
+	k_EGamepadTextInputModeSubmit = 2,
+}
+public enum EGamepadTextInputLineMode
+{
+	k_EGamepadTextInputLineModeSingleLine = 0,
+	k_EGamepadTextInputLineModeMultipleLines = 1,
+}
+public enum EVROverlayIntersectionMaskPrimitiveType
+{
+	OverlayIntersectionPrimitiveType_Rectangle = 0,
+	OverlayIntersectionPrimitiveType_Circle = 1,
+}
+public enum EKeyboardFlags
+{
+	KeyboardFlag_Minimal = 1,
+	KeyboardFlag_Modal = 2,
+}
+public enum EDeviceType
+{
+	Invalid = -1,
+	DirectX11 = 0,
+	Vulkan = 1,
+}
+public enum HeadsetViewMode_t
+{
+	HeadsetViewMode_Left = 0,
+	HeadsetViewMode_Right = 1,
+	HeadsetViewMode_Both = 2,
+}
+public enum EVRRenderModelError
+{
+	None = 0,
+	Loading = 100,
+	NotSupported = 200,
+	InvalidArg = 300,
+	InvalidModel = 301,
+	NoShapes = 302,
+	MultipleShapes = 303,
+	TooManyVertices = 304,
+	MultipleTextures = 305,
+	BufferTooSmall = 306,
+	NotEnoughNormals = 307,
+	NotEnoughTexCoords = 308,
+	InvalidTexture = 400,
+}
+public enum EVRRenderModelTextureFormat
+{
+	RGBA8_SRGB = 0,
+	BC2 = 1,
+	BC4 = 2,
+	BC7 = 3,
+	BC7_SRGB = 4,
+}
+public enum EVRNotificationType
+{
+	Transient = 0,
+	Persistent = 1,
+	Transient_SystemWithUserValue = 2,
+}
+public enum EVRNotificationStyle
+{
+	None = 0,
+	Application = 100,
+	Contact_Disabled = 200,
+	Contact_Enabled = 201,
+	Contact_Active = 202,
+}
+public enum EVRSettingsError
+{
+	None = 0,
+	IPCFailed = 1,
+	WriteFailed = 2,
+	ReadFailed = 3,
+	JsonParseFailed = 4,
+	UnsetSettingHasNoDefault = 5,
+}
+public enum EVRScreenshotError
+{
+	None = 0,
+	RequestFailed = 1,
+	IncompatibleVersion = 100,
+	NotFound = 101,
+	BufferTooSmall = 102,
+	ScreenshotAlreadyInProgress = 108,
+}
+public enum EVRSkeletalTransformSpace
+{
+	Model = 0,
+	Parent = 1,
+}
+public enum EVRSkeletalReferencePose
+{
+	BindPose = 0,
+	OpenHand = 1,
+	Fist = 2,
+	GripLimit = 3,
+}
+public enum EVRFinger
+{
+	Thumb = 0,
+	Index = 1,
+	Middle = 2,
+	Ring = 3,
+	Pinky = 4,
+	Count = 5,
+}
+public enum EVRFingerSplay
+{
+	Thumb_Index = 0,
+	Index_Middle = 1,
+	Middle_Ring = 2,
+	Ring_Pinky = 3,
+	Count = 4,
+}
+public enum EVRSummaryType
+{
+	FromAnimation = 0,
+	FromDevice = 1,
+}
+public enum EVRInputFilterCancelType
+{
+	VRInputFilterCancel_Timers = 0,
+	VRInputFilterCancel_Momentum = 1,
+}
+public enum EVRInputStringBits
+{
+	VRInputString_Hand = 1,
+	VRInputString_ControllerType = 2,
+	VRInputString_InputSource = 4,
+	VRInputString_All = -1,
+}
+public enum EIOBufferError
+{
+	IOBuffer_Success = 0,
+	IOBuffer_OperationFailed = 100,
+	IOBuffer_InvalidHandle = 101,
+	IOBuffer_InvalidArgument = 102,
+	IOBuffer_PathExists = 103,
+	IOBuffer_PathDoesNotExist = 104,
+	IOBuffer_Permission = 105,
+}
+public enum EIOBufferMode
+{
+	Read = 1,
+	Write = 2,
+	Create = 512,
+}
+public enum EVRDebugError
+{
+	Success = 0,
+	BadParameter = 1,
+}
+public enum EPropertyWriteType
+{
+	PropertyWrite_Set = 0,
+	PropertyWrite_Erase = 1,
+	PropertyWrite_SetError = 2,
+}
+public enum EBlockQueueError
+{
+	None = 0,
+	QueueAlreadyExists = 1,
+	QueueNotFound = 2,
+	BlockNotAvailable = 3,
+	InvalidHandle = 4,
+	InvalidParam = 5,
+	ParamMismatch = 6,
+	InternalError = 7,
+	AlreadyInitialized = 8,
+	OperationIsServerOnly = 9,
+	TooManyConnections = 10,
+}
+public enum EBlockQueueReadType
+{
+	BlockQueueRead_Latest = 0,
+	BlockQueueRead_New = 1,
+	BlockQueueRead_Next = 2,
+}
+
+[StructLayout(LayoutKind.Explicit)] public struct VREvent_Data_t
+{
+	[FieldOffset(0)] public VREvent_Reserved_t reserved;
+	[FieldOffset(0)] public VREvent_Controller_t controller;
+	[FieldOffset(0)] public VREvent_Mouse_t mouse;
+	[FieldOffset(0)] public VREvent_Scroll_t scroll;
+	[FieldOffset(0)] public VREvent_Process_t process;
+	[FieldOffset(0)] public VREvent_Notification_t notification;
+	[FieldOffset(0)] public VREvent_Overlay_t overlay;
+	[FieldOffset(0)] public VREvent_Status_t status;
+	[FieldOffset(0)] public VREvent_Ipd_t ipd;
+	[FieldOffset(0)] public VREvent_Chaperone_t chaperone;
+	[FieldOffset(0)] public VREvent_PerformanceTest_t performanceTest;
+	[FieldOffset(0)] public VREvent_TouchPadMove_t touchPadMove;
+	[FieldOffset(0)] public VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+	[FieldOffset(0)] public VREvent_Screenshot_t screenshot;
+	[FieldOffset(0)] public VREvent_ScreenshotProgress_t screenshotProgress;
+	[FieldOffset(0)] public VREvent_ApplicationLaunch_t applicationLaunch;
+	[FieldOffset(0)] public VREvent_EditingCameraSurface_t cameraSurface;
+	[FieldOffset(0)] public VREvent_MessageOverlay_t messageOverlay;
+	[FieldOffset(0)] public VREvent_Property_t property;
+	[FieldOffset(0)] public VREvent_HapticVibration_t hapticVibration;
+	[FieldOffset(0)] public VREvent_WebConsole_t webConsole;
+	[FieldOffset(0)] public VREvent_InputBindingLoad_t inputBinding;
+	[FieldOffset(0)] public VREvent_SpatialAnchor_t spatialAnchor;
+	[FieldOffset(0)] public VREvent_InputActionManifestLoad_t actionManifest;
+	[FieldOffset(0)] public VREvent_ProgressUpdate_t progressUpdate;
+	[FieldOffset(0)] public VREvent_ShowUI_t showUi;
+	[FieldOffset(0)] public VREvent_ShowDevTools_t showDevTools;
+	[FieldOffset(0)] public VREvent_HDCPError_t hdcpError;
+	[FieldOffset(0)] public VREvent_Keyboard_t keyboard; // This has to be at the end due to a mono bug
+}
+
+
+[StructLayout(LayoutKind.Explicit)] public struct VROverlayIntersectionMaskPrimitive_Data_t
+{
+	[FieldOffset(0)] public IntersectionMaskRectangle_t m_Rectangle;
+	[FieldOffset(0)] public IntersectionMaskCircle_t m_Circle;
+}
+
+[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix34_t
+{
+	public float m0; //float[3][4]
+	public float m1;
+	public float m2;
+	public float m3;
+	public float m4;
+	public float m5;
+	public float m6;
+	public float m7;
+	public float m8;
+	public float m9;
+	public float m10;
+	public float m11;
+#if UNITY_5_3_OR_NEWER
+
+	public Vector3 GetPosition()
+	{
+		return new Vector3(m3, m7, -m11);
+	}
+
+	public bool IsRotationValid()
+	{
+		return ((m2 != 0 || m6 != 0 || m10 != 0) && (m1 != 0 || m5 != 0 || m9 != 0));
+	}
+
+	public Quaternion GetRotation()
+	{
+		if (IsRotationValid())
+		{
+			float w = Mathf.Sqrt(Mathf.Max(0, 1 + m0 + m5 + m10)) / 2;
+			float x = Mathf.Sqrt(Mathf.Max(0, 1 + m0 - m5 - m10)) / 2;
+			float y = Mathf.Sqrt(Mathf.Max(0, 1 - m0 + m5 - m10)) / 2;
+			float z = Mathf.Sqrt(Mathf.Max(0, 1 - m0 - m5 + m10)) / 2;
+
+			_copysign(ref x, -m9 - -m6);
+			_copysign(ref y, -m2 - -m8);
+			_copysign(ref z, m4 - m1);
+
+			return new Quaternion(x, y, z, w);
+		}
+		return Quaternion.identity;
+	}
+
+	private static void _copysign(ref float sizeval, float signval)
+	{
+		if (signval > 0 != sizeval > 0)
+			sizeval = -sizeval;
+	}
+#endif
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix33_t
+{
+	public float m0; //float[3][3]
+	public float m1;
+	public float m2;
+	public float m3;
+	public float m4;
+	public float m5;
+	public float m6;
+	public float m7;
+	public float m8;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix44_t
+{
+	public float m0; //float[4][4]
+	public float m1;
+	public float m2;
+	public float m3;
+	public float m4;
+	public float m5;
+	public float m6;
+	public float m7;
+	public float m8;
+	public float m9;
+	public float m10;
+	public float m11;
+	public float m12;
+	public float m13;
+	public float m14;
+	public float m15;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdVector3_t
+{
+	public float v0; //float[3]
+	public float v1;
+	public float v2;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdVector4_t
+{
+	public float v0; //float[4]
+	public float v1;
+	public float v2;
+	public float v3;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdVector3d_t
+{
+	public double v0; //double[3]
+	public double v1;
+	public double v2;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdVector2_t
+{
+	public float v0; //float[2]
+	public float v1;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdQuaternion_t
+{
+	public double w;
+	public double x;
+	public double y;
+	public double z;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdQuaternionf_t
+{
+	public float w;
+	public float x;
+	public float y;
+	public float z;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdColor_t
+{
+	public float r;
+	public float g;
+	public float b;
+	public float a;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdQuad_t
+{
+	public HmdVector3_t vCorners0; //HmdVector3_t[4]
+	public HmdVector3_t vCorners1;
+	public HmdVector3_t vCorners2;
+	public HmdVector3_t vCorners3;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HmdRect2_t
+{
+	public HmdVector2_t vTopLeft;
+	public HmdVector2_t vBottomRight;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRBoneTransform_t
+{
+	public HmdVector4_t position;
+	public HmdQuaternionf_t orientation;
+}
+[StructLayout(LayoutKind.Sequential)] public struct DistortionCoordinates_t
+{
+	public float rfRed0; //float[2]
+	public float rfRed1;
+	public float rfGreen0; //float[2]
+	public float rfGreen1;
+	public float rfBlue0; //float[2]
+	public float rfBlue1;
+}
+[StructLayout(LayoutKind.Sequential)] public struct Texture_t
+{
+	public IntPtr handle; // void *
+	public ETextureType eType;
+	public EColorSpace eColorSpace;
+}
+[StructLayout(LayoutKind.Sequential)] public struct TrackedDevicePose_t
+{
+	public HmdMatrix34_t mDeviceToAbsoluteTracking;
+	public HmdVector3_t vVelocity;
+	public HmdVector3_t vAngularVelocity;
+	public ETrackingResult eTrackingResult;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bPoseIsValid;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bDeviceIsConnected;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRTextureBounds_t
+{
+	public float uMin;
+	public float vMin;
+	public float uMax;
+	public float vMax;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithPose_t
+{
+	public IntPtr handle; // void *
+	public ETextureType eType;
+	public EColorSpace eColorSpace;
+	public HmdMatrix34_t mDeviceToAbsoluteTracking;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRTextureDepthInfo_t
+{
+	public IntPtr handle; // void *
+	public HmdMatrix44_t mProjection;
+	public HmdVector2_t vRange;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithDepth_t
+{
+	public IntPtr handle; // void *
+	public ETextureType eType;
+	public EColorSpace eColorSpace;
+	public VRTextureDepthInfo_t depth;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithPoseAndDepth_t
+{
+	public IntPtr handle; // void *
+	public ETextureType eType;
+	public EColorSpace eColorSpace;
+	public HmdMatrix34_t mDeviceToAbsoluteTracking;
+	public VRTextureDepthInfo_t depth;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRVulkanTextureData_t
+{
+	public ulong m_nImage;
+	public IntPtr m_pDevice; // struct VkDevice_T *
+	public IntPtr m_pPhysicalDevice; // struct VkPhysicalDevice_T *
+	public IntPtr m_pInstance; // struct VkInstance_T *
+	public IntPtr m_pQueue; // struct VkQueue_T *
+	public uint m_nQueueFamilyIndex;
+	public uint m_nWidth;
+	public uint m_nHeight;
+	public uint m_nFormat;
+	public uint m_nSampleCount;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRVulkanTextureArrayData_t
+{
+	public uint m_unArrayIndex;
+	public uint m_unArraySize;
+}
+[StructLayout(LayoutKind.Sequential)] public struct D3D12TextureData_t
+{
+	public IntPtr m_pResource; // struct ID3D12Resource *
+	public IntPtr m_pCommandQueue; // struct ID3D12CommandQueue *
+	public uint m_nNodeMask;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Controller_t
+{
+	public uint button;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Mouse_t
+{
+	public float x;
+	public float y;
+	public uint button;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Scroll_t
+{
+	public float xdelta;
+	public float ydelta;
+	public uint unused;
+	public float viewportscale;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_TouchPadMove_t
+{
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bFingerDown;
+	public float flSecondsFingerDown;
+	public float fValueXFirst;
+	public float fValueYFirst;
+	public float fValueXRaw;
+	public float fValueYRaw;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Notification_t
+{
+	public ulong ulUserValue;
+	public uint notificationId;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Process_t
+{
+	public uint pid;
+	public uint oldPid;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bForced;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bConnectionLost;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Overlay_t
+{
+	public ulong overlayHandle;
+	public ulong devicePath;
+	public ulong memoryBlockId;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Status_t
+{
+	public uint statusState;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Keyboard_t
+{
+	public byte cNewInput0,cNewInput1,cNewInput2,cNewInput3,cNewInput4,cNewInput5,cNewInput6,cNewInput7;
+	public string cNewInput
+	{
+		get
+		{
+			return new string(new char[] {
+				(char)cNewInput0,
+				(char)cNewInput1,
+				(char)cNewInput2,
+				(char)cNewInput3,
+				(char)cNewInput4,
+				(char)cNewInput5,
+				(char)cNewInput6,
+				(char)cNewInput7
+			}).TrimEnd('\0');
+		}
+	}
+	public ulong uUserValue;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Ipd_t
+{
+	public float ipdMeters;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Chaperone_t
+{
+	public ulong m_nPreviousUniverse;
+	public ulong m_nCurrentUniverse;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Reserved_t
+{
+	public ulong reserved0;
+	public ulong reserved1;
+	public ulong reserved2;
+	public ulong reserved3;
+	public ulong reserved4;
+	public ulong reserved5;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_PerformanceTest_t
+{
+	public uint m_nFidelityLevel;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_SeatedZeroPoseReset_t
+{
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bResetBySystemMenu;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Screenshot_t
+{
+	public uint handle;
+	public uint type;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_ScreenshotProgress_t
+{
+	public float progress;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_ApplicationLaunch_t
+{
+	public uint pid;
+	public uint unArgsHandle;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_EditingCameraSurface_t
+{
+	public ulong overlayHandle;
+	public uint nVisualMode;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_MessageOverlay_t
+{
+	public uint unVRMessageOverlayResponse;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_Property_t
+{
+	public ulong container;
+	public ETrackedDeviceProperty prop;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_HapticVibration_t
+{
+	public ulong containerHandle;
+	public ulong componentHandle;
+	public float fDurationSeconds;
+	public float fFrequency;
+	public float fAmplitude;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_WebConsole_t
+{
+	public ulong webConsoleHandle;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_InputBindingLoad_t
+{
+	public ulong ulAppContainer;
+	public ulong pathMessage;
+	public ulong pathUrl;
+	public ulong pathControllerType;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_InputActionManifestLoad_t
+{
+	public ulong pathAppKey;
+	public ulong pathMessage;
+	public ulong pathMessageParam;
+	public ulong pathManifestPath;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_SpatialAnchor_t
+{
+	public uint unHandle;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_ProgressUpdate_t
+{
+	public ulong ulApplicationPropertyContainer;
+	public ulong pathDevice;
+	public ulong pathInputSource;
+	public ulong pathProgressAction;
+	public ulong pathIcon;
+	public float fProgress;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_ShowUI_t
+{
+	public EShowUIType eType;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_ShowDevTools_t
+{
+	public int nBrowserIdentifier;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_HDCPError_t
+{
+	public EHDCPError eCode;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VREvent_t
+{
+	public uint eventType;
+	public uint trackedDeviceIndex;
+	public float eventAgeSeconds;
+	public VREvent_Data_t data;
+}
+// This structure is for backwards binary compatibility on Linux and OSX only
+[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct VREvent_t_Packed
+{
+	public uint eventType;
+	public uint trackedDeviceIndex;
+	public float eventAgeSeconds;
+	public VREvent_Data_t data;
+	public VREvent_t_Packed(VREvent_t unpacked)
+	{
+		this.eventType = unpacked.eventType;
+		this.trackedDeviceIndex = unpacked.trackedDeviceIndex;
+		this.eventAgeSeconds = unpacked.eventAgeSeconds;
+		this.data = unpacked.data;
+	}
+	public void Unpack(ref VREvent_t unpacked)
+	{
+		unpacked.eventType = this.eventType;
+		unpacked.trackedDeviceIndex = this.trackedDeviceIndex;
+		unpacked.eventAgeSeconds = this.eventAgeSeconds;
+		unpacked.data = this.data;
+	}
+}
+[StructLayout(LayoutKind.Sequential)] public struct RenderModel_ComponentState_t
+{
+	public HmdMatrix34_t mTrackingToComponentRenderModel;
+	public HmdMatrix34_t mTrackingToComponentLocal;
+	public uint uProperties;
+}
+[StructLayout(LayoutKind.Sequential)] public struct HiddenAreaMesh_t
+{
+	public IntPtr pVertexData; // const struct vr::HmdVector2_t *
+	public uint unTriangleCount;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRControllerAxis_t
+{
+	public float x;
+	public float y;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRControllerState_t
+{
+	public uint unPacketNum;
+	public ulong ulButtonPressed;
+	public ulong ulButtonTouched;
+	public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5]
+	public VRControllerAxis_t rAxis1;
+	public VRControllerAxis_t rAxis2;
+	public VRControllerAxis_t rAxis3;
+	public VRControllerAxis_t rAxis4;
+}
+// This structure is for backwards binary compatibility on Linux and OSX only
+[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct VRControllerState_t_Packed
+{
+	public uint unPacketNum;
+	public ulong ulButtonPressed;
+	public ulong ulButtonTouched;
+	public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5]
+	public VRControllerAxis_t rAxis1;
+	public VRControllerAxis_t rAxis2;
+	public VRControllerAxis_t rAxis3;
+	public VRControllerAxis_t rAxis4;
+	public VRControllerState_t_Packed(VRControllerState_t unpacked)
+	{
+		this.unPacketNum = unpacked.unPacketNum;
+		this.ulButtonPressed = unpacked.ulButtonPressed;
+		this.ulButtonTouched = unpacked.ulButtonTouched;
+		this.rAxis0 = unpacked.rAxis0;
+		this.rAxis1 = unpacked.rAxis1;
+		this.rAxis2 = unpacked.rAxis2;
+		this.rAxis3 = unpacked.rAxis3;
+		this.rAxis4 = unpacked.rAxis4;
+	}
+	public void Unpack(ref VRControllerState_t unpacked)
+	{
+		unpacked.unPacketNum = this.unPacketNum;
+		unpacked.ulButtonPressed = this.ulButtonPressed;
+		unpacked.ulButtonTouched = this.ulButtonTouched;
+		unpacked.rAxis0 = this.rAxis0;
+		unpacked.rAxis1 = this.rAxis1;
+		unpacked.rAxis2 = this.rAxis2;
+		unpacked.rAxis3 = this.rAxis3;
+		unpacked.rAxis4 = this.rAxis4;
+	}
+}
+[StructLayout(LayoutKind.Sequential)] public struct CameraVideoStreamFrameHeader_t
+{
+	public EVRTrackedCameraFrameType eFrameType;
+	public uint nWidth;
+	public uint nHeight;
+	public uint nBytesPerPixel;
+	public uint nFrameSequence;
+	public TrackedDevicePose_t trackedDevicePose;
+	public ulong ulFrameExposureTime;
+}
+[StructLayout(LayoutKind.Sequential)] public struct Compositor_FrameTiming
+{
+	public uint m_nSize;
+	public uint m_nFrameIndex;
+	public uint m_nNumFramePresents;
+	public uint m_nNumMisPresented;
+	public uint m_nNumDroppedFrames;
+	public uint m_nReprojectionFlags;
+	public double m_flSystemTimeInSeconds;
+	public float m_flPreSubmitGpuMs;
+	public float m_flPostSubmitGpuMs;
+	public float m_flTotalRenderGpuMs;
+	public float m_flCompositorRenderGpuMs;
+	public float m_flCompositorRenderCpuMs;
+	public float m_flCompositorIdleCpuMs;
+	public float m_flClientFrameIntervalMs;
+	public float m_flPresentCallCpuMs;
+	public float m_flWaitForPresentCpuMs;
+	public float m_flSubmitFrameMs;
+	public float m_flWaitGetPosesCalledMs;
+	public float m_flNewPosesReadyMs;
+	public float m_flNewFrameReadyMs;
+	public float m_flCompositorUpdateStartMs;
+	public float m_flCompositorUpdateEndMs;
+	public float m_flCompositorRenderStartMs;
+	public TrackedDevicePose_t m_HmdPose;
+	public uint m_nNumVSyncsReadyForUse;
+	public uint m_nNumVSyncsToFirstView;
+}
+[StructLayout(LayoutKind.Sequential)] public struct Compositor_BenchmarkResults
+{
+	public float m_flMegaPixelsPerSecond;
+	public float m_flHmdRecommendedMegaPixelsPerSecond;
+}
+[StructLayout(LayoutKind.Sequential)] public struct DriverDirectMode_FrameTiming
+{
+	public uint m_nSize;
+	public uint m_nNumFramePresents;
+	public uint m_nNumMisPresented;
+	public uint m_nNumDroppedFrames;
+	public uint m_nReprojectionFlags;
+}
+[StructLayout(LayoutKind.Sequential)] public struct ImuSample_t
+{
+	public double fSampleTime;
+	public HmdVector3d_t vAccel;
+	public HmdVector3d_t vGyro;
+	public uint unOffScaleFlags;
+}
+[StructLayout(LayoutKind.Sequential)] public struct AppOverrideKeys_t
+{
+	public IntPtr pchKey; // const char *
+	public IntPtr pchValue; // const char *
+}
+[StructLayout(LayoutKind.Sequential)] public struct Compositor_CumulativeStats
+{
+	public uint m_nPid;
+	public uint m_nNumFramePresents;
+	public uint m_nNumDroppedFrames;
+	public uint m_nNumReprojectedFrames;
+	public uint m_nNumFramePresentsOnStartup;
+	public uint m_nNumDroppedFramesOnStartup;
+	public uint m_nNumReprojectedFramesOnStartup;
+	public uint m_nNumLoading;
+	public uint m_nNumFramePresentsLoading;
+	public uint m_nNumDroppedFramesLoading;
+	public uint m_nNumReprojectedFramesLoading;
+	public uint m_nNumTimedOut;
+	public uint m_nNumFramePresentsTimedOut;
+	public uint m_nNumDroppedFramesTimedOut;
+	public uint m_nNumReprojectedFramesTimedOut;
+}
+[StructLayout(LayoutKind.Sequential)] public struct Compositor_StageRenderSettings
+{
+	public HmdColor_t m_PrimaryColor;
+	public HmdColor_t m_SecondaryColor;
+	public float m_flVignetteInnerRadius;
+	public float m_flVignetteOuterRadius;
+	public float m_flFresnelStrength;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool m_bBackfaceCulling;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool m_bGreyscale;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool m_bWireframe;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionParams_t
+{
+	public HmdVector3_t vSource;
+	public HmdVector3_t vDirection;
+	public ETrackingUniverseOrigin eOrigin;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionResults_t
+{
+	public HmdVector3_t vPoint;
+	public HmdVector3_t vNormal;
+	public HmdVector2_t vUVs;
+	public float fDistance;
+}
+[StructLayout(LayoutKind.Sequential)] public struct IntersectionMaskRectangle_t
+{
+	public float m_flTopLeftX;
+	public float m_flTopLeftY;
+	public float m_flWidth;
+	public float m_flHeight;
+}
+[StructLayout(LayoutKind.Sequential)] public struct IntersectionMaskCircle_t
+{
+	public float m_flCenterX;
+	public float m_flCenterY;
+	public float m_flRadius;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionMaskPrimitive_t
+{
+	public EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	public VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VROverlayProjection_t
+{
+	public float fLeft;
+	public float fRight;
+	public float fTop;
+	public float fBottom;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VROverlayView_t
+{
+	public ulong overlayHandle;
+	public Texture_t texture;
+	public VRTextureBounds_t textureBounds;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRVulkanDevice_t
+{
+	public IntPtr m_pInstance; // struct VkInstance_T *
+	public IntPtr m_pDevice; // struct VkDevice_T *
+	public IntPtr m_pPhysicalDevice; // struct VkPhysicalDevice_T *
+	public IntPtr m_pQueue; // struct VkQueue_T *
+	public uint m_uQueueFamilyIndex;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRNativeDevice_t
+{
+	public IntPtr handle; // void *
+	public EDeviceType eType;
+}
+[StructLayout(LayoutKind.Sequential)] public struct RenderModel_Vertex_t
+{
+	public HmdVector3_t vPosition;
+	public HmdVector3_t vNormal;
+	public float rfTextureCoord0; //float[2]
+	public float rfTextureCoord1;
+}
+[StructLayout(LayoutKind.Sequential)] public struct RenderModel_TextureMap_t
+{
+	public ushort unWidth;
+	public ushort unHeight;
+	public IntPtr rubTextureMapData; // const uint8_t *
+	public EVRRenderModelTextureFormat format;
+}
+// This structure is for backwards binary compatibility on Linux and OSX only
+[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct RenderModel_TextureMap_t_Packed
+{
+	public ushort unWidth;
+	public ushort unHeight;
+	public IntPtr rubTextureMapData; // const uint8_t *
+	public EVRRenderModelTextureFormat format;
+	public RenderModel_TextureMap_t_Packed(RenderModel_TextureMap_t unpacked)
+	{
+		this.unWidth = unpacked.unWidth;
+		this.unHeight = unpacked.unHeight;
+		this.rubTextureMapData = unpacked.rubTextureMapData;
+		this.format = unpacked.format;
+	}
+	public void Unpack(ref RenderModel_TextureMap_t unpacked)
+	{
+		unpacked.unWidth = this.unWidth;
+		unpacked.unHeight = this.unHeight;
+		unpacked.rubTextureMapData = this.rubTextureMapData;
+		unpacked.format = this.format;
+	}
+}
+[StructLayout(LayoutKind.Sequential)] public struct RenderModel_t
+{
+	public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t *
+	public uint unVertexCount;
+	public IntPtr rIndexData; // const uint16_t *
+	public uint unTriangleCount;
+	public int diffuseTextureId;
+}
+// This structure is for backwards binary compatibility on Linux and OSX only
+[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct RenderModel_t_Packed
+{
+	public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t *
+	public uint unVertexCount;
+	public IntPtr rIndexData; // const uint16_t *
+	public uint unTriangleCount;
+	public int diffuseTextureId;
+	public RenderModel_t_Packed(RenderModel_t unpacked)
+	{
+		this.rVertexData = unpacked.rVertexData;
+		this.unVertexCount = unpacked.unVertexCount;
+		this.rIndexData = unpacked.rIndexData;
+		this.unTriangleCount = unpacked.unTriangleCount;
+		this.diffuseTextureId = unpacked.diffuseTextureId;
+	}
+	public void Unpack(ref RenderModel_t unpacked)
+	{
+		unpacked.rVertexData = this.rVertexData;
+		unpacked.unVertexCount = this.unVertexCount;
+		unpacked.rIndexData = this.rIndexData;
+		unpacked.unTriangleCount = this.unTriangleCount;
+		unpacked.diffuseTextureId = this.diffuseTextureId;
+	}
+}
+[StructLayout(LayoutKind.Sequential)] public struct RenderModel_ControllerMode_State_t
+{
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bScrollWheelVisible;
+}
+[StructLayout(LayoutKind.Sequential)] public struct NotificationBitmap_t
+{
+	public IntPtr m_pImageData; // void *
+	public int m_nWidth;
+	public int m_nHeight;
+	public int m_nBytesPerPixel;
+}
+[StructLayout(LayoutKind.Sequential)] public struct CVRSettingHelper
+{
+	public IntPtr m_pSettings; // class vr::IVRSettings *
+}
+[StructLayout(LayoutKind.Sequential)] public struct InputAnalogActionData_t
+{
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bActive;
+	public ulong activeOrigin;
+	public float x;
+	public float y;
+	public float z;
+	public float deltaX;
+	public float deltaY;
+	public float deltaZ;
+	public float fUpdateTime;
+}
+[StructLayout(LayoutKind.Sequential)] public struct InputDigitalActionData_t
+{
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bActive;
+	public ulong activeOrigin;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bState;
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bChanged;
+	public float fUpdateTime;
+}
+[StructLayout(LayoutKind.Sequential)] public struct InputPoseActionData_t
+{
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bActive;
+	public ulong activeOrigin;
+	public TrackedDevicePose_t pose;
+}
+[StructLayout(LayoutKind.Sequential)] public struct InputSkeletalActionData_t
+{
+	[MarshalAs(UnmanagedType.I1)]
+	public bool bActive;
+	public ulong activeOrigin;
+}
+[StructLayout(LayoutKind.Sequential)] public struct InputOriginInfo_t
+{
+	public ulong devicePath;
+	public uint trackedDeviceIndex;
+	public byte rchRenderModelComponentName0,rchRenderModelComponentName1,rchRenderModelComponentName2,rchRenderModelComponentName3,rchRenderModelComponentName4,rchRenderModelComponentName5,rchRenderModelComponentName6,rchRenderModelComponentName7,rchRenderModelComponentName8,rchRenderModelComponentName9,rchRenderModelComponentName10,rchRenderModelComponentName11,rchRenderModelComponentName12,rchRenderModelComponentName13,rchRenderModelComponentName14,rchRenderModelComponentName15,rchRenderModelComponentName16,rchRenderModelComponentName17,rchRenderModelComponentName18,rchRenderModelComponentName19,rchRenderModelComponentName20,rchRenderModelComponentName21,rchRenderModelComponentName22,rchRenderModelComponentName23,rchRenderModelComponentName24,rchRenderModelComponentName25,rchRenderModelComponentName26,rchRenderModelComponentName27,rchRenderModelComponentName28,rchRenderModelComponentName29,rchRenderModelComponentName30,rchRenderModelComponentName31,rchRenderModelComponentName32,rchRenderModelComponentName33,rchRenderModelComponentName34,rchRenderModelComponentName35,rchRenderModelComponentName36,rchRenderModelComponentName37,rchRenderModelComponentName38,rchRenderModelComponentName39,rchRenderModelComponentName40,rchRenderModelComponentName41,rchRenderModelComponentName42,rchRenderModelComponentName43,rchRenderModelComponentName44,rchRenderModelComponentName45,rchRenderModelComponentName46,rchRenderModelComponentName47,rchRenderModelComponentName48,rchRenderModelComponentName49,rchRenderModelComponentName50,rchRenderModelComponentName51,rchRenderModelComponentName52,rchRenderModelComponentName53,rchRenderModelComponentName54,rchRenderModelComponentName55,rchRenderModelComponentName56,rchRenderModelComponentName57,rchRenderModelComponentName58,rchRenderModelComponentName59,rchRenderModelComponentName60,rchRenderModelComponentName61,rchRenderModelComponentName62,rchRenderModelComponentName63,rchRenderModelComponentName64,rchRenderModelComponentName65,rchRenderModelComponentName66,rchRenderModelComponentName67,rchRenderModelComponentName68,rchRenderModelComponentName69,rchRenderModelComponentName70,rchRenderModelComponentName71,rchRenderModelComponentName72,rchRenderModelComponentName73,rchRenderModelComponentName74,rchRenderModelComponentName75,rchRenderModelComponentName76,rchRenderModelComponentName77,rchRenderModelComponentName78,rchRenderModelComponentName79,rchRenderModelComponentName80,rchRenderModelComponentName81,rchRenderModelComponentName82,rchRenderModelComponentName83,rchRenderModelComponentName84,rchRenderModelComponentName85,rchRenderModelComponentName86,rchRenderModelComponentName87,rchRenderModelComponentName88,rchRenderModelComponentName89,rchRenderModelComponentName90,rchRenderModelComponentName91,rchRenderModelComponentName92,rchRenderModelComponentName93,rchRenderModelComponentName94,rchRenderModelComponentName95,rchRenderModelComponentName96,rchRenderModelComponentName97,rchRenderModelComponentName98,rchRenderModelComponentName99,rchRenderModelComponentName100,rchRenderModelComponentName101,rchRenderModelComponentName102,rchRenderModelComponentName103,rchRenderModelComponentName104,rchRenderModelComponentName105,rchRenderModelComponentName106,rchRenderModelComponentName107,rchRenderModelComponentName108,rchRenderModelComponentName109,rchRenderModelComponentName110,rchRenderModelComponentName111,rchRenderModelComponentName112,rchRenderModelComponentName113,rchRenderModelComponentName114,rchRenderModelComponentName115,rchRenderModelComponentName116,rchRenderModelComponentName117,rchRenderModelComponentName118,rchRenderModelComponentName119,rchRenderModelComponentName120,rchRenderModelComponentName121,rchRenderModelComponentName122,rchRenderModelComponentName123,rchRenderModelComponentName124,rchRenderModelComponentName125,rchRenderModelComponentName126,rchRenderModelComponentName127;
+	public string rchRenderModelComponentName
+	{
+		get
+		{
+			return new string(new char[] {
+				(char)rchRenderModelComponentName0,
+				(char)rchRenderModelComponentName1,
+				(char)rchRenderModelComponentName2,
+				(char)rchRenderModelComponentName3,
+				(char)rchRenderModelComponentName4,
+				(char)rchRenderModelComponentName5,
+				(char)rchRenderModelComponentName6,
+				(char)rchRenderModelComponentName7,
+				(char)rchRenderModelComponentName8,
+				(char)rchRenderModelComponentName9,
+				(char)rchRenderModelComponentName10,
+				(char)rchRenderModelComponentName11,
+				(char)rchRenderModelComponentName12,
+				(char)rchRenderModelComponentName13,
+				(char)rchRenderModelComponentName14,
+				(char)rchRenderModelComponentName15,
+				(char)rchRenderModelComponentName16,
+				(char)rchRenderModelComponentName17,
+				(char)rchRenderModelComponentName18,
+				(char)rchRenderModelComponentName19,
+				(char)rchRenderModelComponentName20,
+				(char)rchRenderModelComponentName21,
+				(char)rchRenderModelComponentName22,
+				(char)rchRenderModelComponentName23,
+				(char)rchRenderModelComponentName24,
+				(char)rchRenderModelComponentName25,
+				(char)rchRenderModelComponentName26,
+				(char)rchRenderModelComponentName27,
+				(char)rchRenderModelComponentName28,
+				(char)rchRenderModelComponentName29,
+				(char)rchRenderModelComponentName30,
+				(char)rchRenderModelComponentName31,
+				(char)rchRenderModelComponentName32,
+				(char)rchRenderModelComponentName33,
+				(char)rchRenderModelComponentName34,
+				(char)rchRenderModelComponentName35,
+				(char)rchRenderModelComponentName36,
+				(char)rchRenderModelComponentName37,
+				(char)rchRenderModelComponentName38,
+				(char)rchRenderModelComponentName39,
+				(char)rchRenderModelComponentName40,
+				(char)rchRenderModelComponentName41,
+				(char)rchRenderModelComponentName42,
+				(char)rchRenderModelComponentName43,
+				(char)rchRenderModelComponentName44,
+				(char)rchRenderModelComponentName45,
+				(char)rchRenderModelComponentName46,
+				(char)rchRenderModelComponentName47,
+				(char)rchRenderModelComponentName48,
+				(char)rchRenderModelComponentName49,
+				(char)rchRenderModelComponentName50,
+				(char)rchRenderModelComponentName51,
+				(char)rchRenderModelComponentName52,
+				(char)rchRenderModelComponentName53,
+				(char)rchRenderModelComponentName54,
+				(char)rchRenderModelComponentName55,
+				(char)rchRenderModelComponentName56,
+				(char)rchRenderModelComponentName57,
+				(char)rchRenderModelComponentName58,
+				(char)rchRenderModelComponentName59,
+				(char)rchRenderModelComponentName60,
+				(char)rchRenderModelComponentName61,
+				(char)rchRenderModelComponentName62,
+				(char)rchRenderModelComponentName63,
+				(char)rchRenderModelComponentName64,
+				(char)rchRenderModelComponentName65,
+				(char)rchRenderModelComponentName66,
+				(char)rchRenderModelComponentName67,
+				(char)rchRenderModelComponentName68,
+				(char)rchRenderModelComponentName69,
+				(char)rchRenderModelComponentName70,
+				(char)rchRenderModelComponentName71,
+				(char)rchRenderModelComponentName72,
+				(char)rchRenderModelComponentName73,
+				(char)rchRenderModelComponentName74,
+				(char)rchRenderModelComponentName75,
+				(char)rchRenderModelComponentName76,
+				(char)rchRenderModelComponentName77,
+				(char)rchRenderModelComponentName78,
+				(char)rchRenderModelComponentName79,
+				(char)rchRenderModelComponentName80,
+				(char)rchRenderModelComponentName81,
+				(char)rchRenderModelComponentName82,
+				(char)rchRenderModelComponentName83,
+				(char)rchRenderModelComponentName84,
+				(char)rchRenderModelComponentName85,
+				(char)rchRenderModelComponentName86,
+				(char)rchRenderModelComponentName87,
+				(char)rchRenderModelComponentName88,
+				(char)rchRenderModelComponentName89,
+				(char)rchRenderModelComponentName90,
+				(char)rchRenderModelComponentName91,
+				(char)rchRenderModelComponentName92,
+				(char)rchRenderModelComponentName93,
+				(char)rchRenderModelComponentName94,
+				(char)rchRenderModelComponentName95,
+				(char)rchRenderModelComponentName96,
+				(char)rchRenderModelComponentName97,
+				(char)rchRenderModelComponentName98,
+				(char)rchRenderModelComponentName99,
+				(char)rchRenderModelComponentName100,
+				(char)rchRenderModelComponentName101,
+				(char)rchRenderModelComponentName102,
+				(char)rchRenderModelComponentName103,
+				(char)rchRenderModelComponentName104,
+				(char)rchRenderModelComponentName105,
+				(char)rchRenderModelComponentName106,
+				(char)rchRenderModelComponentName107,
+				(char)rchRenderModelComponentName108,
+				(char)rchRenderModelComponentName109,
+				(char)rchRenderModelComponentName110,
+				(char)rchRenderModelComponentName111,
+				(char)rchRenderModelComponentName112,
+				(char)rchRenderModelComponentName113,
+				(char)rchRenderModelComponentName114,
+				(char)rchRenderModelComponentName115,
+				(char)rchRenderModelComponentName116,
+				(char)rchRenderModelComponentName117,
+				(char)rchRenderModelComponentName118,
+				(char)rchRenderModelComponentName119,
+				(char)rchRenderModelComponentName120,
+				(char)rchRenderModelComponentName121,
+				(char)rchRenderModelComponentName122,
+				(char)rchRenderModelComponentName123,
+				(char)rchRenderModelComponentName124,
+				(char)rchRenderModelComponentName125,
+				(char)rchRenderModelComponentName126,
+				(char)rchRenderModelComponentName127
+			}).TrimEnd('\0');
+		}
+	}
+}
+[StructLayout(LayoutKind.Sequential)] public struct InputBindingInfo_t
+{
+	public byte rchDevicePathName0,rchDevicePathName1,rchDevicePathName2,rchDevicePathName3,rchDevicePathName4,rchDevicePathName5,rchDevicePathName6,rchDevicePathName7,rchDevicePathName8,rchDevicePathName9,rchDevicePathName10,rchDevicePathName11,rchDevicePathName12,rchDevicePathName13,rchDevicePathName14,rchDevicePathName15,rchDevicePathName16,rchDevicePathName17,rchDevicePathName18,rchDevicePathName19,rchDevicePathName20,rchDevicePathName21,rchDevicePathName22,rchDevicePathName23,rchDevicePathName24,rchDevicePathName25,rchDevicePathName26,rchDevicePathName27,rchDevicePathName28,rchDevicePathName29,rchDevicePathName30,rchDevicePathName31,rchDevicePathName32,rchDevicePathName33,rchDevicePathName34,rchDevicePathName35,rchDevicePathName36,rchDevicePathName37,rchDevicePathName38,rchDevicePathName39,rchDevicePathName40,rchDevicePathName41,rchDevicePathName42,rchDevicePathName43,rchDevicePathName44,rchDevicePathName45,rchDevicePathName46,rchDevicePathName47,rchDevicePathName48,rchDevicePathName49,rchDevicePathName50,rchDevicePathName51,rchDevicePathName52,rchDevicePathName53,rchDevicePathName54,rchDevicePathName55,rchDevicePathName56,rchDevicePathName57,rchDevicePathName58,rchDevicePathName59,rchDevicePathName60,rchDevicePathName61,rchDevicePathName62,rchDevicePathName63,rchDevicePathName64,rchDevicePathName65,rchDevicePathName66,rchDevicePathName67,rchDevicePathName68,rchDevicePathName69,rchDevicePathName70,rchDevicePathName71,rchDevicePathName72,rchDevicePathName73,rchDevicePathName74,rchDevicePathName75,rchDevicePathName76,rchDevicePathName77,rchDevicePathName78,rchDevicePathName79,rchDevicePathName80,rchDevicePathName81,rchDevicePathName82,rchDevicePathName83,rchDevicePathName84,rchDevicePathName85,rchDevicePathName86,rchDevicePathName87,rchDevicePathName88,rchDevicePathName89,rchDevicePathName90,rchDevicePathName91,rchDevicePathName92,rchDevicePathName93,rchDevicePathName94,rchDevicePathName95,rchDevicePathName96,rchDevicePathName97,rchDevicePathName98,rchDevicePathName99,rchDevicePathName100,rchDevicePathName101,rchDevicePathName102,rchDevicePathName103,rchDevicePathName104,rchDevicePathName105,rchDevicePathName106,rchDevicePathName107,rchDevicePathName108,rchDevicePathName109,rchDevicePathName110,rchDevicePathName111,rchDevicePathName112,rchDevicePathName113,rchDevicePathName114,rchDevicePathName115,rchDevicePathName116,rchDevicePathName117,rchDevicePathName118,rchDevicePathName119,rchDevicePathName120,rchDevicePathName121,rchDevicePathName122,rchDevicePathName123,rchDevicePathName124,rchDevicePathName125,rchDevicePathName126,rchDevicePathName127;
+	public string rchDevicePathName
+	{
+		get
+		{
+			return new string(new char[] {
+				(char)rchDevicePathName0,
+				(char)rchDevicePathName1,
+				(char)rchDevicePathName2,
+				(char)rchDevicePathName3,
+				(char)rchDevicePathName4,
+				(char)rchDevicePathName5,
+				(char)rchDevicePathName6,
+				(char)rchDevicePathName7,
+				(char)rchDevicePathName8,
+				(char)rchDevicePathName9,
+				(char)rchDevicePathName10,
+				(char)rchDevicePathName11,
+				(char)rchDevicePathName12,
+				(char)rchDevicePathName13,
+				(char)rchDevicePathName14,
+				(char)rchDevicePathName15,
+				(char)rchDevicePathName16,
+				(char)rchDevicePathName17,
+				(char)rchDevicePathName18,
+				(char)rchDevicePathName19,
+				(char)rchDevicePathName20,
+				(char)rchDevicePathName21,
+				(char)rchDevicePathName22,
+				(char)rchDevicePathName23,
+				(char)rchDevicePathName24,
+				(char)rchDevicePathName25,
+				(char)rchDevicePathName26,
+				(char)rchDevicePathName27,
+				(char)rchDevicePathName28,
+				(char)rchDevicePathName29,
+				(char)rchDevicePathName30,
+				(char)rchDevicePathName31,
+				(char)rchDevicePathName32,
+				(char)rchDevicePathName33,
+				(char)rchDevicePathName34,
+				(char)rchDevicePathName35,
+				(char)rchDevicePathName36,
+				(char)rchDevicePathName37,
+				(char)rchDevicePathName38,
+				(char)rchDevicePathName39,
+				(char)rchDevicePathName40,
+				(char)rchDevicePathName41,
+				(char)rchDevicePathName42,
+				(char)rchDevicePathName43,
+				(char)rchDevicePathName44,
+				(char)rchDevicePathName45,
+				(char)rchDevicePathName46,
+				(char)rchDevicePathName47,
+				(char)rchDevicePathName48,
+				(char)rchDevicePathName49,
+				(char)rchDevicePathName50,
+				(char)rchDevicePathName51,
+				(char)rchDevicePathName52,
+				(char)rchDevicePathName53,
+				(char)rchDevicePathName54,
+				(char)rchDevicePathName55,
+				(char)rchDevicePathName56,
+				(char)rchDevicePathName57,
+				(char)rchDevicePathName58,
+				(char)rchDevicePathName59,
+				(char)rchDevicePathName60,
+				(char)rchDevicePathName61,
+				(char)rchDevicePathName62,
+				(char)rchDevicePathName63,
+				(char)rchDevicePathName64,
+				(char)rchDevicePathName65,
+				(char)rchDevicePathName66,
+				(char)rchDevicePathName67,
+				(char)rchDevicePathName68,
+				(char)rchDevicePathName69,
+				(char)rchDevicePathName70,
+				(char)rchDevicePathName71,
+				(char)rchDevicePathName72,
+				(char)rchDevicePathName73,
+				(char)rchDevicePathName74,
+				(char)rchDevicePathName75,
+				(char)rchDevicePathName76,
+				(char)rchDevicePathName77,
+				(char)rchDevicePathName78,
+				(char)rchDevicePathName79,
+				(char)rchDevicePathName80,
+				(char)rchDevicePathName81,
+				(char)rchDevicePathName82,
+				(char)rchDevicePathName83,
+				(char)rchDevicePathName84,
+				(char)rchDevicePathName85,
+				(char)rchDevicePathName86,
+				(char)rchDevicePathName87,
+				(char)rchDevicePathName88,
+				(char)rchDevicePathName89,
+				(char)rchDevicePathName90,
+				(char)rchDevicePathName91,
+				(char)rchDevicePathName92,
+				(char)rchDevicePathName93,
+				(char)rchDevicePathName94,
+				(char)rchDevicePathName95,
+				(char)rchDevicePathName96,
+				(char)rchDevicePathName97,
+				(char)rchDevicePathName98,
+				(char)rchDevicePathName99,
+				(char)rchDevicePathName100,
+				(char)rchDevicePathName101,
+				(char)rchDevicePathName102,
+				(char)rchDevicePathName103,
+				(char)rchDevicePathName104,
+				(char)rchDevicePathName105,
+				(char)rchDevicePathName106,
+				(char)rchDevicePathName107,
+				(char)rchDevicePathName108,
+				(char)rchDevicePathName109,
+				(char)rchDevicePathName110,
+				(char)rchDevicePathName111,
+				(char)rchDevicePathName112,
+				(char)rchDevicePathName113,
+				(char)rchDevicePathName114,
+				(char)rchDevicePathName115,
+				(char)rchDevicePathName116,
+				(char)rchDevicePathName117,
+				(char)rchDevicePathName118,
+				(char)rchDevicePathName119,
+				(char)rchDevicePathName120,
+				(char)rchDevicePathName121,
+				(char)rchDevicePathName122,
+				(char)rchDevicePathName123,
+				(char)rchDevicePathName124,
+				(char)rchDevicePathName125,
+				(char)rchDevicePathName126,
+				(char)rchDevicePathName127
+			}).TrimEnd('\0');
+		}
+	}
+	public byte rchInputPathName0,rchInputPathName1,rchInputPathName2,rchInputPathName3,rchInputPathName4,rchInputPathName5,rchInputPathName6,rchInputPathName7,rchInputPathName8,rchInputPathName9,rchInputPathName10,rchInputPathName11,rchInputPathName12,rchInputPathName13,rchInputPathName14,rchInputPathName15,rchInputPathName16,rchInputPathName17,rchInputPathName18,rchInputPathName19,rchInputPathName20,rchInputPathName21,rchInputPathName22,rchInputPathName23,rchInputPathName24,rchInputPathName25,rchInputPathName26,rchInputPathName27,rchInputPathName28,rchInputPathName29,rchInputPathName30,rchInputPathName31,rchInputPathName32,rchInputPathName33,rchInputPathName34,rchInputPathName35,rchInputPathName36,rchInputPathName37,rchInputPathName38,rchInputPathName39,rchInputPathName40,rchInputPathName41,rchInputPathName42,rchInputPathName43,rchInputPathName44,rchInputPathName45,rchInputPathName46,rchInputPathName47,rchInputPathName48,rchInputPathName49,rchInputPathName50,rchInputPathName51,rchInputPathName52,rchInputPathName53,rchInputPathName54,rchInputPathName55,rchInputPathName56,rchInputPathName57,rchInputPathName58,rchInputPathName59,rchInputPathName60,rchInputPathName61,rchInputPathName62,rchInputPathName63,rchInputPathName64,rchInputPathName65,rchInputPathName66,rchInputPathName67,rchInputPathName68,rchInputPathName69,rchInputPathName70,rchInputPathName71,rchInputPathName72,rchInputPathName73,rchInputPathName74,rchInputPathName75,rchInputPathName76,rchInputPathName77,rchInputPathName78,rchInputPathName79,rchInputPathName80,rchInputPathName81,rchInputPathName82,rchInputPathName83,rchInputPathName84,rchInputPathName85,rchInputPathName86,rchInputPathName87,rchInputPathName88,rchInputPathName89,rchInputPathName90,rchInputPathName91,rchInputPathName92,rchInputPathName93,rchInputPathName94,rchInputPathName95,rchInputPathName96,rchInputPathName97,rchInputPathName98,rchInputPathName99,rchInputPathName100,rchInputPathName101,rchInputPathName102,rchInputPathName103,rchInputPathName104,rchInputPathName105,rchInputPathName106,rchInputPathName107,rchInputPathName108,rchInputPathName109,rchInputPathName110,rchInputPathName111,rchInputPathName112,rchInputPathName113,rchInputPathName114,rchInputPathName115,rchInputPathName116,rchInputPathName117,rchInputPathName118,rchInputPathName119,rchInputPathName120,rchInputPathName121,rchInputPathName122,rchInputPathName123,rchInputPathName124,rchInputPathName125,rchInputPathName126,rchInputPathName127;
+	public string rchInputPathName
+	{
+		get
+		{
+			return new string(new char[] {
+				(char)rchInputPathName0,
+				(char)rchInputPathName1,
+				(char)rchInputPathName2,
+				(char)rchInputPathName3,
+				(char)rchInputPathName4,
+				(char)rchInputPathName5,
+				(char)rchInputPathName6,
+				(char)rchInputPathName7,
+				(char)rchInputPathName8,
+				(char)rchInputPathName9,
+				(char)rchInputPathName10,
+				(char)rchInputPathName11,
+				(char)rchInputPathName12,
+				(char)rchInputPathName13,
+				(char)rchInputPathName14,
+				(char)rchInputPathName15,
+				(char)rchInputPathName16,
+				(char)rchInputPathName17,
+				(char)rchInputPathName18,
+				(char)rchInputPathName19,
+				(char)rchInputPathName20,
+				(char)rchInputPathName21,
+				(char)rchInputPathName22,
+				(char)rchInputPathName23,
+				(char)rchInputPathName24,
+				(char)rchInputPathName25,
+				(char)rchInputPathName26,
+				(char)rchInputPathName27,
+				(char)rchInputPathName28,
+				(char)rchInputPathName29,
+				(char)rchInputPathName30,
+				(char)rchInputPathName31,
+				(char)rchInputPathName32,
+				(char)rchInputPathName33,
+				(char)rchInputPathName34,
+				(char)rchInputPathName35,
+				(char)rchInputPathName36,
+				(char)rchInputPathName37,
+				(char)rchInputPathName38,
+				(char)rchInputPathName39,
+				(char)rchInputPathName40,
+				(char)rchInputPathName41,
+				(char)rchInputPathName42,
+				(char)rchInputPathName43,
+				(char)rchInputPathName44,
+				(char)rchInputPathName45,
+				(char)rchInputPathName46,
+				(char)rchInputPathName47,
+				(char)rchInputPathName48,
+				(char)rchInputPathName49,
+				(char)rchInputPathName50,
+				(char)rchInputPathName51,
+				(char)rchInputPathName52,
+				(char)rchInputPathName53,
+				(char)rchInputPathName54,
+				(char)rchInputPathName55,
+				(char)rchInputPathName56,
+				(char)rchInputPathName57,
+				(char)rchInputPathName58,
+				(char)rchInputPathName59,
+				(char)rchInputPathName60,
+				(char)rchInputPathName61,
+				(char)rchInputPathName62,
+				(char)rchInputPathName63,
+				(char)rchInputPathName64,
+				(char)rchInputPathName65,
+				(char)rchInputPathName66,
+				(char)rchInputPathName67,
+				(char)rchInputPathName68,
+				(char)rchInputPathName69,
+				(char)rchInputPathName70,
+				(char)rchInputPathName71,
+				(char)rchInputPathName72,
+				(char)rchInputPathName73,
+				(char)rchInputPathName74,
+				(char)rchInputPathName75,
+				(char)rchInputPathName76,
+				(char)rchInputPathName77,
+				(char)rchInputPathName78,
+				(char)rchInputPathName79,
+				(char)rchInputPathName80,
+				(char)rchInputPathName81,
+				(char)rchInputPathName82,
+				(char)rchInputPathName83,
+				(char)rchInputPathName84,
+				(char)rchInputPathName85,
+				(char)rchInputPathName86,
+				(char)rchInputPathName87,
+				(char)rchInputPathName88,
+				(char)rchInputPathName89,
+				(char)rchInputPathName90,
+				(char)rchInputPathName91,
+				(char)rchInputPathName92,
+				(char)rchInputPathName93,
+				(char)rchInputPathName94,
+				(char)rchInputPathName95,
+				(char)rchInputPathName96,
+				(char)rchInputPathName97,
+				(char)rchInputPathName98,
+				(char)rchInputPathName99,
+				(char)rchInputPathName100,
+				(char)rchInputPathName101,
+				(char)rchInputPathName102,
+				(char)rchInputPathName103,
+				(char)rchInputPathName104,
+				(char)rchInputPathName105,
+				(char)rchInputPathName106,
+				(char)rchInputPathName107,
+				(char)rchInputPathName108,
+				(char)rchInputPathName109,
+				(char)rchInputPathName110,
+				(char)rchInputPathName111,
+				(char)rchInputPathName112,
+				(char)rchInputPathName113,
+				(char)rchInputPathName114,
+				(char)rchInputPathName115,
+				(char)rchInputPathName116,
+				(char)rchInputPathName117,
+				(char)rchInputPathName118,
+				(char)rchInputPathName119,
+				(char)rchInputPathName120,
+				(char)rchInputPathName121,
+				(char)rchInputPathName122,
+				(char)rchInputPathName123,
+				(char)rchInputPathName124,
+				(char)rchInputPathName125,
+				(char)rchInputPathName126,
+				(char)rchInputPathName127
+			}).TrimEnd('\0');
+		}
+	}
+	public byte rchModeName0,rchModeName1,rchModeName2,rchModeName3,rchModeName4,rchModeName5,rchModeName6,rchModeName7,rchModeName8,rchModeName9,rchModeName10,rchModeName11,rchModeName12,rchModeName13,rchModeName14,rchModeName15,rchModeName16,rchModeName17,rchModeName18,rchModeName19,rchModeName20,rchModeName21,rchModeName22,rchModeName23,rchModeName24,rchModeName25,rchModeName26,rchModeName27,rchModeName28,rchModeName29,rchModeName30,rchModeName31,rchModeName32,rchModeName33,rchModeName34,rchModeName35,rchModeName36,rchModeName37,rchModeName38,rchModeName39,rchModeName40,rchModeName41,rchModeName42,rchModeName43,rchModeName44,rchModeName45,rchModeName46,rchModeName47,rchModeName48,rchModeName49,rchModeName50,rchModeName51,rchModeName52,rchModeName53,rchModeName54,rchModeName55,rchModeName56,rchModeName57,rchModeName58,rchModeName59,rchModeName60,rchModeName61,rchModeName62,rchModeName63,rchModeName64,rchModeName65,rchModeName66,rchModeName67,rchModeName68,rchModeName69,rchModeName70,rchModeName71,rchModeName72,rchModeName73,rchModeName74,rchModeName75,rchModeName76,rchModeName77,rchModeName78,rchModeName79,rchModeName80,rchModeName81,rchModeName82,rchModeName83,rchModeName84,rchModeName85,rchModeName86,rchModeName87,rchModeName88,rchModeName89,rchModeName90,rchModeName91,rchModeName92,rchModeName93,rchModeName94,rchModeName95,rchModeName96,rchModeName97,rchModeName98,rchModeName99,rchModeName100,rchModeName101,rchModeName102,rchModeName103,rchModeName104,rchModeName105,rchModeName106,rchModeName107,rchModeName108,rchModeName109,rchModeName110,rchModeName111,rchModeName112,rchModeName113,rchModeName114,rchModeName115,rchModeName116,rchModeName117,rchModeName118,rchModeName119,rchModeName120,rchModeName121,rchModeName122,rchModeName123,rchModeName124,rchModeName125,rchModeName126,rchModeName127;
+	public string rchModeName
+	{
+		get
+		{
+			return new string(new char[] {
+				(char)rchModeName0,
+				(char)rchModeName1,
+				(char)rchModeName2,
+				(char)rchModeName3,
+				(char)rchModeName4,
+				(char)rchModeName5,
+				(char)rchModeName6,
+				(char)rchModeName7,
+				(char)rchModeName8,
+				(char)rchModeName9,
+				(char)rchModeName10,
+				(char)rchModeName11,
+				(char)rchModeName12,
+				(char)rchModeName13,
+				(char)rchModeName14,
+				(char)rchModeName15,
+				(char)rchModeName16,
+				(char)rchModeName17,
+				(char)rchModeName18,
+				(char)rchModeName19,
+				(char)rchModeName20,
+				(char)rchModeName21,
+				(char)rchModeName22,
+				(char)rchModeName23,
+				(char)rchModeName24,
+				(char)rchModeName25,
+				(char)rchModeName26,
+				(char)rchModeName27,
+				(char)rchModeName28,
+				(char)rchModeName29,
+				(char)rchModeName30,
+				(char)rchModeName31,
+				(char)rchModeName32,
+				(char)rchModeName33,
+				(char)rchModeName34,
+				(char)rchModeName35,
+				(char)rchModeName36,
+				(char)rchModeName37,
+				(char)rchModeName38,
+				(char)rchModeName39,
+				(char)rchModeName40,
+				(char)rchModeName41,
+				(char)rchModeName42,
+				(char)rchModeName43,
+				(char)rchModeName44,
+				(char)rchModeName45,
+				(char)rchModeName46,
+				(char)rchModeName47,
+				(char)rchModeName48,
+				(char)rchModeName49,
+				(char)rchModeName50,
+				(char)rchModeName51,
+				(char)rchModeName52,
+				(char)rchModeName53,
+				(char)rchModeName54,
+				(char)rchModeName55,
+				(char)rchModeName56,
+				(char)rchModeName57,
+				(char)rchModeName58,
+				(char)rchModeName59,
+				(char)rchModeName60,
+				(char)rchModeName61,
+				(char)rchModeName62,
+				(char)rchModeName63,
+				(char)rchModeName64,
+				(char)rchModeName65,
+				(char)rchModeName66,
+				(char)rchModeName67,
+				(char)rchModeName68,
+				(char)rchModeName69,
+				(char)rchModeName70,
+				(char)rchModeName71,
+				(char)rchModeName72,
+				(char)rchModeName73,
+				(char)rchModeName74,
+				(char)rchModeName75,
+				(char)rchModeName76,
+				(char)rchModeName77,
+				(char)rchModeName78,
+				(char)rchModeName79,
+				(char)rchModeName80,
+				(char)rchModeName81,
+				(char)rchModeName82,
+				(char)rchModeName83,
+				(char)rchModeName84,
+				(char)rchModeName85,
+				(char)rchModeName86,
+				(char)rchModeName87,
+				(char)rchModeName88,
+				(char)rchModeName89,
+				(char)rchModeName90,
+				(char)rchModeName91,
+				(char)rchModeName92,
+				(char)rchModeName93,
+				(char)rchModeName94,
+				(char)rchModeName95,
+				(char)rchModeName96,
+				(char)rchModeName97,
+				(char)rchModeName98,
+				(char)rchModeName99,
+				(char)rchModeName100,
+				(char)rchModeName101,
+				(char)rchModeName102,
+				(char)rchModeName103,
+				(char)rchModeName104,
+				(char)rchModeName105,
+				(char)rchModeName106,
+				(char)rchModeName107,
+				(char)rchModeName108,
+				(char)rchModeName109,
+				(char)rchModeName110,
+				(char)rchModeName111,
+				(char)rchModeName112,
+				(char)rchModeName113,
+				(char)rchModeName114,
+				(char)rchModeName115,
+				(char)rchModeName116,
+				(char)rchModeName117,
+				(char)rchModeName118,
+				(char)rchModeName119,
+				(char)rchModeName120,
+				(char)rchModeName121,
+				(char)rchModeName122,
+				(char)rchModeName123,
+				(char)rchModeName124,
+				(char)rchModeName125,
+				(char)rchModeName126,
+				(char)rchModeName127
+			}).TrimEnd('\0');
+		}
+	}
+	public byte rchSlotName0,rchSlotName1,rchSlotName2,rchSlotName3,rchSlotName4,rchSlotName5,rchSlotName6,rchSlotName7,rchSlotName8,rchSlotName9,rchSlotName10,rchSlotName11,rchSlotName12,rchSlotName13,rchSlotName14,rchSlotName15,rchSlotName16,rchSlotName17,rchSlotName18,rchSlotName19,rchSlotName20,rchSlotName21,rchSlotName22,rchSlotName23,rchSlotName24,rchSlotName25,rchSlotName26,rchSlotName27,rchSlotName28,rchSlotName29,rchSlotName30,rchSlotName31,rchSlotName32,rchSlotName33,rchSlotName34,rchSlotName35,rchSlotName36,rchSlotName37,rchSlotName38,rchSlotName39,rchSlotName40,rchSlotName41,rchSlotName42,rchSlotName43,rchSlotName44,rchSlotName45,rchSlotName46,rchSlotName47,rchSlotName48,rchSlotName49,rchSlotName50,rchSlotName51,rchSlotName52,rchSlotName53,rchSlotName54,rchSlotName55,rchSlotName56,rchSlotName57,rchSlotName58,rchSlotName59,rchSlotName60,rchSlotName61,rchSlotName62,rchSlotName63,rchSlotName64,rchSlotName65,rchSlotName66,rchSlotName67,rchSlotName68,rchSlotName69,rchSlotName70,rchSlotName71,rchSlotName72,rchSlotName73,rchSlotName74,rchSlotName75,rchSlotName76,rchSlotName77,rchSlotName78,rchSlotName79,rchSlotName80,rchSlotName81,rchSlotName82,rchSlotName83,rchSlotName84,rchSlotName85,rchSlotName86,rchSlotName87,rchSlotName88,rchSlotName89,rchSlotName90,rchSlotName91,rchSlotName92,rchSlotName93,rchSlotName94,rchSlotName95,rchSlotName96,rchSlotName97,rchSlotName98,rchSlotName99,rchSlotName100,rchSlotName101,rchSlotName102,rchSlotName103,rchSlotName104,rchSlotName105,rchSlotName106,rchSlotName107,rchSlotName108,rchSlotName109,rchSlotName110,rchSlotName111,rchSlotName112,rchSlotName113,rchSlotName114,rchSlotName115,rchSlotName116,rchSlotName117,rchSlotName118,rchSlotName119,rchSlotName120,rchSlotName121,rchSlotName122,rchSlotName123,rchSlotName124,rchSlotName125,rchSlotName126,rchSlotName127;
+	public string rchSlotName
+	{
+		get
+		{
+			return new string(new char[] {
+				(char)rchSlotName0,
+				(char)rchSlotName1,
+				(char)rchSlotName2,
+				(char)rchSlotName3,
+				(char)rchSlotName4,
+				(char)rchSlotName5,
+				(char)rchSlotName6,
+				(char)rchSlotName7,
+				(char)rchSlotName8,
+				(char)rchSlotName9,
+				(char)rchSlotName10,
+				(char)rchSlotName11,
+				(char)rchSlotName12,
+				(char)rchSlotName13,
+				(char)rchSlotName14,
+				(char)rchSlotName15,
+				(char)rchSlotName16,
+				(char)rchSlotName17,
+				(char)rchSlotName18,
+				(char)rchSlotName19,
+				(char)rchSlotName20,
+				(char)rchSlotName21,
+				(char)rchSlotName22,
+				(char)rchSlotName23,
+				(char)rchSlotName24,
+				(char)rchSlotName25,
+				(char)rchSlotName26,
+				(char)rchSlotName27,
+				(char)rchSlotName28,
+				(char)rchSlotName29,
+				(char)rchSlotName30,
+				(char)rchSlotName31,
+				(char)rchSlotName32,
+				(char)rchSlotName33,
+				(char)rchSlotName34,
+				(char)rchSlotName35,
+				(char)rchSlotName36,
+				(char)rchSlotName37,
+				(char)rchSlotName38,
+				(char)rchSlotName39,
+				(char)rchSlotName40,
+				(char)rchSlotName41,
+				(char)rchSlotName42,
+				(char)rchSlotName43,
+				(char)rchSlotName44,
+				(char)rchSlotName45,
+				(char)rchSlotName46,
+				(char)rchSlotName47,
+				(char)rchSlotName48,
+				(char)rchSlotName49,
+				(char)rchSlotName50,
+				(char)rchSlotName51,
+				(char)rchSlotName52,
+				(char)rchSlotName53,
+				(char)rchSlotName54,
+				(char)rchSlotName55,
+				(char)rchSlotName56,
+				(char)rchSlotName57,
+				(char)rchSlotName58,
+				(char)rchSlotName59,
+				(char)rchSlotName60,
+				(char)rchSlotName61,
+				(char)rchSlotName62,
+				(char)rchSlotName63,
+				(char)rchSlotName64,
+				(char)rchSlotName65,
+				(char)rchSlotName66,
+				(char)rchSlotName67,
+				(char)rchSlotName68,
+				(char)rchSlotName69,
+				(char)rchSlotName70,
+				(char)rchSlotName71,
+				(char)rchSlotName72,
+				(char)rchSlotName73,
+				(char)rchSlotName74,
+				(char)rchSlotName75,
+				(char)rchSlotName76,
+				(char)rchSlotName77,
+				(char)rchSlotName78,
+				(char)rchSlotName79,
+				(char)rchSlotName80,
+				(char)rchSlotName81,
+				(char)rchSlotName82,
+				(char)rchSlotName83,
+				(char)rchSlotName84,
+				(char)rchSlotName85,
+				(char)rchSlotName86,
+				(char)rchSlotName87,
+				(char)rchSlotName88,
+				(char)rchSlotName89,
+				(char)rchSlotName90,
+				(char)rchSlotName91,
+				(char)rchSlotName92,
+				(char)rchSlotName93,
+				(char)rchSlotName94,
+				(char)rchSlotName95,
+				(char)rchSlotName96,
+				(char)rchSlotName97,
+				(char)rchSlotName98,
+				(char)rchSlotName99,
+				(char)rchSlotName100,
+				(char)rchSlotName101,
+				(char)rchSlotName102,
+				(char)rchSlotName103,
+				(char)rchSlotName104,
+				(char)rchSlotName105,
+				(char)rchSlotName106,
+				(char)rchSlotName107,
+				(char)rchSlotName108,
+				(char)rchSlotName109,
+				(char)rchSlotName110,
+				(char)rchSlotName111,
+				(char)rchSlotName112,
+				(char)rchSlotName113,
+				(char)rchSlotName114,
+				(char)rchSlotName115,
+				(char)rchSlotName116,
+				(char)rchSlotName117,
+				(char)rchSlotName118,
+				(char)rchSlotName119,
+				(char)rchSlotName120,
+				(char)rchSlotName121,
+				(char)rchSlotName122,
+				(char)rchSlotName123,
+				(char)rchSlotName124,
+				(char)rchSlotName125,
+				(char)rchSlotName126,
+				(char)rchSlotName127
+			}).TrimEnd('\0');
+		}
+	}
+	public byte rchInputSourceType0,rchInputSourceType1,rchInputSourceType2,rchInputSourceType3,rchInputSourceType4,rchInputSourceType5,rchInputSourceType6,rchInputSourceType7,rchInputSourceType8,rchInputSourceType9,rchInputSourceType10,rchInputSourceType11,rchInputSourceType12,rchInputSourceType13,rchInputSourceType14,rchInputSourceType15,rchInputSourceType16,rchInputSourceType17,rchInputSourceType18,rchInputSourceType19,rchInputSourceType20,rchInputSourceType21,rchInputSourceType22,rchInputSourceType23,rchInputSourceType24,rchInputSourceType25,rchInputSourceType26,rchInputSourceType27,rchInputSourceType28,rchInputSourceType29,rchInputSourceType30,rchInputSourceType31;
+	public string rchInputSourceType
+	{
+		get
+		{
+			return new string(new char[] {
+				(char)rchInputSourceType0,
+				(char)rchInputSourceType1,
+				(char)rchInputSourceType2,
+				(char)rchInputSourceType3,
+				(char)rchInputSourceType4,
+				(char)rchInputSourceType5,
+				(char)rchInputSourceType6,
+				(char)rchInputSourceType7,
+				(char)rchInputSourceType8,
+				(char)rchInputSourceType9,
+				(char)rchInputSourceType10,
+				(char)rchInputSourceType11,
+				(char)rchInputSourceType12,
+				(char)rchInputSourceType13,
+				(char)rchInputSourceType14,
+				(char)rchInputSourceType15,
+				(char)rchInputSourceType16,
+				(char)rchInputSourceType17,
+				(char)rchInputSourceType18,
+				(char)rchInputSourceType19,
+				(char)rchInputSourceType20,
+				(char)rchInputSourceType21,
+				(char)rchInputSourceType22,
+				(char)rchInputSourceType23,
+				(char)rchInputSourceType24,
+				(char)rchInputSourceType25,
+				(char)rchInputSourceType26,
+				(char)rchInputSourceType27,
+				(char)rchInputSourceType28,
+				(char)rchInputSourceType29,
+				(char)rchInputSourceType30,
+				(char)rchInputSourceType31
+			}).TrimEnd('\0');
+		}
+	}
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRActiveActionSet_t
+{
+	public ulong ulActionSet;
+	public ulong ulRestrictedToDevice;
+	public ulong ulSecondaryActionSet;
+	public uint unPadding;
+	public int nPriority;
+}
+[StructLayout(LayoutKind.Sequential)] public struct VRSkeletalSummaryData_t
+{
+	public float flFingerCurl0; //float[5]
+	public float flFingerCurl1;
+	public float flFingerCurl2;
+	public float flFingerCurl3;
+	public float flFingerCurl4;
+	public float flFingerSplay0; //float[4]
+	public float flFingerSplay1;
+	public float flFingerSplay2;
+	public float flFingerSplay3;
+}
+[StructLayout(LayoutKind.Sequential)] public struct SpatialAnchorPose_t
+{
+	public HmdMatrix34_t mAnchorToAbsoluteTracking;
+}
+[StructLayout(LayoutKind.Sequential)] public struct COpenVRContext
+{
+	public IntPtr m_pVRSystem; // class vr::IVRSystem *
+	public IntPtr m_pVRChaperone; // class vr::IVRChaperone *
+	public IntPtr m_pVRChaperoneSetup; // class vr::IVRChaperoneSetup *
+	public IntPtr m_pVRCompositor; // class vr::IVRCompositor *
+	public IntPtr m_pVRHeadsetView; // class vr::IVRHeadsetView *
+	public IntPtr m_pVROverlay; // class vr::IVROverlay *
+	public IntPtr m_pVROverlayView; // class vr::IVROverlayView *
+	public IntPtr m_pVRResources; // class vr::IVRResources *
+	public IntPtr m_pVRRenderModels; // class vr::IVRRenderModels *
+	public IntPtr m_pVRExtendedDisplay; // class vr::IVRExtendedDisplay *
+	public IntPtr m_pVRSettings; // class vr::IVRSettings *
+	public IntPtr m_pVRApplications; // class vr::IVRApplications *
+	public IntPtr m_pVRTrackedCamera; // class vr::IVRTrackedCamera *
+	public IntPtr m_pVRScreenshots; // class vr::IVRScreenshots *
+	public IntPtr m_pVRDriverManager; // class vr::IVRDriverManager *
+	public IntPtr m_pVRInput; // class vr::IVRInput *
+	public IntPtr m_pVRIOBuffer; // class vr::IVRIOBuffer *
+	public IntPtr m_pVRSpatialAnchors; // class vr::IVRSpatialAnchors *
+	public IntPtr m_pVRDebug; // class vr::IVRDebug *
+	public IntPtr m_pVRNotifications; // class vr::IVRNotifications *
+}
+[StructLayout(LayoutKind.Sequential)] public struct PropertyWrite_t
+{
+	public ETrackedDeviceProperty prop;
+	public EPropertyWriteType writeType;
+	public ETrackedPropertyError eSetError;
+	public IntPtr pvBuffer; // void *
+	public uint unBufferSize;
+	public uint unTag;
+	public ETrackedPropertyError eError;
+}
+[StructLayout(LayoutKind.Sequential)] public struct PropertyRead_t
+{
+	public ETrackedDeviceProperty prop;
+	public IntPtr pvBuffer; // void *
+	public uint unBufferSize;
+	public uint unTag;
+	public uint unRequiredBufferSize;
+	public ETrackedPropertyError eError;
+}
+[StructLayout(LayoutKind.Sequential)] public struct CVRPropertyHelpers
+{
+	public IntPtr m_pProperties; // class vr::IVRProperties *
+}
+[StructLayout(LayoutKind.Sequential)] public struct PathWrite_t
+{
+	public ulong ulPath;
+	public EPropertyWriteType writeType;
+	public ETrackedPropertyError eSetError;
+	public IntPtr pvBuffer; // void *
+	public uint unBufferSize;
+	public uint unTag;
+	public ETrackedPropertyError eError;
+	public IntPtr pszPath; // const char *
+}
+[StructLayout(LayoutKind.Sequential)] public struct PathRead_t
+{
+	public ulong ulPath;
+	public IntPtr pvBuffer; // void *
+	public uint unBufferSize;
+	public uint unTag;
+	public uint unRequiredBufferSize;
+	public ETrackedPropertyError eError;
+	public IntPtr pszPath; // const char *
+}
+
+public class OpenVR
+{
+
+	public static uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType)
+	{
+		return OpenVRInterop.InitInternal(ref peError, eApplicationType);
+	}
+
+	public static uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType, string pchStartupInfo)
+	{
+		return OpenVRInterop.InitInternal2(ref peError, eApplicationType, pchStartupInfo);
+	}
+
+	public static void ShutdownInternal()
+	{
+		OpenVRInterop.ShutdownInternal();
+	}
+
+	public static bool IsHmdPresent()
+	{
+		return OpenVRInterop.IsHmdPresent();
+	}
+
+	public static bool IsRuntimeInstalled()
+	{
+		return OpenVRInterop.IsRuntimeInstalled();
+	}
+
+	public static string RuntimePath()
+	{
+		try
+		{
+			uint pathSize = 512;
+			uint requiredPathSize = 512;
+			System.Text.StringBuilder path = new System.Text.StringBuilder((int)pathSize);
+			bool success = OpenVRInterop.GetRuntimePath(path, pathSize, ref requiredPathSize);
+			if (success == false)
+			{
+				return null;
+			}
+
+			return path.ToString();
+		} catch
+		{
+			return OpenVRInterop.RuntimePath(); //this api is deprecated but here to support older unity versions
+		}
+	}
+
+	public static string GetStringForHmdError(EVRInitError error)
+	{
+		return Marshal.PtrToStringAnsi(OpenVRInterop.GetStringForHmdError(error));
+	}
+
+	public static IntPtr GetGenericInterface(string pchInterfaceVersion, ref EVRInitError peError)
+	{
+		return OpenVRInterop.GetGenericInterface(pchInterfaceVersion, ref peError);
+	}
+
+	public static bool IsInterfaceVersionValid(string pchInterfaceVersion)
+	{
+		return OpenVRInterop.IsInterfaceVersionValid(pchInterfaceVersion);
+	}
+
+	public static uint GetInitToken()
+	{
+		return OpenVRInterop.GetInitToken();
+	}
+
+	public const uint k_nDriverNone = 4294967295;
+	public const uint k_unMaxDriverDebugResponseSize = 32768;
+	public const uint k_unTrackedDeviceIndex_Hmd = 0;
+	public const uint k_unMaxTrackedDeviceCount = 64;
+	public const uint k_unTrackedDeviceIndexOther = 4294967294;
+	public const uint k_unTrackedDeviceIndexInvalid = 4294967295;
+	public const ulong k_ulInvalidPropertyContainer = 0;
+	public const uint k_unInvalidPropertyTag = 0;
+	public const ulong k_ulInvalidDriverHandle = 0;
+	public const uint k_unFloatPropertyTag = 1;
+	public const uint k_unInt32PropertyTag = 2;
+	public const uint k_unUint64PropertyTag = 3;
+	public const uint k_unBoolPropertyTag = 4;
+	public const uint k_unStringPropertyTag = 5;
+	public const uint k_unErrorPropertyTag = 6;
+	public const uint k_unDoublePropertyTag = 7;
+	public const uint k_unHmdMatrix34PropertyTag = 20;
+	public const uint k_unHmdMatrix44PropertyTag = 21;
+	public const uint k_unHmdVector3PropertyTag = 22;
+	public const uint k_unHmdVector4PropertyTag = 23;
+	public const uint k_unHmdVector2PropertyTag = 24;
+	public const uint k_unHmdQuadPropertyTag = 25;
+	public const uint k_unHiddenAreaPropertyTag = 30;
+	public const uint k_unPathHandleInfoTag = 31;
+	public const uint k_unActionPropertyTag = 32;
+	public const uint k_unInputValuePropertyTag = 33;
+	public const uint k_unWildcardPropertyTag = 34;
+	public const uint k_unHapticVibrationPropertyTag = 35;
+	public const uint k_unSkeletonPropertyTag = 36;
+	public const uint k_unSpatialAnchorPosePropertyTag = 40;
+	public const uint k_unJsonPropertyTag = 41;
+	public const uint k_unActiveActionSetPropertyTag = 42;
+	public const uint k_unOpenVRInternalReserved_Start = 1000;
+	public const uint k_unOpenVRInternalReserved_End = 10000;
+	public const uint k_unMaxPropertyStringSize = 32768;
+	public const ulong k_ulInvalidActionHandle = 0;
+	public const ulong k_ulInvalidActionSetHandle = 0;
+	public const ulong k_ulInvalidInputValueHandle = 0;
+	public const uint k_unControllerStateAxisCount = 5;
+	public const ulong k_ulOverlayHandleInvalid = 0;
+	public const uint k_unMaxDistortionFunctionParameters = 8;
+	public const uint k_unScreenshotHandleInvalid = 0;
+	public const string IVRSystem_Version = "IVRSystem_022";
+	public const string IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+	public const string IVRTrackedCamera_Version = "IVRTrackedCamera_006";
+	public const uint k_unMaxApplicationKeyLength = 128;
+	public const string k_pch_MimeType_HomeApp = "vr/home";
+	public const string k_pch_MimeType_GameTheater = "vr/game_theater";
+	public const string IVRApplications_Version = "IVRApplications_007";
+	public const string IVRChaperone_Version = "IVRChaperone_004";
+	public const string IVRChaperoneSetup_Version = "IVRChaperoneSetup_006";
+	public const string IVRCompositor_Version = "IVRCompositor_027";
+	public const uint k_unVROverlayMaxKeyLength = 128;
+	public const uint k_unVROverlayMaxNameLength = 128;
+	public const uint k_unMaxOverlayCount = 128;
+	public const uint k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+	public const string IVROverlay_Version = "IVROverlay_025";
+	public const string IVROverlayView_Version = "IVROverlayView_003";
+	public const uint k_unHeadsetViewMaxWidth = 3840;
+	public const uint k_unHeadsetViewMaxHeight = 2160;
+	public const string k_pchHeadsetViewOverlayKey = "system.HeadsetView";
+	public const string IVRHeadsetView_Version = "IVRHeadsetView_001";
+	public const string k_pch_Controller_Component_GDC2015 = "gdc2015";
+	public const string k_pch_Controller_Component_Base = "base";
+	public const string k_pch_Controller_Component_Tip = "tip";
+	public const string k_pch_Controller_Component_HandGrip = "handgrip";
+	public const string k_pch_Controller_Component_Status = "status";
+	public const string IVRRenderModels_Version = "IVRRenderModels_006";
+	public const uint k_unNotificationTextMaxSize = 256;
+	public const string IVRNotifications_Version = "IVRNotifications_002";
+	public const uint k_unMaxSettingsKeyLength = 128;
+	public const string IVRSettings_Version = "IVRSettings_003";
+	public const string k_pch_SteamVR_Section = "steamvr";
+	public const string k_pch_SteamVR_RequireHmd_String = "requireHmd";
+	public const string k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+	public const string k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+	public const string k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+	public const string k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+	public const string k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+	public const string k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+	public const string k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+	public const string k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+	public const string k_pch_SteamVR_IPD_Float = "ipd";
+	public const string k_pch_SteamVR_Background_String = "background";
+	public const string k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+	public const string k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+	public const string k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+	public const string k_pch_SteamVR_GridColor_String = "gridColor";
+	public const string k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+	public const string k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+	public const string k_pch_SteamVR_ShowStage_Bool = "showStage";
+	public const string k_pch_SteamVR_DrawTrackingReferences_Bool = "drawTrackingReferences";
+	public const string k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+	public const string k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+	public const string k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+	public const string k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+	public const string k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+	public const string k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+	public const string k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+	public const string k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+	public const string k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+	public const string k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+	public const string k_pch_SteamVR_FramesToThrottle_Int32 = "framesToThrottle";
+	public const string k_pch_SteamVR_AdditionalFramesToPredict_Int32 = "additionalFramesToPredict";
+	public const string k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+	public const string k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+	public const string k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+	public const string k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+	public const string k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+	public const string k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+	public const string k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+	public const string k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+	public const string k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+	public const string k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph";
+	public const string k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+	public const string k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+	public const string k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+	public const string k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+	public const string k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+	public const string k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+	public const string k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+	public const string k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+	public const string k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+	public const string k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride";
+	public const string k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+	public const string k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
+	public const string k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
+	public const string k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
+	public const string k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
+	public const string k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
+	public const string k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
+	public const string k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
+	public const string k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
+	public const string k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
+	public const string k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
+	public const string k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
+	public const string k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
+	public const string k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
+	public const string k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
+	public const string k_pch_SteamVR_CustomIconStyle_String = "customIconStyle";
+	public const string k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle";
+	public const string k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
+	public const string k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
+	public const string k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+	public const string k_pch_SteamVR_BlockOculusSDKOnOpenVRLaunchOption_Bool = "blockOculusSDKOnOpenVRLaunchOption";
+	public const string k_pch_SteamVR_BlockOculusSDKOnAllLaunches_Bool = "blockOculusSDKOnAllLaunches";
+	public const string k_pch_SteamVR_HDCPLegacyCompatibility_Bool = "hdcp14legacyCompatibility";
+	public const string k_pch_SteamVR_UsePrism_Bool = "usePrism";
+	public const string k_pch_DirectMode_Section = "direct_mode";
+	public const string k_pch_DirectMode_Enable_Bool = "enable";
+	public const string k_pch_DirectMode_Count_Int32 = "count";
+	public const string k_pch_DirectMode_EdidVid_Int32 = "edidVid";
+	public const string k_pch_DirectMode_EdidPid_Int32 = "edidPid";
+	public const string k_pch_Lighthouse_Section = "driver_lighthouse";
+	public const string k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+	public const string k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
+	public const string k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+	public const string k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+	public const string k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+	public const string k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+	public const string k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
+	public const string k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations";
+	public const string k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2";
+	public const string k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations";
+	public const string k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback";
+	public const string k_pch_Null_Section = "driver_null";
+	public const string k_pch_Null_SerialNumber_String = "serialNumber";
+	public const string k_pch_Null_ModelNumber_String = "modelNumber";
+	public const string k_pch_Null_WindowX_Int32 = "windowX";
+	public const string k_pch_Null_WindowY_Int32 = "windowY";
+	public const string k_pch_Null_WindowWidth_Int32 = "windowWidth";
+	public const string k_pch_Null_WindowHeight_Int32 = "windowHeight";
+	public const string k_pch_Null_RenderWidth_Int32 = "renderWidth";
+	public const string k_pch_Null_RenderHeight_Int32 = "renderHeight";
+	public const string k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+	public const string k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+	public const string k_pch_WindowsMR_Section = "driver_holographic";
+	public const string k_pch_UserInterface_Section = "userinterface";
+	public const string k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+	public const string k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+	public const string k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized";
+	public const string k_pch_UserInterface_Screenshots_Bool = "screenshots";
+	public const string k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+	public const string k_pch_Notifications_Section = "notifications";
+	public const string k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+	public const string k_pch_Keyboard_Section = "keyboard";
+	public const string k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+	public const string k_pch_Keyboard_ScaleX = "ScaleX";
+	public const string k_pch_Keyboard_ScaleY = "ScaleY";
+	public const string k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+	public const string k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+	public const string k_pch_Keyboard_OffsetY = "OffsetY";
+	public const string k_pch_Keyboard_Smoothing = "Smoothing";
+	public const string k_pch_Perf_Section = "perfcheck";
+	public const string k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD";
+	public const string k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+	public const string k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+	public const string k_pch_Perf_TestData_Float = "perfTestData";
+	public const string k_pch_Perf_GPUProfiling_Bool = "GPUProfiling";
+	public const string k_pch_CollisionBounds_Section = "collisionBounds";
+	public const string k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+	public const string k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+	public const string k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+	public const string k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+	public const string k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+	public const string k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight";
+	public const string k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+	public const string k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+	public const string k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+	public const string k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+	public const string k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+	public const string k_pch_Camera_Section = "camera";
+	public const string k_pch_Camera_EnableCamera_Bool = "enableCamera";
+	public const string k_pch_Camera_ShowOnController_Bool = "showOnController";
+	public const string k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+	public const string k_pch_Camera_RoomView_Int32 = "roomView";
+	public const string k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+	public const string k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+	public const string k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+	public const string k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+	public const string k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+	public const string k_pch_Camera_RoomViewStyle_Int32 = "roomViewStyle";
+	public const string k_pch_audio_Section = "audio";
+	public const string k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+	public const string k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+	public const string k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+	public const string k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+	public const string k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+	public const string k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+	public const string k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+	public const string k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+	public const string k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+	public const string k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+	public const string k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+	public const string k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+	public const string k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice";
+	public const string k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume";
+	public const string k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+	public const string k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+	public const string k_pch_audio_DualSpeakerAndJackOutput_Bool = "dualSpeakerAndJackOutput";
+	public const string k_pch_audio_MuteMicMonitor_Bool = "muteMicMonitor";
+	public const string k_pch_Power_Section = "power";
+	public const string k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+	public const string k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+	public const string k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+	public const string k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+	public const string k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+	public const string k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+	public const string k_pch_Dashboard_Section = "dashboard";
+	public const string k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+	public const string k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+	public const string k_pch_Dashboard_Position = "position";
+	public const string k_pch_Dashboard_DesktopScale = "desktopScale";
+	public const string k_pch_Dashboard_DashboardScale = "dashboardScale";
+	public const string k_pch_Dashboard_UseStandaloneSystemLayer = "standaloneSystemLayer";
+	public const string k_pch_modelskin_Section = "modelskins";
+	public const string k_pch_Driver_Enable_Bool = "enable";
+	public const string k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode";
+	public const string k_pch_Driver_LoadPriority_Int32 = "loadPriority";
+	public const string k_pch_WebInterface_Section = "WebInterface";
+	public const string k_pch_VRWebHelper_Section = "VRWebHelper";
+	public const string k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled";
+	public const string k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort";
+	public const string k_pch_TrackingOverride_Section = "TrackingOverrides";
+	public const string k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL";
+	public const string k_pch_App_BindingLegacyAPISuffix_String = "_legacy";
+	public const string k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput";
+	public const string k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
+	public const string k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
+	public const string k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+	public const string k_pch_App_DominantHand_Int32 = "DominantHand";
+	public const string k_pch_App_BlockOculusSDK_Bool = "blockOculusSDK";
+	public const string k_pch_Trackers_Section = "trackers";
+	public const string k_pch_DesktopUI_Section = "DesktopUI";
+	public const string k_pch_LastKnown_Section = "LastKnown";
+	public const string k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer";
+	public const string k_pch_LastKnown_HMDModel_String = "HMDModel";
+	public const string k_pch_DismissedWarnings_Section = "DismissedWarnings";
+	public const string k_pch_Input_Section = "input";
+	public const string k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
+	public const string k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
+	public const string k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
+	public const string k_pch_GpuSpeed_Section = "GpuSpeed";
+	public const string IVRScreenshots_Version = "IVRScreenshots_001";
+	public const string IVRResources_Version = "IVRResources_001";
+	public const string IVRDriverManager_Version = "IVRDriverManager_001";
+	public const uint k_unMaxActionNameLength = 64;
+	public const uint k_unMaxActionSetNameLength = 64;
+	public const uint k_unMaxActionOriginCount = 16;
+	public const uint k_unMaxBoneNameLength = 32;
+	public const int k_nActionSetOverlayGlobalPriorityMin = 16777216;
+	public const int k_nActionSetOverlayGlobalPriorityMax = 33554431;
+	public const int k_nActionSetPriorityReservedMin = 33554432;
+	public const string IVRInput_Version = "IVRInput_010";
+	public const ulong k_ulInvalidIOBufferHandle = 0;
+	public const string IVRIOBuffer_Version = "IVRIOBuffer_002";
+	public const uint k_ulInvalidSpatialAnchorHandle = 0;
+	public const string IVRSpatialAnchors_Version = "IVRSpatialAnchors_001";
+	public const string IVRDebug_Version = "IVRDebug_001";
+	public const ulong k_ulDisplayRedirectContainer = 25769803779;
+	public const string IVRProperties_Version = "IVRProperties_001";
+	public const string k_pchPathUserHandRight = "/user/hand/right";
+	public const string k_pchPathUserHandLeft = "/user/hand/left";
+	public const string k_pchPathUserHandPrimary = "/user/hand/primary";
+	public const string k_pchPathUserHandSecondary = "/user/hand/secondary";
+	public const string k_pchPathUserHead = "/user/head";
+	public const string k_pchPathUserGamepad = "/user/gamepad";
+	public const string k_pchPathUserTreadmill = "/user/treadmill";
+	public const string k_pchPathUserStylus = "/user/stylus";
+	public const string k_pchPathDevices = "/devices";
+	public const string k_pchPathDevicePath = "/device_path";
+	public const string k_pchPathBestAliasPath = "/best_alias_path";
+	public const string k_pchPathBoundTrackerAliasPath = "/bound_tracker_path";
+	public const string k_pchPathBoundTrackerRole = "/bound_tracker_role";
+	public const string k_pchPathPoseRaw = "/pose/raw";
+	public const string k_pchPathPoseTip = "/pose/tip";
+	public const string k_pchPathPoseGrip = "/pose/grip";
+	public const string k_pchPathSystemButtonClick = "/input/system/click";
+	public const string k_pchPathProximity = "/proximity";
+	public const string k_pchPathControllerTypePrefix = "/controller_type/";
+	public const string k_pchPathInputProfileSuffix = "/input_profile";
+	public const string k_pchPathBindingNameSuffix = "/binding_name";
+	public const string k_pchPathBindingUrlSuffix = "/binding_url";
+	public const string k_pchPathBindingErrorSuffix = "/binding_error";
+	public const string k_pchPathActiveActionSets = "/active_action_sets";
+	public const string k_pchPathComponentUpdates = "/total_component_updates";
+	public const string k_pchPathUserFootLeft = "/user/foot/left";
+	public const string k_pchPathUserFootRight = "/user/foot/right";
+	public const string k_pchPathUserShoulderLeft = "/user/shoulder/left";
+	public const string k_pchPathUserShoulderRight = "/user/shoulder/right";
+	public const string k_pchPathUserElbowLeft = "/user/elbow/left";
+	public const string k_pchPathUserElbowRight = "/user/elbow/right";
+	public const string k_pchPathUserKneeLeft = "/user/knee/left";
+	public const string k_pchPathUserKneeRight = "/user/knee/right";
+	public const string k_pchPathUserWaist = "/user/waist";
+	public const string k_pchPathUserChest = "/user/chest";
+	public const string k_pchPathUserCamera = "/user/camera";
+	public const string k_pchPathUserKeyboard = "/user/keyboard";
+	public const string k_pchPathClientAppKey = "/client_info/app_key";
+	public const ulong k_ulInvalidPathHandle = 0;
+	public const string IVRPaths_Version = "IVRPaths_001";
+	public const string IVRBlockQueue_Version = "IVRBlockQueue_004";
+
+	static uint VRToken { get; set; }
+
+	const string FnTable_Prefix = "FnTable:";
+
+	class COpenVRContext
+	{
+		public COpenVRContext() { Clear(); }
+
+		public void Clear()
+		{
+			m_pVRSystem = null;
+			m_pVRChaperone = null;
+			m_pVRChaperoneSetup = null;
+			m_pVRCompositor = null;
+			m_pVRHeadsetView = null;
+			m_pVROverlay = null;
+			m_pVROverlayView = null;
+			m_pVRRenderModels = null;
+			m_pVRExtendedDisplay = null;
+			m_pVRSettings = null;
+			m_pVRApplications = null;
+			m_pVRScreenshots = null;
+			m_pVRTrackedCamera = null;
+			m_pVRInput = null;
+			m_pVRIOBuffer = null;
+			m_pVRSpatialAnchors = null;
+			m_pVRNotifications = null;
+			m_pVRDebug = null;
+		}
+
+		void CheckClear()
+		{
+			if (VRToken != GetInitToken())
+			{
+				Clear();
+				VRToken = GetInitToken();
+			}
+		}
+
+		public CVRSystem VRSystem()
+		{
+			CheckClear();
+			if (m_pVRSystem == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRSystem_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRSystem = new CVRSystem(pInterface);
+			}
+			return m_pVRSystem;
+		}
+
+		public CVRChaperone VRChaperone()
+		{
+			CheckClear();
+			if (m_pVRChaperone == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRChaperone_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRChaperone = new CVRChaperone(pInterface);
+			}
+			return m_pVRChaperone;
+		}
+
+		public CVRChaperoneSetup VRChaperoneSetup()
+		{
+			CheckClear();
+			if (m_pVRChaperoneSetup == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRChaperoneSetup_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRChaperoneSetup = new CVRChaperoneSetup(pInterface);
+			}
+			return m_pVRChaperoneSetup;
+		}
+
+		public CVRCompositor VRCompositor()
+		{
+			CheckClear();
+			if (m_pVRCompositor == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRCompositor_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRCompositor = new CVRCompositor(pInterface);
+			}
+			return m_pVRCompositor;
+		}
+
+		public CVRHeadsetView VRHeadsetView()
+		{
+			CheckClear();
+			if (m_pVRHeadsetView == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRHeadsetView_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRHeadsetView = new CVRHeadsetView(pInterface);
+			}
+			return m_pVRHeadsetView;
+		}
+
+		public CVROverlay VROverlay()
+		{
+			CheckClear();
+			if (m_pVROverlay == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVROverlay_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVROverlay = new CVROverlay(pInterface);
+			}
+			return m_pVROverlay;
+		}
+
+		public CVROverlayView VROverlayView()
+		{
+			CheckClear();
+			if (m_pVROverlayView == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVROverlayView_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVROverlayView = new CVROverlayView(pInterface);
+			}
+			return m_pVROverlayView;
+		}
+
+		public CVRRenderModels VRRenderModels()
+		{
+			CheckClear();
+			if (m_pVRRenderModels == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRRenderModels_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRRenderModels = new CVRRenderModels(pInterface);
+			}
+			return m_pVRRenderModels;
+		}
+
+		public CVRExtendedDisplay VRExtendedDisplay()
+		{
+			CheckClear();
+			if (m_pVRExtendedDisplay == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRExtendedDisplay_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRExtendedDisplay = new CVRExtendedDisplay(pInterface);
+			}
+			return m_pVRExtendedDisplay;
+		}
+
+		public CVRSettings VRSettings()
+		{
+			CheckClear();
+			if (m_pVRSettings == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRSettings_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRSettings = new CVRSettings(pInterface);
+			}
+			return m_pVRSettings;
+		}
+
+		public CVRApplications VRApplications()
+		{
+			CheckClear();
+			if (m_pVRApplications == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRApplications_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRApplications = new CVRApplications(pInterface);
+			}
+			return m_pVRApplications;
+		}
+
+		public CVRScreenshots VRScreenshots()
+		{
+			CheckClear();
+			if (m_pVRScreenshots == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRScreenshots_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRScreenshots = new CVRScreenshots(pInterface);
+			}
+			return m_pVRScreenshots;
+		}
+
+		public CVRTrackedCamera VRTrackedCamera()
+		{
+			CheckClear();
+			if (m_pVRTrackedCamera == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRTrackedCamera_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRTrackedCamera = new CVRTrackedCamera(pInterface);
+			}
+			return m_pVRTrackedCamera;
+		}
+
+		public CVRInput VRInput()
+		{
+			CheckClear();
+			if (m_pVRInput == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRInput_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRInput = new CVRInput(pInterface);
+			}
+			return m_pVRInput;
+		}
+
+		public CVRIOBuffer VRIOBuffer()
+		{
+			CheckClear();
+			if (m_pVRIOBuffer == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRIOBuffer_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRIOBuffer = new CVRIOBuffer(pInterface);
+			}
+			return m_pVRIOBuffer;
+		}
+
+		public CVRSpatialAnchors VRSpatialAnchors()
+		{
+			CheckClear();
+			if (m_pVRSpatialAnchors == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSpatialAnchors_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRSpatialAnchors = new CVRSpatialAnchors(pInterface);
+			}
+			return m_pVRSpatialAnchors;
+		}
+
+		public CVRDebug VRDebug()
+		{
+			CheckClear();
+			if (m_pVRDebug == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRDebug_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRDebug = new CVRDebug(pInterface);
+			}
+			return m_pVRDebug;
+		}
+
+		public CVRNotifications VRNotifications()
+		{
+			CheckClear();
+			if (m_pVRNotifications == null)
+			{
+				var eError = EVRInitError.None;
+				var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRNotifications_Version, ref eError);
+				if (pInterface != IntPtr.Zero && eError == EVRInitError.None)
+					m_pVRNotifications = new CVRNotifications(pInterface);
+			}
+			return m_pVRNotifications;
+		}
+
+		private CVRSystem m_pVRSystem;
+		private CVRChaperone m_pVRChaperone;
+		private CVRChaperoneSetup m_pVRChaperoneSetup;
+		private CVRCompositor m_pVRCompositor;
+		private CVRHeadsetView m_pVRHeadsetView;
+		private CVROverlay m_pVROverlay;
+		private CVROverlayView m_pVROverlayView;
+		private CVRRenderModels m_pVRRenderModels;
+		private CVRExtendedDisplay m_pVRExtendedDisplay;
+		private CVRSettings m_pVRSettings;
+		private CVRApplications m_pVRApplications;
+		private CVRScreenshots m_pVRScreenshots;
+		private CVRTrackedCamera m_pVRTrackedCamera;
+		private CVRInput m_pVRInput;
+		private CVRIOBuffer m_pVRIOBuffer;
+		private CVRSpatialAnchors m_pVRSpatialAnchors;
+		private CVRNotifications m_pVRNotifications;
+		private CVRDebug m_pVRDebug;
+	};
+
+	private static COpenVRContext _OpenVRInternal_ModuleContext = null;
+	static COpenVRContext OpenVRInternal_ModuleContext
+	{
+		get
+		{
+			if (_OpenVRInternal_ModuleContext == null)
+				_OpenVRInternal_ModuleContext = new COpenVRContext();
+			return _OpenVRInternal_ModuleContext;
+		}
+	}
+
+	public static CVRSystem System { get { return OpenVRInternal_ModuleContext.VRSystem(); } }
+	public static CVRChaperone Chaperone { get { return OpenVRInternal_ModuleContext.VRChaperone(); } }
+	public static CVRChaperoneSetup ChaperoneSetup { get { return OpenVRInternal_ModuleContext.VRChaperoneSetup(); } }
+	public static CVRCompositor Compositor { get { return OpenVRInternal_ModuleContext.VRCompositor(); } }
+	public static CVRHeadsetView HeadsetView { get { return OpenVRInternal_ModuleContext.VRHeadsetView(); } }
+	public static CVROverlay Overlay { get { return OpenVRInternal_ModuleContext.VROverlay(); } }
+	public static CVROverlayView OverlayView { get { return OpenVRInternal_ModuleContext.VROverlayView(); } }
+	public static CVRRenderModels RenderModels { get { return OpenVRInternal_ModuleContext.VRRenderModels(); } }
+	public static CVRExtendedDisplay ExtendedDisplay { get { return OpenVRInternal_ModuleContext.VRExtendedDisplay(); } }
+	public static CVRSettings Settings { get { return OpenVRInternal_ModuleContext.VRSettings(); } }
+	public static CVRApplications Applications { get { return OpenVRInternal_ModuleContext.VRApplications(); } }
+	public static CVRScreenshots Screenshots { get { return OpenVRInternal_ModuleContext.VRScreenshots(); } }
+	public static CVRTrackedCamera TrackedCamera { get { return OpenVRInternal_ModuleContext.VRTrackedCamera(); } }
+	public static CVRInput Input { get { return OpenVRInternal_ModuleContext.VRInput(); } }
+	public static CVRIOBuffer IOBuffer { get { return OpenVRInternal_ModuleContext.VRIOBuffer(); } }
+	public static CVRSpatialAnchors SpatialAnchors { get { return OpenVRInternal_ModuleContext.VRSpatialAnchors(); } }
+	public static CVRNotifications Notifications { get { return OpenVRInternal_ModuleContext.VRNotifications(); } }
+	public static CVRDebug Debug { get { return OpenVRInternal_ModuleContext.VRDebug(); } }
+
+
+	/** Finds the active installation of vrclient.dll and initializes it */
+	public static CVRSystem Init(ref EVRInitError peError, EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene, string pchStartupInfo= "")
+	{
+		try
+		{
+			VRToken = InitInternal2(ref peError, eApplicationType, pchStartupInfo);
+		}
+		catch (EntryPointNotFoundException)
+		{
+			VRToken = InitInternal(ref peError, eApplicationType);
+		}
+
+		OpenVRInternal_ModuleContext.Clear();
+
+		if (peError != EVRInitError.None)
+			return null;
+
+		bool bInterfaceValid = IsInterfaceVersionValid(IVRSystem_Version);
+		if (!bInterfaceValid)
+		{
+			ShutdownInternal();
+			peError = EVRInitError.Init_InterfaceNotFound;
+			return null;
+		}
+
+		return OpenVR.System;
+	}
+
+	/** unloads vrclient.dll. Any interface pointers from the interface are
+	* invalid after this point */
+	public static void Shutdown()
+	{
+		ShutdownInternal();
+	}
+
+}
+
+
+
+}
+#endif
+
diff --git a/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/openvr_api.dll b/OpenXR-Runtime-Manager/OpenXR-Runtime-Manager/openvr_api.dll
new file mode 100644
index 0000000000000000000000000000000000000000..a4ad76404d562e80910f134d366c2a64851da34c
GIT binary patch
literal 818904
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%0A8b0
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

literal 0
HcmV?d00001

diff --git a/third-party/openvr b/third-party/openvr
new file mode 160000
index 0000000..4c85abc
--- /dev/null
+++ b/third-party/openvr
@@ -0,0 +1 @@
+Subproject commit 4c85abcb7f7f1f02adaf3812018c99fc593bc341