OpenVR SDK 1.12.5v1.12.5

Vulkan: 
* Added support for texture arrays

[git-p4: depot-paths = "//vr/steamvr/sdk_release/": change = 5908460]

25 files changed, 1268 insertions, 148 deletions

diff --git a/bin/linux32/libopenvr_api.so b/bin/linux32/libopenvr_api.so
index c4fa5ad..a7883e8 100755
--- a/bin/linux32/libopenvr_api.so
+++ b/bin/linux32/libopenvr_api.so
diff --git a/bin/linux32/libopenvr_api.so.dbg b/bin/linux32/libopenvr_api.so.dbg
index aaccc90..87a40d7 100755
--- a/bin/linux32/libopenvr_api.so.dbg
+++ b/bin/linux32/libopenvr_api.so.dbg
diff --git a/bin/linux64/libopenvr_api.so b/bin/linux64/libopenvr_api.so
index 05df827..1e9a1eb 100755
--- a/bin/linux64/libopenvr_api.so
+++ b/bin/linux64/libopenvr_api.so
diff --git a/bin/linux64/libopenvr_api.so.dbg b/bin/linux64/libopenvr_api.so.dbg
index 84adf34..b3267e1 100755
--- a/bin/linux64/libopenvr_api.so.dbg
+++ b/bin/linux64/libopenvr_api.so.dbg
diff --git a/bin/win32/openvr_api.dll b/bin/win32/openvr_api.dll
index b09c549..5d33527 100644
--- a/bin/win32/openvr_api.dll
+++ b/bin/win32/openvr_api.dll
diff --git a/bin/win32/openvr_api.dll.sig b/bin/win32/openvr_api.dll.sig
index 58b8d15..8668ce4 100644
--- a/bin/win32/openvr_api.dll.sig
+++ b/bin/win32/openvr_api.dll.sig
diff --git a/bin/win32/openvr_api.pdb b/bin/win32/openvr_api.pdb
index bb50bfe..6014a38 100644
--- a/bin/win32/openvr_api.pdb
+++ b/bin/win32/openvr_api.pdb
diff --git a/bin/win64/openvr_api.dll b/bin/win64/openvr_api.dll
index ab3d881..6b0c8fe 100644
--- a/bin/win64/openvr_api.dll
+++ b/bin/win64/openvr_api.dll
diff --git a/bin/win64/openvr_api.dll.sig b/bin/win64/openvr_api.dll.sig
index 17e7277..58c40fb 100644
--- a/bin/win64/openvr_api.dll.sig
+++ b/bin/win64/openvr_api.dll.sig
diff --git a/bin/win64/openvr_api.pdb b/bin/win64/openvr_api.pdb
index f49a132..d82ded0 100644
--- a/bin/win64/openvr_api.pdb
+++ b/bin/win64/openvr_api.pdb
diff --git a/headers/openvr.h b/headers/openvr.h
index ec26ef4..e3f7c16 100644
--- a/headers/openvr.h
+++ b/headers/openvr.h
@@ -15,8 +15,8 @@
 namespace vr
 {
 	static const uint32_t k_nSteamVRVersionMajor = 1;
-	static const uint32_t k_nSteamVRVersionMinor = 11;
-	static const uint32_t k_nSteamVRVersionBuild = 11;
+	static const uint32_t k_nSteamVRVersionMinor = 12;
+	static const uint32_t k_nSteamVRVersionBuild = 5;
 } // namespace vr
 
 // vrtypes.h
@@ -634,6 +634,9 @@ enum EVRSubmitFlags
 	// Set to indicate a discontinuity between this and the last frame.
 	// This will prevent motion smoothing from attempting to extrapolate using the pair.
 	Submit_FrameDiscontinuty = 0x20,
+
+	// Set to indicate that pTexture->handle is a contains VRVulkanTextureArrayData_t
+	Submit_VulkanTextureWithArrayData = 0x40,
 };
 
 /** Data required for passing Vulkan textures to IVRCompositor::Submit.
@@ -650,6 +653,15 @@ struct VRVulkanTextureData_t
 	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
 };
 
+/** Data required for passing Vulkan texture arrays to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. 
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureArrayData_t : public VRVulkanTextureData_t
+{
+	uint32_t m_unArrayIndex;
+	uint32_t m_unArraySize;
+};
+
 /** Data required for passing D3D12 textures to IVRCompositor::Submit.
 * Be sure to call OpenVR_Shutdown before destroying these resources. */
 struct D3D12TextureData_t
@@ -2700,6 +2712,8 @@ namespace vr
 	static const char * const k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
 	static const char * const k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
 	static const char * const k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+	static const char * const k_pch_SteamVR_BlockOculusSDKOnOpenVRLaunchOption_Bool = "blockOculusSDKOnOpenVRLaunchOption";
+	static const char * const k_pch_SteamVR_BlockOculusSDKOnAllLaunches_Bool = "blockOculusSDKOnAllLaunches";
 
 	//-----------------------------------------------------------------------------
 	// direct mode keys
@@ -2878,6 +2892,7 @@ namespace vr
 	static const char* const k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
 	static const char* const k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
 	static const char* const k_pch_App_DominantHand_Int32 = "DominantHand";
+	static const char* const k_pch_App_BlockOculusSDK_Bool = "blockOculusSDK";
 
 	//-----------------------------------------------------------------------------
 	// configuration for trackers
diff --git a/headers/openvr_api.cs b/headers/openvr_api.cs
index db9893f..ef55a5f 100644
--- a/headers/openvr_api.cs
+++ b/headers/openvr_api.cs
@@ -355,17 +355,17 @@ public struct IVRTrackedCamera
 public struct IVRApplications
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _AddApplicationManifest(string pchApplicationManifestFullPath, bool bTemporary);
+	internal delegate EVRApplicationError _AddApplicationManifest(IntPtr pchApplicationManifestFullPath, bool bTemporary);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _AddApplicationManifest AddApplicationManifest;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _RemoveApplicationManifest(string pchApplicationManifestFullPath);
+	internal delegate EVRApplicationError _RemoveApplicationManifest(IntPtr pchApplicationManifestFullPath);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _RemoveApplicationManifest RemoveApplicationManifest;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate bool _IsApplicationInstalled(string pchAppKey);
+	internal delegate bool _IsApplicationInstalled(IntPtr pchAppKey);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _IsApplicationInstalled IsApplicationInstalled;
 
@@ -385,37 +385,37 @@ public struct IVRApplications
 	internal _GetApplicationKeyByProcessId GetApplicationKeyByProcessId;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _LaunchApplication(string pchAppKey);
+	internal delegate EVRApplicationError _LaunchApplication(IntPtr pchAppKey);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _LaunchApplication LaunchApplication;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _LaunchTemplateApplication(string pchTemplateAppKey, string pchNewAppKey, [In, Out] AppOverrideKeys_t[] pKeys, uint unKeys);
+	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(string pchMimeType, string pchArgs);
+	internal delegate EVRApplicationError _LaunchApplicationFromMimeType(IntPtr pchMimeType, IntPtr pchArgs);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _LaunchApplicationFromMimeType LaunchApplicationFromMimeType;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _LaunchDashboardOverlay(string pchAppKey);
+	internal delegate EVRApplicationError _LaunchDashboardOverlay(IntPtr pchAppKey);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _LaunchDashboardOverlay LaunchDashboardOverlay;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate bool _CancelApplicationLaunch(string pchAppKey);
+	internal delegate bool _CancelApplicationLaunch(IntPtr pchAppKey);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _CancelApplicationLaunch CancelApplicationLaunch;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _IdentifyApplication(uint unProcessId, string pchAppKey);
+	internal delegate EVRApplicationError _IdentifyApplication(uint unProcessId, IntPtr pchAppKey);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _IdentifyApplication IdentifyApplication;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _GetApplicationProcessId(string pchAppKey);
+	internal delegate uint _GetApplicationProcessId(IntPtr pchAppKey);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetApplicationProcessId GetApplicationProcessId;
 
@@ -425,47 +425,47 @@ public struct IVRApplications
 	internal _GetApplicationsErrorNameFromEnum GetApplicationsErrorNameFromEnum;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _GetApplicationPropertyString(string pchAppKey, EVRApplicationProperty eProperty, System.Text.StringBuilder pchPropertyValueBuffer, uint unPropertyValueBufferLen, ref EVRApplicationError peError);
+	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(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError);
+	internal delegate bool _GetApplicationPropertyBool(IntPtr pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetApplicationPropertyBool GetApplicationPropertyBool;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate ulong _GetApplicationPropertyUint64(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError);
+	internal delegate ulong _GetApplicationPropertyUint64(IntPtr pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetApplicationPropertyUint64 GetApplicationPropertyUint64;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _SetApplicationAutoLaunch(string pchAppKey, bool bAutoLaunch);
+	internal delegate EVRApplicationError _SetApplicationAutoLaunch(IntPtr pchAppKey, bool bAutoLaunch);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _SetApplicationAutoLaunch SetApplicationAutoLaunch;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate bool _GetApplicationAutoLaunch(string pchAppKey);
+	internal delegate bool _GetApplicationAutoLaunch(IntPtr pchAppKey);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetApplicationAutoLaunch GetApplicationAutoLaunch;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _SetDefaultApplicationForMimeType(string pchAppKey, string pchMimeType);
+	internal delegate EVRApplicationError _SetDefaultApplicationForMimeType(IntPtr pchAppKey, IntPtr pchMimeType);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _SetDefaultApplicationForMimeType SetDefaultApplicationForMimeType;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate bool _GetDefaultApplicationForMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen);
+	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(string pchAppKey, System.Text.StringBuilder pchMimeTypesBuffer, uint unMimeTypesBuffer);
+	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(string pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer);
+	internal delegate uint _GetApplicationsThatSupportMimeType(IntPtr pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetApplicationsThatSupportMimeType GetApplicationsThatSupportMimeType;
 
@@ -485,7 +485,7 @@ public struct IVRApplications
 	internal _GetSceneApplicationState GetSceneApplicationState;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _PerformApplicationPrelaunchCheck(string pchAppKey);
+	internal delegate EVRApplicationError _PerformApplicationPrelaunchCheck(IntPtr pchAppKey);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _PerformApplicationPrelaunchCheck PerformApplicationPrelaunchCheck;
 
@@ -495,7 +495,7 @@ public struct IVRApplications
 	internal _GetSceneApplicationStateNameFromEnum GetSceneApplicationStateNameFromEnum;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRApplicationError _LaunchInternalProcess(string pchBinaryPath, string pchArguments, string pchWorkingDirectory);
+	internal delegate EVRApplicationError _LaunchInternalProcess(IntPtr pchBinaryPath, IntPtr pchArguments, IntPtr pchWorkingDirectory);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _LaunchInternalProcess LaunchInternalProcess;
 
@@ -635,7 +635,7 @@ public struct IVRChaperoneSetup
 	internal _ExportLiveToBuffer ExportLiveToBuffer;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate bool _ImportFromBufferToWorking(string pBuffer, uint nImportFlags);
+	internal delegate bool _ImportFromBufferToWorking(IntPtr pBuffer, uint nImportFlags);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _ImportFromBufferToWorking ImportFromBufferToWorking;
 
@@ -890,7 +890,7 @@ public struct IVRCompositor
 	internal _IsCurrentSceneFocusAppLoading IsCurrentSceneFocusAppLoading;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRCompositorError _SetStageOverride_Async(string pchRenderModelPath, ref HmdMatrix34_t pTransform, ref Compositor_StageRenderSettings pRenderSettings, uint nSizeOfRenderSettings);
+	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;
 
@@ -920,12 +920,12 @@ public struct IVRCompositor
 public struct IVROverlay
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVROverlayError _FindOverlay(string pchOverlayKey, ref ulong pOverlayHandle);
+	internal delegate EVROverlayError _FindOverlay(IntPtr pchOverlayKey, ref ulong pOverlayHandle);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _FindOverlay FindOverlay;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVROverlayError _CreateOverlay(string pchOverlayKey, string pchOverlayName, ref ulong pOverlayHandle);
+	internal delegate EVROverlayError _CreateOverlay(IntPtr pchOverlayKey, IntPtr pchOverlayName, ref ulong pOverlayHandle);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _CreateOverlay CreateOverlay;
 
@@ -945,7 +945,7 @@ public struct IVROverlay
 	internal _GetOverlayName GetOverlayName;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVROverlayError _SetOverlayName(ulong ulOverlayHandle, string pchName);
+	internal delegate EVROverlayError _SetOverlayName(ulong ulOverlayHandle, IntPtr pchName);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _SetOverlayName SetOverlayName;
 
@@ -1090,7 +1090,7 @@ public struct IVROverlay
 	internal _GetOverlayTransformTrackedDeviceRelative GetOverlayTransformTrackedDeviceRelative;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, string pchComponentName);
+	internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, IntPtr pchComponentName);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _SetOverlayTransformTrackedDeviceComponent SetOverlayTransformTrackedDeviceComponent;
 
@@ -1215,7 +1215,7 @@ public struct IVROverlay
 	internal _SetOverlayRaw SetOverlayRaw;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVROverlayError _SetOverlayFromFile(ulong ulOverlayHandle, string pchFilePath);
+	internal delegate EVROverlayError _SetOverlayFromFile(ulong ulOverlayHandle, IntPtr pchFilePath);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _SetOverlayFromFile SetOverlayFromFile;
 
@@ -1235,7 +1235,7 @@ public struct IVROverlay
 	internal _GetOverlayTextureSize GetOverlayTextureSize;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVROverlayError _CreateDashboardOverlay(string pchOverlayKey, string pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle);
+	internal delegate EVROverlayError _CreateDashboardOverlay(IntPtr pchOverlayKey, IntPtr pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _CreateDashboardOverlay CreateDashboardOverlay;
 
@@ -1260,7 +1260,7 @@ public struct IVROverlay
 	internal _GetDashboardOverlaySceneProcess GetDashboardOverlaySceneProcess;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate void _ShowDashboard(string pchOverlayToShow);
+	internal delegate void _ShowDashboard(IntPtr pchOverlayToShow);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _ShowDashboard ShowDashboard;
 
@@ -1270,12 +1270,12 @@ public struct IVROverlay
 	internal _GetPrimaryDashboardDevice GetPrimaryDashboardDevice;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVROverlayError _ShowKeyboard(int eInputMode, int eLineInputMode, uint unFlags, string pchDescription, uint unCharMax, string pchExistingText, ulong uUserValue);
+	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, string pchDescription, uint unCharMax, string pchExistingText, ulong uUserValue);
+	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;
 
@@ -1300,7 +1300,7 @@ public struct IVROverlay
 	internal _SetKeyboardPositionForOverlay SetKeyboardPositionForOverlay;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate VRMessageOverlayResponse _ShowMessageOverlay(string pchText, string pchCaption, string pchButton0Text, string pchButton1Text, string pchButton2Text, string pchButton3Text);
+	internal delegate VRMessageOverlayResponse _ShowMessageOverlay(IntPtr pchText, IntPtr pchCaption, IntPtr pchButton0Text, IntPtr pchButton1Text, IntPtr pchButton2Text, IntPtr pchButton3Text);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _ShowMessageOverlay ShowMessageOverlay;
 
@@ -1390,7 +1390,7 @@ public struct IVRHeadsetView
 public struct IVRRenderModels
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRRenderModelError _LoadRenderModel_Async(string pchRenderModelName, ref IntPtr ppRenderModel);
+	internal delegate EVRRenderModelError _LoadRenderModel_Async(IntPtr pchRenderModelName, ref IntPtr ppRenderModel);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _LoadRenderModel_Async LoadRenderModel_Async;
 
@@ -1435,47 +1435,47 @@ public struct IVRRenderModels
 	internal _GetRenderModelCount GetRenderModelCount;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _GetComponentCount(string pchRenderModelName);
+	internal delegate uint _GetComponentCount(IntPtr pchRenderModelName);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetComponentCount GetComponentCount;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _GetComponentName(string pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen);
+	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(string pchRenderModelName, string pchComponentName);
+	internal delegate ulong _GetComponentButtonMask(IntPtr pchRenderModelName, IntPtr pchComponentName);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetComponentButtonMask GetComponentButtonMask;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _GetComponentRenderModelName(string pchRenderModelName, string pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen);
+	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(string pchRenderModelName, string pchComponentName, ulong devicePath, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState);
+	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(string pchRenderModelName, string pchComponentName, ref VRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState);
+	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(string pchRenderModelName, string pchComponentName);
+	internal delegate bool _RenderModelHasComponent(IntPtr pchRenderModelName, IntPtr pchComponentName);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _RenderModelHasComponent RenderModelHasComponent;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _GetRenderModelThumbnailURL(string pchRenderModelName, System.Text.StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError);
+	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(string pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError);
+	internal delegate uint _GetRenderModelOriginalPath(IntPtr pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetRenderModelOriginalPath GetRenderModelOriginalPath;
 
@@ -1490,7 +1490,7 @@ public struct IVRRenderModels
 public struct IVRNotifications
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRNotificationError _CreateNotification(ulong ulOverlayHandle, ulong ulUserValue, EVRNotificationType type, string pchText, EVRNotificationStyle style, ref NotificationBitmap_t pImage, ref uint pNotificationId);
+	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;
 
@@ -1510,52 +1510,52 @@ public struct IVRSettings
 	internal _GetSettingsErrorNameFromEnum GetSettingsErrorNameFromEnum;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate void _SetBool(string pchSection, string pchSettingsKey, bool bValue, ref EVRSettingsError peError);
+	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(string pchSection, string pchSettingsKey, int nValue, ref EVRSettingsError peError);
+	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(string pchSection, string pchSettingsKey, float flValue, ref EVRSettingsError peError);
+	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(string pchSection, string pchSettingsKey, string pchValue, ref EVRSettingsError peError);
+	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(string pchSection, string pchSettingsKey, ref EVRSettingsError peError);
+	internal delegate bool _GetBool(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetBool GetBool;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate int _GetInt32(string pchSection, string pchSettingsKey, ref EVRSettingsError peError);
+	internal delegate int _GetInt32(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetInt32 GetInt32;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate float _GetFloat(string pchSection, string pchSettingsKey, ref EVRSettingsError peError);
+	internal delegate float _GetFloat(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetFloat GetFloat;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate void _GetString(string pchSection, string pchSettingsKey, System.Text.StringBuilder pchValue, uint unValueLen, ref EVRSettingsError peError);
+	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(string pchSection, ref EVRSettingsError peError);
+	internal delegate void _RemoveSection(IntPtr pchSection, ref EVRSettingsError peError);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _RemoveSection RemoveSection;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate void _RemoveKeyInSection(string pchSection, string pchSettingsKey, ref EVRSettingsError peError);
+	internal delegate void _RemoveKeyInSection(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _RemoveKeyInSection RemoveKeyInSection;
 
@@ -1565,7 +1565,7 @@ public struct IVRSettings
 public struct IVRScreenshots
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRScreenshotError _RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, string pchPreviewFilename, string pchVRFilename);
+	internal delegate EVRScreenshotError _RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, IntPtr pchPreviewFilename, IntPtr pchVRFilename);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _RequestScreenshot RequestScreenshot;
 
@@ -1590,12 +1590,12 @@ public struct IVRScreenshots
 	internal _UpdateScreenshotProgress UpdateScreenshotProgress;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRScreenshotError _TakeStereoScreenshot(ref uint pOutScreenshotHandle, string pchPreviewFilename, string pchVRFilename);
+	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, string pchSourcePreviewFilename, string pchSourceVRFilename);
+	internal delegate EVRScreenshotError _SubmitScreenshot(uint screenshotHandle, EVRScreenshotType type, IntPtr pchSourcePreviewFilename, IntPtr pchSourceVRFilename);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _SubmitScreenshot SubmitScreenshot;
 
@@ -1605,12 +1605,12 @@ public struct IVRScreenshots
 public struct IVRResources
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _LoadSharedResource(string pchResourceName, string pchBuffer, uint unBufferLen);
+	internal delegate uint _LoadSharedResource(IntPtr pchResourceName, string pchBuffer, uint unBufferLen);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _LoadSharedResource LoadSharedResource;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _GetResourceFullPath(string pchResourceName, string pchResourceTypeDirectory, System.Text.StringBuilder pchPathBuffer, uint unBufferLen);
+	internal delegate uint _GetResourceFullPath(IntPtr pchResourceName, IntPtr pchResourceTypeDirectory, System.Text.StringBuilder pchPathBuffer, uint unBufferLen);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetResourceFullPath GetResourceFullPath;
 
@@ -1630,7 +1630,7 @@ public struct IVRDriverManager
 	internal _GetDriverName GetDriverName;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate ulong _GetDriverHandle(string pchDriverName);
+	internal delegate ulong _GetDriverHandle(IntPtr pchDriverName);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetDriverHandle GetDriverHandle;
 
@@ -1645,22 +1645,22 @@ public struct IVRDriverManager
 public struct IVRInput
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRInputError _SetActionManifestPath(string pchActionManifestPath);
+	internal delegate EVRInputError _SetActionManifestPath(IntPtr pchActionManifestPath);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _SetActionManifestPath SetActionManifestPath;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRInputError _GetActionSetHandle(string pchActionSetName, ref ulong pHandle);
+	internal delegate EVRInputError _GetActionSetHandle(IntPtr pchActionSetName, ref ulong pHandle);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetActionSetHandle GetActionSetHandle;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRInputError _GetActionHandle(string pchActionName, ref ulong pHandle);
+	internal delegate EVRInputError _GetActionHandle(IntPtr pchActionName, ref ulong pHandle);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetActionHandle GetActionHandle;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRInputError _GetInputSourceHandle(string pchInputSourcePath, ref ulong pHandle);
+	internal delegate EVRInputError _GetInputSourceHandle(IntPtr pchInputSourcePath, ref ulong pHandle);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _GetInputSourceHandle GetInputSourceHandle;
 
@@ -1785,7 +1785,7 @@ public struct IVRInput
 	internal _ShowBindingsForActionSet ShowBindingsForActionSet;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRInputError _GetComponentStateForBinding(string pchRenderModelName, string pchComponentName, ref InputBindingInfo_t pOriginInfo, uint unBindingInfoSize, uint unBindingInfoCount, ref RenderModel_ComponentState_t pComponentState);
+	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;
 
@@ -1795,7 +1795,7 @@ public struct IVRInput
 	internal _IsUsingLegacyInput IsUsingLegacyInput;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRInputError _OpenBindingUI(string pchAppKey, ulong ulActionSetHandle, ulong ulDeviceHandle, bool bShowOnDesktop);
+	internal delegate EVRInputError _OpenBindingUI(IntPtr pchAppKey, ulong ulActionSetHandle, ulong ulDeviceHandle, bool bShowOnDesktop);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _OpenBindingUI OpenBindingUI;
 
@@ -1810,7 +1810,7 @@ public struct IVRInput
 public struct IVRIOBuffer
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EIOBufferError _Open(string pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer);
+	internal delegate EIOBufferError _Open(IntPtr pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _Open Open;
 
@@ -1845,7 +1845,7 @@ public struct IVRIOBuffer
 public struct IVRSpatialAnchors
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromDescriptor(string pchDescriptor, ref uint pHandleOut);
+	internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromDescriptor(IntPtr pchDescriptor, ref uint pHandleOut);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _CreateSpatialAnchorFromDescriptor CreateSpatialAnchorFromDescriptor;
 
@@ -1870,7 +1870,7 @@ public struct IVRSpatialAnchors
 public struct IVRDebug
 {
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRDebugError _EmitVrProfilerEvent(string pchMessage);
+	internal delegate EVRDebugError _EmitVrProfilerEvent(IntPtr pchMessage);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _EmitVrProfilerEvent EmitVrProfilerEvent;
 
@@ -1880,17 +1880,132 @@ public struct IVRDebug
 	internal _BeginVrProfilerEvent BeginVrProfilerEvent;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate EVRDebugError _FinishVrProfilerEvent(ulong hHandle, string pchMessage);
+	internal delegate EVRDebugError _FinishVrProfilerEvent(ulong hHandle, IntPtr pchMessage);
 	[MarshalAs(UnmanagedType.FunctionPtr)]
 	internal _FinishVrProfilerEvent FinishVrProfilerEvent;
 
 	[UnmanagedFunctionPointer(CallingConvention.StdCall)]
-	internal delegate uint _DriverDebugRequest(uint unDeviceIndex, string pchRequest, System.Text.StringBuilder pchResponseBuffer, uint unResponseBufferSize);
+	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)
+	{
+		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
 {
@@ -2344,17 +2459,23 @@ public class CVRApplications
 	}
 	public EVRApplicationError AddApplicationManifest(string pchApplicationManifestFullPath,bool bTemporary)
 	{
-		EVRApplicationError result = FnTable.AddApplicationManifest(pchApplicationManifestFullPath,bTemporary);
+		IntPtr pchApplicationManifestFullPathUtf8 = Utils.ToUtf8(pchApplicationManifestFullPath);
+		EVRApplicationError result = FnTable.AddApplicationManifest(pchApplicationManifestFullPathUtf8,bTemporary);
+		Marshal.FreeHGlobal(pchApplicationManifestFullPathUtf8);
 		return result;
 	}
 	public EVRApplicationError RemoveApplicationManifest(string pchApplicationManifestFullPath)
 	{
-		EVRApplicationError result = FnTable.RemoveApplicationManifest(pchApplicationManifestFullPath);
+		IntPtr pchApplicationManifestFullPathUtf8 = Utils.ToUtf8(pchApplicationManifestFullPath);
+		EVRApplicationError result = FnTable.RemoveApplicationManifest(pchApplicationManifestFullPathUtf8);
+		Marshal.FreeHGlobal(pchApplicationManifestFullPathUtf8);
 		return result;
 	}
 	public bool IsApplicationInstalled(string pchAppKey)
 	{
-		bool result = FnTable.IsApplicationInstalled(pchAppKey);
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		bool result = FnTable.IsApplicationInstalled(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
 		return result;
 	}
 	public uint GetApplicationCount()
@@ -2374,37 +2495,55 @@ public class CVRApplications
 	}
 	public EVRApplicationError LaunchApplication(string pchAppKey)
 	{
-		EVRApplicationError result = FnTable.LaunchApplication(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)
 	{
-		EVRApplicationError result = FnTable.LaunchTemplateApplication(pchTemplateAppKey,pchNewAppKey,pKeys,(uint) pKeys.Length);
+		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)
 	{
-		EVRApplicationError result = FnTable.LaunchApplicationFromMimeType(pchMimeType,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)
 	{
-		EVRApplicationError result = FnTable.LaunchDashboardOverlay(pchAppKey);
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.LaunchDashboardOverlay(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
 		return result;
 	}
 	public bool CancelApplicationLaunch(string pchAppKey)
 	{
-		bool result = FnTable.CancelApplicationLaunch(pchAppKey);
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		bool result = FnTable.CancelApplicationLaunch(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
 		return result;
 	}
 	public EVRApplicationError IdentifyApplication(uint unProcessId,string pchAppKey)
 	{
-		EVRApplicationError result = FnTable.IdentifyApplication(unProcessId,pchAppKey);
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.IdentifyApplication(unProcessId,pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
 		return result;
 	}
 	public uint GetApplicationProcessId(string pchAppKey)
 	{
-		uint result = FnTable.GetApplicationProcessId(pchAppKey);
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		uint result = FnTable.GetApplicationProcessId(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
 		return result;
 	}
 	public string GetApplicationsErrorNameFromEnum(EVRApplicationError error)
@@ -2414,47 +2553,67 @@ public class CVRApplications
 	}
 	public uint GetApplicationPropertyString(string pchAppKey,EVRApplicationProperty eProperty,System.Text.StringBuilder pchPropertyValueBuffer,uint unPropertyValueBufferLen,ref EVRApplicationError peError)
 	{
-		uint result = FnTable.GetApplicationPropertyString(pchAppKey,eProperty,pchPropertyValueBuffer,unPropertyValueBufferLen,ref 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)
 	{
-		bool result = FnTable.GetApplicationPropertyBool(pchAppKey,eProperty,ref 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)
 	{
-		ulong result = FnTable.GetApplicationPropertyUint64(pchAppKey,eProperty,ref 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)
 	{
-		EVRApplicationError result = FnTable.SetApplicationAutoLaunch(pchAppKey,bAutoLaunch);
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.SetApplicationAutoLaunch(pchAppKeyUtf8,bAutoLaunch);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
 		return result;
 	}
 	public bool GetApplicationAutoLaunch(string pchAppKey)
 	{
-		bool result = FnTable.GetApplicationAutoLaunch(pchAppKey);
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		bool result = FnTable.GetApplicationAutoLaunch(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
 		return result;
 	}
 	public EVRApplicationError SetDefaultApplicationForMimeType(string pchAppKey,string pchMimeType)
 	{
-		EVRApplicationError result = FnTable.SetDefaultApplicationForMimeType(pchAppKey,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)
 	{
-		bool result = FnTable.GetDefaultApplicationForMimeType(pchMimeType,pchAppKeyBuffer,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)
 	{
-		bool result = FnTable.GetApplicationSupportedMimeTypes(pchAppKey,pchMimeTypesBuffer,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)
 	{
-		uint result = FnTable.GetApplicationsThatSupportMimeType(pchMimeType,pchAppKeysThatSupportBuffer,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)
@@ -2474,7 +2633,9 @@ public class CVRApplications
 	}
 	public EVRApplicationError PerformApplicationPrelaunchCheck(string pchAppKey)
 	{
-		EVRApplicationError result = FnTable.PerformApplicationPrelaunchCheck(pchAppKey);
+		IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey);
+		EVRApplicationError result = FnTable.PerformApplicationPrelaunchCheck(pchAppKeyUtf8);
+		Marshal.FreeHGlobal(pchAppKeyUtf8);
 		return result;
 	}
 	public string GetSceneApplicationStateNameFromEnum(EVRSceneApplicationState state)
@@ -2484,7 +2645,13 @@ public class CVRApplications
 	}
 	public EVRApplicationError LaunchInternalProcess(string pchBinaryPath,string pchArguments,string pchWorkingDirectory)
 	{
-		EVRApplicationError result = FnTable.LaunchInternalProcess(pchBinaryPath,pchArguments,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()
@@ -2634,7 +2801,9 @@ public class CVRChaperoneSetup
 	}
 	public bool ImportFromBufferToWorking(string pBuffer,uint nImportFlags)
 	{
-		bool result = FnTable.ImportFromBufferToWorking(pBuffer,nImportFlags);
+		IntPtr pBufferUtf8 = Utils.ToUtf8(pBuffer);
+		bool result = FnTable.ImportFromBufferToWorking(pBufferUtf8,nImportFlags);
+		Marshal.FreeHGlobal(pBufferUtf8);
 		return result;
 	}
 	public void ShowWorkingSetPreview()
@@ -2872,7 +3041,9 @@ public class CVRCompositor
 	}
 	public EVRCompositorError SetStageOverride_Async(string pchRenderModelPath,ref HmdMatrix34_t pTransform,ref Compositor_StageRenderSettings pRenderSettings,uint nSizeOfRenderSettings)
 	{
-		EVRCompositorError result = FnTable.SetStageOverride_Async(pchRenderModelPath,ref pTransform,ref pRenderSettings,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()
@@ -2908,14 +3079,20 @@ public class CVROverlay
 	}
 	public EVROverlayError FindOverlay(string pchOverlayKey,ref ulong pOverlayHandle)
 	{
+		IntPtr pchOverlayKeyUtf8 = Utils.ToUtf8(pchOverlayKey);
 		pOverlayHandle = 0;
-		EVROverlayError result = FnTable.FindOverlay(pchOverlayKey,ref pOverlayHandle);
+		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(pchOverlayKey,pchOverlayName,ref pOverlayHandle);
+		EVROverlayError result = FnTable.CreateOverlay(pchOverlayKeyUtf8,pchOverlayNameUtf8,ref pOverlayHandle);
+		Marshal.FreeHGlobal(pchOverlayKeyUtf8);
+		Marshal.FreeHGlobal(pchOverlayNameUtf8);
 		return result;
 	}
 	public EVROverlayError DestroyOverlay(ulong ulOverlayHandle)
@@ -2935,7 +3112,9 @@ public class CVROverlay
 	}
 	public EVROverlayError SetOverlayName(ulong ulOverlayHandle,string pchName)
 	{
-		EVROverlayError result = FnTable.SetOverlayName(ulOverlayHandle,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)
@@ -3093,7 +3272,9 @@ public class CVROverlay
 	}
 	public EVROverlayError SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,uint unDeviceIndex,string pchComponentName)
 	{
-		EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,unDeviceIndex,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)
@@ -3246,7 +3427,9 @@ public class CVROverlay
 	}
 	public EVROverlayError SetOverlayFromFile(ulong ulOverlayHandle,string pchFilePath)
 	{
-		EVROverlayError result = FnTable.SetOverlayFromFile(ulOverlayHandle,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)
@@ -3271,9 +3454,13 @@ public class CVROverlay
 	}
 	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(pchOverlayKey,pchOverlayFriendlyName,ref pMainHandle,ref pThumbnailHandle);
+		EVROverlayError result = FnTable.CreateDashboardOverlay(pchOverlayKeyUtf8,pchOverlayFriendlyNameUtf8,ref pMainHandle,ref pThumbnailHandle);
+		Marshal.FreeHGlobal(pchOverlayKeyUtf8);
+		Marshal.FreeHGlobal(pchOverlayFriendlyNameUtf8);
 		return result;
 	}
 	public bool IsDashboardVisible()
@@ -3299,7 +3486,9 @@ public class CVROverlay
 	}
 	public void ShowDashboard(string pchOverlayToShow)
 	{
-		FnTable.ShowDashboard(pchOverlayToShow);
+		IntPtr pchOverlayToShowUtf8 = Utils.ToUtf8(pchOverlayToShow);
+		FnTable.ShowDashboard(pchOverlayToShowUtf8);
+		Marshal.FreeHGlobal(pchOverlayToShowUtf8);
 	}
 	public uint GetPrimaryDashboardDevice()
 	{
@@ -3308,12 +3497,20 @@ public class CVROverlay
 	}
 	public EVROverlayError ShowKeyboard(int eInputMode,int eLineInputMode,uint unFlags,string pchDescription,uint unCharMax,string pchExistingText,ulong uUserValue)
 	{
-		EVROverlayError result = FnTable.ShowKeyboard(eInputMode,eLineInputMode,unFlags,pchDescription,unCharMax,pchExistingText,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)
 	{
-		EVROverlayError result = FnTable.ShowKeyboardForOverlay(ulOverlayHandle,eInputMode,eLineInputMode,unFlags,pchDescription,unCharMax,pchExistingText,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)
@@ -3335,7 +3532,19 @@ public class CVROverlay
 	}
 	public VRMessageOverlayResponse ShowMessageOverlay(string pchText,string pchCaption,string pchButton0Text,string pchButton1Text,string pchButton2Text,string pchButton3Text)
 	{
-		VRMessageOverlayResponse result = FnTable.ShowMessageOverlay(pchText,pchCaption,pchButton0Text,pchButton1Text,pchButton2Text,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()
@@ -3436,7 +3645,9 @@ public class CVRRenderModels
 	}
 	public EVRRenderModelError LoadRenderModel_Async(string pchRenderModelName,ref IntPtr ppRenderModel)
 	{
-		EVRRenderModelError result = FnTable.LoadRenderModel_Async(pchRenderModelName,ref ppRenderModel);
+		IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName);
+		EVRRenderModelError result = FnTable.LoadRenderModel_Async(pchRenderModelNameUtf8,ref ppRenderModel);
+		Marshal.FreeHGlobal(pchRenderModelNameUtf8);
 		return result;
 	}
 	public void FreeRenderModel(IntPtr pRenderModel)
@@ -3478,33 +3689,49 @@ public class CVRRenderModels
 	}
 	public uint GetComponentCount(string pchRenderModelName)
 	{
-		uint result = FnTable.GetComponentCount(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)
 	{
-		uint result = FnTable.GetComponentName(pchRenderModelName,unComponentIndex,pchComponentName,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)
 	{
-		ulong result = FnTable.GetComponentButtonMask(pchRenderModelName,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)
 	{
-		uint result = FnTable.GetComponentRenderModelName(pchRenderModelName,pchComponentName,pchComponentRenderModelName,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)
 	{
-		bool result = FnTable.GetComponentStateForDevicePath(pchRenderModelName,pchComponentName,devicePath,ref pState,ref 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(string pchRenderModelName,string pchComponentName,ref VRControllerState_t_Packed pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState);
+	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
 	{
@@ -3515,6 +3742,8 @@ public class CVRRenderModels
 	}
 	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))
@@ -3523,28 +3752,38 @@ public class CVRRenderModels
 			VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState);
 			u.pGetComponentStatePacked = null;
 			u.pGetComponentState = FnTable.GetComponentState;
-			bool packed_result = u.pGetComponentStatePacked(pchRenderModelName,pchComponentName,ref state_packed,ref pState,ref pComponentState);
+			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(pchRenderModelName,pchComponentName,ref pControllerState,ref pState,ref pComponentState);
+		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)
 	{
-		bool result = FnTable.RenderModelHasComponent(pchRenderModelName,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)
 	{
-		uint result = FnTable.GetRenderModelThumbnailURL(pchRenderModelName,pchThumbnailURL,unThumbnailURLLen,ref 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)
 	{
-		uint result = FnTable.GetRenderModelOriginalPath(pchRenderModelName,pchOriginalPath,unOriginalPathLen,ref 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)
@@ -3564,8 +3803,10 @@ public class CVRNotifications
 	}
 	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,pchText,style,ref pImage,ref pNotificationId);
+		EVRNotificationError result = FnTable.CreateNotification(ulOverlayHandle,ulUserValue,type,pchTextUtf8,style,ref pImage,ref pNotificationId);
+		Marshal.FreeHGlobal(pchTextUtf8);
 		return result;
 	}
 	public EVRNotificationError RemoveNotification(uint notificationId)
@@ -3590,46 +3831,86 @@ public class CVRSettings
 	}
 	public void SetBool(string pchSection,string pchSettingsKey,bool bValue,ref EVRSettingsError peError)
 	{
-		FnTable.SetBool(pchSection,pchSettingsKey,bValue,ref 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)
 	{
-		FnTable.SetInt32(pchSection,pchSettingsKey,nValue,ref 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)
 	{
-		FnTable.SetFloat(pchSection,pchSettingsKey,flValue,ref 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)
 	{
-		FnTable.SetString(pchSection,pchSettingsKey,pchValue,ref 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)
 	{
-		bool result = FnTable.GetBool(pchSection,pchSettingsKey,ref 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)
 	{
-		int result = FnTable.GetInt32(pchSection,pchSettingsKey,ref 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)
 	{
-		float result = FnTable.GetFloat(pchSection,pchSettingsKey,ref 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)
 	{
-		FnTable.GetString(pchSection,pchSettingsKey,pchValue,unValueLen,ref 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)
 	{
-		FnTable.RemoveSection(pchSection,ref peError);
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		FnTable.RemoveSection(pchSectionUtf8,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
 	}
 	public void RemoveKeyInSection(string pchSection,string pchSettingsKey,ref EVRSettingsError peError)
 	{
-		FnTable.RemoveKeyInSection(pchSection,pchSettingsKey,ref peError);
+		IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection);
+		IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey);
+		FnTable.RemoveKeyInSection(pchSectionUtf8,pchSettingsKeyUtf8,ref peError);
+		Marshal.FreeHGlobal(pchSectionUtf8);
+		Marshal.FreeHGlobal(pchSettingsKeyUtf8);
 	}
 }
 
@@ -3644,7 +3925,11 @@ public class CVRScreenshots
 	public EVRScreenshotError RequestScreenshot(ref uint pOutScreenshotHandle,EVRScreenshotType type,string pchPreviewFilename,string pchVRFilename)
 	{
 		pOutScreenshotHandle = 0;
-		EVRScreenshotError result = FnTable.RequestScreenshot(ref pOutScreenshotHandle,type,pchPreviewFilename,pchVRFilename);
+		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)
@@ -3670,12 +3955,20 @@ public class CVRScreenshots
 	public EVRScreenshotError TakeStereoScreenshot(ref uint pOutScreenshotHandle,string pchPreviewFilename,string pchVRFilename)
 	{
 		pOutScreenshotHandle = 0;
-		EVRScreenshotError result = FnTable.TakeStereoScreenshot(ref pOutScreenshotHandle,pchPreviewFilename,pchVRFilename);
+		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)
 	{
-		EVRScreenshotError result = FnTable.SubmitScreenshot(screenshotHandle,type,pchSourcePreviewFilename,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;
 	}
 }
@@ -3690,12 +3983,18 @@ public class CVRResources
 	}
 	public uint LoadSharedResource(string pchResourceName,string pchBuffer,uint unBufferLen)
 	{
-		uint result = FnTable.LoadSharedResource(pchResourceName,pchBuffer,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)
 	{
-		uint result = FnTable.GetResourceFullPath(pchResourceName,pchResourceTypeDirectory,pchPathBuffer,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;
 	}
 }
@@ -3720,7 +4019,9 @@ public class CVRDriverManager
 	}
 	public ulong GetDriverHandle(string pchDriverName)
 	{
-		ulong result = FnTable.GetDriverHandle(pchDriverName);
+		IntPtr pchDriverNameUtf8 = Utils.ToUtf8(pchDriverName);
+		ulong result = FnTable.GetDriverHandle(pchDriverNameUtf8);
+		Marshal.FreeHGlobal(pchDriverNameUtf8);
 		return result;
 	}
 	public bool IsEnabled(uint nDriver)
@@ -3740,25 +4041,33 @@ public class CVRInput
 	}
 	public EVRInputError SetActionManifestPath(string pchActionManifestPath)
 	{
-		EVRInputError result = FnTable.SetActionManifestPath(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(pchActionSetName,ref pHandle);
+		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(pchActionName,ref pHandle);
+		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(pchInputSourcePath,ref pHandle);
+		EVRInputError result = FnTable.GetInputSourceHandle(pchInputSourcePathUtf8,ref pHandle);
+		Marshal.FreeHGlobal(pchInputSourcePathUtf8);
 		return result;
 	}
 	public EVRInputError UpdateActionState(VRActiveActionSet_t [] pSets,uint unSizeOfVRSelectedActionSet_t)
@@ -3886,7 +4195,11 @@ public class CVRInput
 	}
 	public EVRInputError GetComponentStateForBinding(string pchRenderModelName,string pchComponentName,ref InputBindingInfo_t pOriginInfo,uint unBindingInfoSize,uint unBindingInfoCount,ref RenderModel_ComponentState_t pComponentState)
 	{
-		EVRInputError result = FnTable.GetComponentStateForBinding(pchRenderModelName,pchComponentName,ref pOriginInfo,unBindingInfoSize,unBindingInfoCount,ref 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()
@@ -3896,7 +4209,9 @@ public class CVRInput
 	}
 	public EVRInputError OpenBindingUI(string pchAppKey,ulong ulActionSetHandle,ulong ulDeviceHandle,bool bShowOnDesktop)
 	{
-		EVRInputError result = FnTable.OpenBindingUI(pchAppKey,ulActionSetHandle,ulDeviceHandle,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)
@@ -3916,8 +4231,10 @@ public class CVRIOBuffer
 	}
 	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(pchPath,mode,unElementSize,unElements,ref pulBuffer);
+		EIOBufferError result = FnTable.Open(pchPathUtf8,mode,unElementSize,unElements,ref pulBuffer);
+		Marshal.FreeHGlobal(pchPathUtf8);
 		return result;
 	}
 	public EIOBufferError Close(ulong ulBuffer)
@@ -3958,8 +4275,10 @@ public class CVRSpatialAnchors
 	}
 	public EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor(string pchDescriptor,ref uint pHandleOut)
 	{
+		IntPtr pchDescriptorUtf8 = Utils.ToUtf8(pchDescriptor);
 		pHandleOut = 0;
-		EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromDescriptor(pchDescriptor,ref pHandleOut);
+		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)
@@ -3991,7 +4310,9 @@ public class CVRDebug
 	}
 	public EVRDebugError EmitVrProfilerEvent(string pchMessage)
 	{
-		EVRDebugError result = FnTable.EmitVrProfilerEvent(pchMessage);
+		IntPtr pchMessageUtf8 = Utils.ToUtf8(pchMessage);
+		EVRDebugError result = FnTable.EmitVrProfilerEvent(pchMessageUtf8);
+		Marshal.FreeHGlobal(pchMessageUtf8);
 		return result;
 	}
 	public EVRDebugError BeginVrProfilerEvent(ref ulong pHandleOut)
@@ -4002,12 +4323,145 @@ public class CVRDebug
 	}
 	public EVRDebugError FinishVrProfilerEvent(ulong hHandle,string pchMessage)
 	{
-		EVRDebugError result = FnTable.FinishVrProfilerEvent(hHandle,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)
 	{
-		uint result = FnTable.DriverDebugRequest(unDeviceIndex,pchRequest,pchResponseBuffer,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;
 	}
 }
@@ -4338,6 +4792,7 @@ public enum EVRSubmitFlags
 	Submit_TextureWithPose = 8,
 	Submit_TextureWithDepth = 16,
 	Submit_FrameDiscontinuty = 32,
+	Submit_VulkanTextureWithArrayData = 64,
 }
 public enum EVRState
 {
@@ -5276,6 +5731,32 @@ 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
 {
@@ -5520,6 +6001,11 @@ public enum EVRDebugError
 	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 *
@@ -6847,6 +7333,50 @@ public enum EVRDebugError
 	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
 {
@@ -7057,6 +7587,8 @@ public class OpenVR
 	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_DirectMode_Section = "direct_mode";
 	public const string k_pch_DirectMode_Enable_Bool = "enable";
 	public const string k_pch_DirectMode_Count_Int32 = "count";
@@ -7177,6 +7709,7 @@ public class OpenVR
 	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";
@@ -7204,6 +7737,48 @@ public class OpenVR
 	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_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; }
 
diff --git a/headers/openvr_api.json b/headers/openvr_api.json
index 0dbec84..3cc3ef4 100644
--- a/headers/openvr_api.json
+++ b/headers/openvr_api.json
@@ -39,6 +39,7 @@
 ,{"typedef": "vr::VRFirmwareError","type": "enum vr::EVRFirmwareError"}
 ,{"typedef": "vr::VRCompositorError","type": "enum vr::EVRCompositorError"}
 ,{"typedef": "vr::VRScreenshotsError","type": "enum vr::EVRScreenshotError"}
+,{"typedef": "vr::PathHandle_t","type": "uint64_t"}
 ],
 "enums":[
 	{"enumname": "vr::EVREye","values": [ 
@@ -327,6 +328,7 @@
 	,{"name": "Submit_TextureWithPose","value": "8"}
 	,{"name": "Submit_TextureWithDepth","value": "16"}
 	,{"name": "Submit_FrameDiscontinuty","value": "32"}
+	,{"name": "Submit_VulkanTextureWithArrayData","value": "64"}
 ]}
 ,	{"enumname": "vr::EVRState","values": [ 
 	{"name": "VRState_Undefined","value": "-1"}
@@ -1201,6 +1203,29 @@
 	{"name": "VRDebugError_Success","value": "0"}
 	,{"name": "VRDebugError_BadParameter","value": "1"}
 ]}
+,	{"enumname": "vr::EPropertyWriteType","values": [ 
+	{"name": "PropertyWrite_Set","value": "0"}
+	,{"name": "PropertyWrite_Erase","value": "1"}
+	,{"name": "PropertyWrite_SetError","value": "2"}
+]}
+,	{"enumname": "vr::EBlockQueueError","values": [ 
+	{"name": "BlockQueueError_None","value": "0"}
+	,{"name": "BlockQueueError_QueueAlreadyExists","value": "1"}
+	,{"name": "BlockQueueError_QueueNotFound","value": "2"}
+	,{"name": "BlockQueueError_BlockNotAvailable","value": "3"}
+	,{"name": "BlockQueueError_InvalidHandle","value": "4"}
+	,{"name": "BlockQueueError_InvalidParam","value": "5"}
+	,{"name": "BlockQueueError_ParamMismatch","value": "6"}
+	,{"name": "BlockQueueError_InternalError","value": "7"}
+	,{"name": "BlockQueueError_AlreadyInitialized","value": "8"}
+	,{"name": "BlockQueueError_OperationIsServerOnly","value": "9"}
+	,{"name": "BlockQueueError_TooManyConnections","value": "10"}
+]}
+,	{"enumname": "vr::EBlockQueueReadType","values": [ 
+	{"name": "BlockQueueRead_Latest","value": "0"}
+	,{"name": "BlockQueueRead_New","value": "1"}
+	,{"name": "BlockQueueRead_Next","value": "2"}
+]}
 ],
 "consts":[{
 	"constname": "k_nDriverNone","consttype": "const uint32_t", "constval": "4294967295"}
@@ -1485,6 +1510,10 @@
 ,{
 	"constname": "k_pch_SteamVR_OverlayRenderQuality","consttype": "const char *const", "constval": "overlayRenderQuality_2"}
 ,{
+	"constname": "k_pch_SteamVR_BlockOculusSDKOnOpenVRLaunchOption_Bool","consttype": "const char *const", "constval": "blockOculusSDKOnOpenVRLaunchOption"}
+,{
+	"constname": "k_pch_SteamVR_BlockOculusSDKOnAllLaunches_Bool","consttype": "const char *const", "constval": "blockOculusSDKOnAllLaunches"}
+,{
 	"constname": "k_pch_DirectMode_Section","consttype": "const char *const", "constval": "direct_mode"}
 ,{
 	"constname": "k_pch_DirectMode_Enable_Bool","consttype": "const char *const", "constval": "enable"}
@@ -1725,6 +1754,8 @@
 ,{
 	"constname": "k_pch_App_DominantHand_Int32","consttype": "const char *const", "constval": "DominantHand"}
 ,{
+	"constname": "k_pch_App_BlockOculusSDK_Bool","consttype": "const char *const", "constval": "blockOculusSDK"}
+,{
 	"constname": "k_pch_Trackers_Section","consttype": "const char *const", "constval": "trackers"}
 ,{
 	"constname": "k_pch_DesktopUI_Section","consttype": "const char *const", "constval": "DesktopUI"}
@@ -1778,6 +1809,90 @@
 	"constname": "IVRSpatialAnchors_Version","consttype": "const char *const", "constval": "IVRSpatialAnchors_001"}
 ,{
 	"constname": "IVRDebug_Version","consttype": "const char *const", "constval": "IVRDebug_001"}
+,{
+	"constname": "k_ulDisplayRedirectContainer","consttype": "const PropertyContainerHandle_t", "constval": "25769803779"}
+,{
+	"constname": "IVRProperties_Version","consttype": "const char *const", "constval": "IVRProperties_001"}
+,{
+	"constname": "k_pchPathUserHandRight","consttype": "const char *", "constval": "/user/hand/right"}
+,{
+	"constname": "k_pchPathUserHandLeft","consttype": "const char *", "constval": "/user/hand/left"}
+,{
+	"constname": "k_pchPathUserHandPrimary","consttype": "const char *", "constval": "/user/hand/primary"}
+,{
+	"constname": "k_pchPathUserHandSecondary","consttype": "const char *", "constval": "/user/hand/secondary"}
+,{
+	"constname": "k_pchPathUserHead","consttype": "const char *", "constval": "/user/head"}
+,{
+	"constname": "k_pchPathUserGamepad","consttype": "const char *", "constval": "/user/gamepad"}
+,{
+	"constname": "k_pchPathUserTreadmill","consttype": "const char *", "constval": "/user/treadmill"}
+,{
+	"constname": "k_pchPathUserStylus","consttype": "const char *", "constval": "/user/stylus"}
+,{
+	"constname": "k_pchPathDevices","consttype": "const char *", "constval": "/devices"}
+,{
+	"constname": "k_pchPathDevicePath","consttype": "const char *", "constval": "/device_path"}
+,{
+	"constname": "k_pchPathBestAliasPath","consttype": "const char *", "constval": "/best_alias_path"}
+,{
+	"constname": "k_pchPathBoundTrackerAliasPath","consttype": "const char *", "constval": "/bound_tracker_path"}
+,{
+	"constname": "k_pchPathBoundTrackerRole","consttype": "const char *", "constval": "/bound_tracker_role"}
+,{
+	"constname": "k_pchPathPoseRaw","consttype": "const char *", "constval": "/pose/raw"}
+,{
+	"constname": "k_pchPathPoseTip","consttype": "const char *", "constval": "/pose/tip"}
+,{
+	"constname": "k_pchPathSystemButtonClick","consttype": "const char *", "constval": "/input/system/click"}
+,{
+	"constname": "k_pchPathProximity","consttype": "const char *", "constval": "/proximity"}
+,{
+	"constname": "k_pchPathControllerTypePrefix","consttype": "const char *", "constval": "/controller_type/"}
+,{
+	"constname": "k_pchPathInputProfileSuffix","consttype": "const char *", "constval": "/input_profile"}
+,{
+	"constname": "k_pchPathBindingNameSuffix","consttype": "const char *", "constval": "/binding_name"}
+,{
+	"constname": "k_pchPathBindingUrlSuffix","consttype": "const char *", "constval": "/binding_url"}
+,{
+	"constname": "k_pchPathBindingErrorSuffix","consttype": "const char *", "constval": "/binding_error"}
+,{
+	"constname": "k_pchPathActiveActionSets","consttype": "const char *", "constval": "/active_action_sets"}
+,{
+	"constname": "k_pchPathComponentUpdates","consttype": "const char *", "constval": "/total_component_updates"}
+,{
+	"constname": "k_pchPathUserFootLeft","consttype": "const char *", "constval": "/user/foot/left"}
+,{
+	"constname": "k_pchPathUserFootRight","consttype": "const char *", "constval": "/user/foot/right"}
+,{
+	"constname": "k_pchPathUserShoulderLeft","consttype": "const char *", "constval": "/user/shoulder/left"}
+,{
+	"constname": "k_pchPathUserShoulderRight","consttype": "const char *", "constval": "/user/shoulder/right"}
+,{
+	"constname": "k_pchPathUserElbowLeft","consttype": "const char *", "constval": "/user/elbow/left"}
+,{
+	"constname": "k_pchPathUserElbowRight","consttype": "const char *", "constval": "/user/elbow/right"}
+,{
+	"constname": "k_pchPathUserKneeLeft","consttype": "const char *", "constval": "/user/knee/left"}
+,{
+	"constname": "k_pchPathUserKneeRight","consttype": "const char *", "constval": "/user/knee/right"}
+,{
+	"constname": "k_pchPathUserWaist","consttype": "const char *", "constval": "/user/waist"}
+,{
+	"constname": "k_pchPathUserChest","consttype": "const char *", "constval": "/user/chest"}
+,{
+	"constname": "k_pchPathUserCamera","consttype": "const char *", "constval": "/user/camera"}
+,{
+	"constname": "k_pchPathUserKeyboard","consttype": "const char *", "constval": "/user/keyboard"}
+,{
+	"constname": "k_pchPathClientAppKey","consttype": "const char *", "constval": "/client_info/app_key"}
+,{
+	"constname": "k_ulInvalidPathHandle","consttype": "const PathHandle_t", "constval": "0"}
+,{
+	"constname": "IVRPaths_Version","consttype": "const char *const", "constval": "IVRPaths_001"}
+,{
+	"constname": "IVRBlockQueue_Version","consttype": "const char *", "constval": "IVRBlockQueue_004"}
 ],
 "structs":[{"struct": "vr::HmdMatrix34_t","fields": [
 { "fieldname": "m", "fieldtype": "float [3][4]"}]}
@@ -1854,6 +1969,9 @@
 { "fieldname": "m_nHeight", "fieldtype": "uint32_t"},
 { "fieldname": "m_nFormat", "fieldtype": "uint32_t"},
 { "fieldname": "m_nSampleCount", "fieldtype": "uint32_t"}]}
+,{"struct": "vr::VRVulkanTextureArrayData_t","fields": [
+{ "fieldname": "m_unArrayIndex", "fieldtype": "uint32_t"},
+{ "fieldname": "m_unArraySize", "fieldtype": "uint32_t"}]}
 ,{"struct": "vr::D3D12TextureData_t","fields": [
 { "fieldname": "m_pResource", "fieldtype": "struct ID3D12Resource *"},
 { "fieldname": "m_pCommandQueue", "fieldtype": "struct ID3D12CommandQueue *"},
@@ -2213,6 +2331,40 @@
 { "fieldname": "m_pVRSpatialAnchors", "fieldtype": "class vr::IVRSpatialAnchors *"},
 { "fieldname": "m_pVRDebug", "fieldtype": "class vr::IVRDebug *"},
 { "fieldname": "m_pVRNotifications", "fieldtype": "class vr::IVRNotifications *"}]}
+,{"struct": "vr::PropertyWrite_t","fields": [
+{ "fieldname": "prop", "fieldtype": "enum vr::ETrackedDeviceProperty"},
+{ "fieldname": "writeType", "fieldtype": "enum vr::EPropertyWriteType"},
+{ "fieldname": "eSetError", "fieldtype": "enum vr::ETrackedPropertyError"},
+{ "fieldname": "pvBuffer", "fieldtype": "void *"},
+{ "fieldname": "unBufferSize", "fieldtype": "uint32_t"},
+{ "fieldname": "unTag", "fieldtype": "PropertyTypeTag_t"},
+{ "fieldname": "eError", "fieldtype": "enum vr::ETrackedPropertyError"}]}
+,{"struct": "vr::PropertyRead_t","fields": [
+{ "fieldname": "prop", "fieldtype": "enum vr::ETrackedDeviceProperty"},
+{ "fieldname": "pvBuffer", "fieldtype": "void *"},
+{ "fieldname": "unBufferSize", "fieldtype": "uint32_t"},
+{ "fieldname": "unTag", "fieldtype": "PropertyTypeTag_t"},
+{ "fieldname": "unRequiredBufferSize", "fieldtype": "uint32_t"},
+{ "fieldname": "eError", "fieldtype": "enum vr::ETrackedPropertyError"}]}
+,{"struct": "vr::CVRPropertyHelpers","fields": [
+{ "fieldname": "m_pProperties", "fieldtype": "class vr::IVRProperties *"}]}
+,{"struct": "vr::PathWrite_t","fields": [
+{ "fieldname": "ulPath", "fieldtype": "PathHandle_t"},
+{ "fieldname": "writeType", "fieldtype": "enum vr::EPropertyWriteType"},
+{ "fieldname": "eSetError", "fieldtype": "enum vr::ETrackedPropertyError"},
+{ "fieldname": "pvBuffer", "fieldtype": "void *"},
+{ "fieldname": "unBufferSize", "fieldtype": "uint32_t"},
+{ "fieldname": "unTag", "fieldtype": "PropertyTypeTag_t"},
+{ "fieldname": "eError", "fieldtype": "enum vr::ETrackedPropertyError"},
+{ "fieldname": "pszPath", "fieldtype": "const char *"}]}
+,{"struct": "vr::PathRead_t","fields": [
+{ "fieldname": "ulPath", "fieldtype": "PathHandle_t"},
+{ "fieldname": "pvBuffer", "fieldtype": "void *"},
+{ "fieldname": "unBufferSize", "fieldtype": "uint32_t"},
+{ "fieldname": "unTag", "fieldtype": "PropertyTypeTag_t"},
+{ "fieldname": "unRequiredBufferSize", "fieldtype": "uint32_t"},
+{ "fieldname": "eError", "fieldtype": "enum vr::ETrackedPropertyError"},
+{ "fieldname": "pszPath", "fieldtype": "const char *"}]}
 ],
 "methods":[{
 	"classname": "vr::IVRSystem",
@@ -5372,5 +5524,170 @@
 {	"paramname": "unResponseBufferSize" ,"paramtype": "uint32_t"}
 	 ]
 }
+,{
+	"classname": "vr::IVRProperties",
+	"methodname": "ReadPropertyBatch",
+	"returntype": "vr::ETrackedPropertyError",
+	"params": [ 
+{	"paramname": "ulContainerHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "pBatch" ,"paramtype": "struct vr::PropertyRead_t *"},
+{	"paramname": "unBatchEntryCount" ,"paramtype": "uint32_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRProperties",
+	"methodname": "WritePropertyBatch",
+	"returntype": "vr::ETrackedPropertyError",
+	"params": [ 
+{	"paramname": "ulContainerHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "pBatch" ,"paramtype": "struct vr::PropertyWrite_t *"},
+{	"paramname": "unBatchEntryCount" ,"paramtype": "uint32_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRProperties",
+	"methodname": "GetPropErrorNameFromEnum",
+	"returntype": "const char *",
+	"params": [ 
+{	"paramname": "error" ,"paramtype": "vr::ETrackedPropertyError"}
+	 ]
+}
+,{
+	"classname": "vr::IVRProperties",
+	"methodname": "TrackedDeviceToPropertyContainer",
+	"returntype": "PropertyContainerHandle_t",
+	"params": [ 
+{	"paramname": "nDevice" ,"paramtype": "vr::TrackedDeviceIndex_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRPaths",
+	"methodname": "ReadPathBatch",
+	"returntype": "vr::ETrackedPropertyError",
+	"params": [ 
+{	"paramname": "ulRootHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "pBatch" ,"paramtype": "struct vr::PathRead_t *"},
+{	"paramname": "unBatchEntryCount" ,"paramtype": "uint32_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRPaths",
+	"methodname": "WritePathBatch",
+	"returntype": "vr::ETrackedPropertyError",
+	"params": [ 
+{	"paramname": "ulRootHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "pBatch" ,"paramtype": "struct vr::PathWrite_t *"},
+{	"paramname": "unBatchEntryCount" ,"paramtype": "uint32_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRPaths",
+	"methodname": "StringToHandle",
+	"returntype": "vr::ETrackedPropertyError",
+	"params": [ 
+{	"paramname": "pHandle" ,"paramtype": "vr::PathHandle_t *"},
+{	"paramname": "pchPath" ,"paramtype": "const char *"}
+	 ]
+}
+,{
+	"classname": "vr::IVRPaths",
+	"methodname": "HandleToString",
+	"returntype": "vr::ETrackedPropertyError",
+	"params": [ 
+{	"paramname": "pHandle" ,"paramtype": "vr::PathHandle_t"},
+{	"paramname": "pchBuffer" ,"paramtype": "char *"},
+{	"paramname": "unBufferSize" ,"paramtype": "uint32_t"},
+{	"paramname": "punBufferSizeUsed" ,"paramtype": "uint32_t *"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "Create",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "pulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t *"},
+{	"paramname": "pchPath" ,"paramtype": "const char *"},
+{	"paramname": "unBlockDataSize" ,"paramtype": "uint32_t"},
+{	"paramname": "unBlockHeaderSize" ,"paramtype": "uint32_t"},
+{	"paramname": "unBlockCount" ,"paramtype": "uint32_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "Connect",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "pulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t *"},
+{	"paramname": "pchPath" ,"paramtype": "const char *"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "Destroy",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "ulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "AcquireWriteOnlyBlock",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "ulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "pulBlockHandle" ,"paramtype": "vr::PropertyContainerHandle_t *"},
+{	"paramname": "ppvBuffer" ,"paramtype": "void **"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "ReleaseWriteOnlyBlock",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "ulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "ulBlockHandle" ,"paramtype": "vr::PropertyContainerHandle_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "WaitAndAcquireReadOnlyBlock",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "ulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "pulBlockHandle" ,"paramtype": "vr::PropertyContainerHandle_t *"},
+{	"paramname": "ppvBuffer" ,"paramtype": "const void **"},
+{	"paramname": "eReadType" ,"paramtype": "vr::EBlockQueueReadType"},
+{	"paramname": "unTimeoutMs" ,"paramtype": "uint32_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "AcquireReadOnlyBlock",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "ulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "pulBlockHandle" ,"paramtype": "vr::PropertyContainerHandle_t *"},
+{	"paramname": "ppvBuffer" ,"paramtype": "const void **"},
+{	"paramname": "eReadType" ,"paramtype": "vr::EBlockQueueReadType"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "ReleaseReadOnlyBlock",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "ulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "ulBlockHandle" ,"paramtype": "vr::PropertyContainerHandle_t"}
+	 ]
+}
+,{
+	"classname": "vr::IVRBlockQueue",
+	"methodname": "QueueHasReader",
+	"returntype": "vr::EBlockQueueError",
+	"params": [ 
+{	"paramname": "ulQueueHandle" ,"paramtype": "vr::PropertyContainerHandle_t"},
+{	"paramname": "pbHasReaders" ,"paramtype": "bool *"}
+	 ]
+}
 ]
 }
\ No newline at end of file
diff --git a/headers/openvr_capi.h b/headers/openvr_capi.h
index 625b8da..050db74 100644
--- a/headers/openvr_capi.h
+++ b/headers/openvr_capi.h
@@ -59,6 +59,7 @@ typedef uint32_t PropertyTypeTag_t;
 typedef uint64_t VRActionHandle_t;
 typedef uint64_t VRActionSetHandle_t;
 typedef uint64_t VRInputValueHandle_t;
+typedef uint64_t PathHandle_t;
 
 
 // OpenVR Constants
@@ -204,6 +205,8 @@ static const char * k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyl
 static const char * k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
 static const char * k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
 static const char * k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+static const char * k_pch_SteamVR_BlockOculusSDKOnOpenVRLaunchOption_Bool = "blockOculusSDKOnOpenVRLaunchOption";
+static const char * k_pch_SteamVR_BlockOculusSDKOnAllLaunches_Bool = "blockOculusSDKOnAllLaunches";
 static const char * k_pch_DirectMode_Section = "direct_mode";
 static const char * k_pch_DirectMode_Enable_Bool = "enable";
 static const char * k_pch_DirectMode_Count_Int32 = "count";
@@ -324,6 +327,7 @@ static const char * k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
 static const char * k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
 static const char * k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
 static const char * k_pch_App_DominantHand_Int32 = "DominantHand";
+static const char * k_pch_App_BlockOculusSDK_Bool = "blockOculusSDK";
 static const char * k_pch_Trackers_Section = "trackers";
 static const char * k_pch_DesktopUI_Section = "DesktopUI";
 static const char * k_pch_LastKnown_Section = "LastKnown";
@@ -351,6 +355,48 @@ static const char * IVRIOBuffer_Version = "IVRIOBuffer_002";
 static const unsigned long k_ulInvalidSpatialAnchorHandle = 0;
 static const char * IVRSpatialAnchors_Version = "IVRSpatialAnchors_001";
 static const char * IVRDebug_Version = "IVRDebug_001";
+static const unsigned long long k_ulDisplayRedirectContainer = 25769803779;
+static const char * IVRProperties_Version = "IVRProperties_001";
+static const char * k_pchPathUserHandRight = "/user/hand/right";
+static const char * k_pchPathUserHandLeft = "/user/hand/left";
+static const char * k_pchPathUserHandPrimary = "/user/hand/primary";
+static const char * k_pchPathUserHandSecondary = "/user/hand/secondary";
+static const char * k_pchPathUserHead = "/user/head";
+static const char * k_pchPathUserGamepad = "/user/gamepad";
+static const char * k_pchPathUserTreadmill = "/user/treadmill";
+static const char * k_pchPathUserStylus = "/user/stylus";
+static const char * k_pchPathDevices = "/devices";
+static const char * k_pchPathDevicePath = "/device_path";
+static const char * k_pchPathBestAliasPath = "/best_alias_path";
+static const char * k_pchPathBoundTrackerAliasPath = "/bound_tracker_path";
+static const char * k_pchPathBoundTrackerRole = "/bound_tracker_role";
+static const char * k_pchPathPoseRaw = "/pose/raw";
+static const char * k_pchPathPoseTip = "/pose/tip";
+static const char * k_pchPathSystemButtonClick = "/input/system/click";
+static const char * k_pchPathProximity = "/proximity";
+static const char * k_pchPathControllerTypePrefix = "/controller_type/";
+static const char * k_pchPathInputProfileSuffix = "/input_profile";
+static const char * k_pchPathBindingNameSuffix = "/binding_name";
+static const char * k_pchPathBindingUrlSuffix = "/binding_url";
+static const char * k_pchPathBindingErrorSuffix = "/binding_error";
+static const char * k_pchPathActiveActionSets = "/active_action_sets";
+static const char * k_pchPathComponentUpdates = "/total_component_updates";
+static const char * k_pchPathUserFootLeft = "/user/foot/left";
+static const char * k_pchPathUserFootRight = "/user/foot/right";
+static const char * k_pchPathUserShoulderLeft = "/user/shoulder/left";
+static const char * k_pchPathUserShoulderRight = "/user/shoulder/right";
+static const char * k_pchPathUserElbowLeft = "/user/elbow/left";
+static const char * k_pchPathUserElbowRight = "/user/elbow/right";
+static const char * k_pchPathUserKneeLeft = "/user/knee/left";
+static const char * k_pchPathUserKneeRight = "/user/knee/right";
+static const char * k_pchPathUserWaist = "/user/waist";
+static const char * k_pchPathUserChest = "/user/chest";
+static const char * k_pchPathUserCamera = "/user/camera";
+static const char * k_pchPathUserKeyboard = "/user/keyboard";
+static const char * k_pchPathClientAppKey = "/client_info/app_key";
+static const unsigned long long k_ulInvalidPathHandle = 0;
+static const char * IVRPaths_Version = "IVRPaths_001";
+static const char * IVRBlockQueue_Version = "IVRBlockQueue_004";
 
 // OpenVR Enums
 
@@ -663,6 +709,7 @@ typedef enum EVRSubmitFlags
 	EVRSubmitFlags_Submit_TextureWithPose = 8,
 	EVRSubmitFlags_Submit_TextureWithDepth = 16,
 	EVRSubmitFlags_Submit_FrameDiscontinuty = 32,
+	EVRSubmitFlags_Submit_VulkanTextureWithArrayData = 64,
 } EVRSubmitFlags;
 
 typedef enum EVRState
@@ -1666,6 +1713,35 @@ typedef enum EVRDebugError
 	EVRDebugError_VRDebugError_BadParameter = 1,
 } EVRDebugError;
 
+typedef enum EPropertyWriteType
+{
+	EPropertyWriteType_PropertyWrite_Set = 0,
+	EPropertyWriteType_PropertyWrite_Erase = 1,
+	EPropertyWriteType_PropertyWrite_SetError = 2,
+} EPropertyWriteType;
+
+typedef enum EBlockQueueError
+{
+	EBlockQueueError_BlockQueueError_None = 0,
+	EBlockQueueError_BlockQueueError_QueueAlreadyExists = 1,
+	EBlockQueueError_BlockQueueError_QueueNotFound = 2,
+	EBlockQueueError_BlockQueueError_BlockNotAvailable = 3,
+	EBlockQueueError_BlockQueueError_InvalidHandle = 4,
+	EBlockQueueError_BlockQueueError_InvalidParam = 5,
+	EBlockQueueError_BlockQueueError_ParamMismatch = 6,
+	EBlockQueueError_BlockQueueError_InternalError = 7,
+	EBlockQueueError_BlockQueueError_AlreadyInitialized = 8,
+	EBlockQueueError_BlockQueueError_OperationIsServerOnly = 9,
+	EBlockQueueError_BlockQueueError_TooManyConnections = 10,
+} EBlockQueueError;
+
+typedef enum EBlockQueueReadType
+{
+	EBlockQueueReadType_BlockQueueRead_Latest = 0,
+	EBlockQueueReadType_BlockQueueRead_New = 1,
+	EBlockQueueReadType_BlockQueueRead_Next = 2,
+} EBlockQueueReadType;
+
 
 // OpenVR typedefs
 
@@ -1711,6 +1787,7 @@ typedef EVROverlayError VROverlayError;
 typedef EVRFirmwareError VRFirmwareError;
 typedef EVRCompositorError VRCompositorError;
 typedef EVRScreenshotError VRScreenshotsError;
+typedef uint64_t PathHandle_t;
 
 // OpenVR Structs
 
@@ -1852,6 +1929,12 @@ typedef struct VRVulkanTextureData_t
 	uint32_t m_nSampleCount;
 } VRVulkanTextureData_t;
 
+typedef struct VRVulkanTextureArrayData_t
+{
+	uint32_t m_unArrayIndex;
+	uint32_t m_unArraySize;
+} VRVulkanTextureArrayData_t;
+
 typedef struct D3D12TextureData_t
 {
 	struct ID3D12Resource * m_pResource; // struct ID3D12Resource *
@@ -2380,6 +2463,55 @@ typedef struct COpenVRContext
 	intptr_t m_pVRNotifications; // class vr::IVRNotifications *
 } COpenVRContext;
 
+typedef struct PropertyWrite_t
+{
+	enum ETrackedDeviceProperty prop;
+	enum EPropertyWriteType writeType;
+	enum ETrackedPropertyError eSetError;
+	void * pvBuffer; // void *
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	enum ETrackedPropertyError eError;
+} PropertyWrite_t;
+
+typedef struct PropertyRead_t
+{
+	enum ETrackedDeviceProperty prop;
+	void * pvBuffer; // void *
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	uint32_t unRequiredBufferSize;
+	enum ETrackedPropertyError eError;
+} PropertyRead_t;
+
+typedef struct CVRPropertyHelpers
+{
+	intptr_t m_pProperties; // class vr::IVRProperties *
+} CVRPropertyHelpers;
+
+typedef struct PathWrite_t
+{
+	PathHandle_t ulPath;
+	enum EPropertyWriteType writeType;
+	enum ETrackedPropertyError eSetError;
+	void * pvBuffer; // void *
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	enum ETrackedPropertyError eError;
+	char * pszPath; // const char *
+} PathWrite_t;
+
+typedef struct PathRead_t
+{
+	PathHandle_t ulPath;
+	void * pvBuffer; // void *
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	uint32_t unRequiredBufferSize;
+	enum ETrackedPropertyError eError;
+	char * pszPath; // const char *
+} PathRead_t;
+
 
 typedef union
 {
@@ -2881,6 +3013,35 @@ struct VR_IVRDebug_FnTable
 	uint32_t (OPENVR_FNTABLE_CALLTYPE *DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
 };
 
+struct VR_IVRProperties_FnTable
+{
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *ReadPropertyBatch)(PropertyContainerHandle_t ulContainerHandle, struct PropertyRead_t * pBatch, uint32_t unBatchEntryCount);
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *WritePropertyBatch)(PropertyContainerHandle_t ulContainerHandle, struct PropertyWrite_t * pBatch, uint32_t unBatchEntryCount);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetPropErrorNameFromEnum)(ETrackedPropertyError error);
+	PropertyContainerHandle_t (OPENVR_FNTABLE_CALLTYPE *TrackedDeviceToPropertyContainer)(TrackedDeviceIndex_t nDevice);
+};
+
+struct VR_IVRPaths_FnTable
+{
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *ReadPathBatch)(PropertyContainerHandle_t ulRootHandle, struct PathRead_t * pBatch, uint32_t unBatchEntryCount);
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *WritePathBatch)(PropertyContainerHandle_t ulRootHandle, struct PathWrite_t * pBatch, uint32_t unBatchEntryCount);
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *StringToHandle)(PathHandle_t * pHandle, char * pchPath);
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *HandleToString)(PathHandle_t pHandle, char * pchBuffer, uint32_t unBufferSize, uint32_t * punBufferSizeUsed);
+};
+
+struct VR_IVRBlockQueue_FnTable
+{
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *Create)(PropertyContainerHandle_t * pulQueueHandle, char * pchPath, uint32_t unBlockDataSize, uint32_t unBlockHeaderSize, uint32_t unBlockCount);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *Connect)(PropertyContainerHandle_t * pulQueueHandle, char * pchPath);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *Destroy)(PropertyContainerHandle_t ulQueueHandle);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *AcquireWriteOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t * pulBlockHandle, void ** ppvBuffer);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *ReleaseWriteOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t ulBlockHandle);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *WaitAndAcquireReadOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t * pulBlockHandle, void ** ppvBuffer, EBlockQueueReadType eReadType, uint32_t unTimeoutMs);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *AcquireReadOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t * pulBlockHandle, void ** ppvBuffer, EBlockQueueReadType eReadType);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *ReleaseReadOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t ulBlockHandle);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *QueueHasReader)(PropertyContainerHandle_t ulQueueHandle, bool * pbHasReaders);
+};
+
 
 #if 0
 // Global entry points
diff --git a/headers/openvr_driver.h b/headers/openvr_driver.h
index 8982f46..00d1346 100644
--- a/headers/openvr_driver.h
+++ b/headers/openvr_driver.h
@@ -15,8 +15,8 @@
 namespace vr
 {
 	static const uint32_t k_nSteamVRVersionMajor = 1;
-	static const uint32_t k_nSteamVRVersionMinor = 11;
-	static const uint32_t k_nSteamVRVersionBuild = 11;
+	static const uint32_t k_nSteamVRVersionMinor = 12;
+	static const uint32_t k_nSteamVRVersionBuild = 5;
 } // namespace vr
 
 // vrtypes.h
@@ -634,6 +634,9 @@ enum EVRSubmitFlags
 	// Set to indicate a discontinuity between this and the last frame.
 	// This will prevent motion smoothing from attempting to extrapolate using the pair.
 	Submit_FrameDiscontinuty = 0x20,
+
+	// Set to indicate that pTexture->handle is a contains VRVulkanTextureArrayData_t
+	Submit_VulkanTextureWithArrayData = 0x40,
 };
 
 /** Data required for passing Vulkan textures to IVRCompositor::Submit.
@@ -650,6 +653,15 @@ struct VRVulkanTextureData_t
 	uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
 };
 
+/** Data required for passing Vulkan texture arrays to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. 
+* Please see https://github.com/ValveSoftware/openvr/wiki/Vulkan for Vulkan-specific documentation */
+struct VRVulkanTextureArrayData_t : public VRVulkanTextureData_t
+{
+	uint32_t m_unArrayIndex;
+	uint32_t m_unArraySize;
+};
+
 /** Data required for passing D3D12 textures to IVRCompositor::Submit.
 * Be sure to call OpenVR_Shutdown before destroying these resources. */
 struct D3D12TextureData_t
@@ -2282,6 +2294,8 @@ namespace vr
 	static const char * const k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
 	static const char * const k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
 	static const char * const k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+	static const char * const k_pch_SteamVR_BlockOculusSDKOnOpenVRLaunchOption_Bool = "blockOculusSDKOnOpenVRLaunchOption";
+	static const char * const k_pch_SteamVR_BlockOculusSDKOnAllLaunches_Bool = "blockOculusSDKOnAllLaunches";
 
 	//-----------------------------------------------------------------------------
 	// direct mode keys
@@ -2460,6 +2474,7 @@ namespace vr
 	static const char* const k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
 	static const char* const k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
 	static const char* const k_pch_App_DominantHand_Int32 = "DominantHand";
+	static const char* const k_pch_App_BlockOculusSDK_Bool = "blockOculusSDK";
 
 	//-----------------------------------------------------------------------------
 	// configuration for trackers
diff --git a/lib/linux32/libopenvr_api.so b/lib/linux32/libopenvr_api.so
index 50851bc..0a7a9ec 100755
--- a/lib/linux32/libopenvr_api.so
+++ b/lib/linux32/libopenvr_api.so
diff --git a/lib/linux64/libopenvr_api.so b/lib/linux64/libopenvr_api.so
index 84adf34..77b3b73 100755
--- a/lib/linux64/libopenvr_api.so
+++ b/lib/linux64/libopenvr_api.so
diff --git a/lib/win32/openvr_api.lib b/lib/win32/openvr_api.lib
index ae1721f..b61a5a0 100644
--- a/lib/win32/openvr_api.lib
+++ b/lib/win32/openvr_api.lib
diff --git a/lib/win64/openvr_api.lib b/lib/win64/openvr_api.lib
index 60c1c01..3b95d6b 100644
--- a/lib/win64/openvr_api.lib
+++ b/lib/win64/openvr_api.lib
diff --git a/samples/bin/linux32/libopenvr_api.so b/samples/bin/linux32/libopenvr_api.so
index c4fa5ad..a7883e8 100644
--- a/samples/bin/linux32/libopenvr_api.so
+++ b/samples/bin/linux32/libopenvr_api.so
diff --git a/samples/bin/linux64/libopenvr_api.so b/samples/bin/linux64/libopenvr_api.so
index 05df827..1e9a1eb 100644
--- a/samples/bin/linux64/libopenvr_api.so
+++ b/samples/bin/linux64/libopenvr_api.so
diff --git a/samples/bin/win32/openvr_api.dll b/samples/bin/win32/openvr_api.dll
index b09c549..5d33527 100644
--- a/samples/bin/win32/openvr_api.dll
+++ b/samples/bin/win32/openvr_api.dll
diff --git a/samples/bin/win64/openvr_api.dll b/samples/bin/win64/openvr_api.dll
index ab3d881..6b0c8fe 100644
--- a/samples/bin/win64/openvr_api.dll
+++ b/samples/bin/win64/openvr_api.dll
diff --git a/src/vrcommon/pathtools_public.cpp b/src/vrcommon/pathtools_public.cpp
index eb1373a..78d01af 100644
--- a/src/vrcommon/pathtools_public.cpp
+++ b/src/vrcommon/pathtools_public.cpp
@@ -591,6 +591,41 @@ std::string Path_FindParentSubDirectoryRecursively( const std::string &strStartD
 //-----------------------------------------------------------------------------
 // Purpose: reading and writing files in the vortex directory
 //-----------------------------------------------------------------------------
+std::vector<uint8_t> Path_ReadBinaryFile( const std::string & strFilename )
+{
+	FILE *f;
+#if defined( POSIX )
+	f = fopen( strFilename.c_str(), "rb" );
+#else
+	std::wstring wstrFilename = UTF8to16( strFilename.c_str() );
+	// the open operation needs to be sharable, therefore use of _wfsopen instead of _wfopen_s
+	f = _wfsopen( wstrFilename.c_str(), L"rb", _SH_DENYNO );
+#endif
+
+	std::vector<uint8_t> vecFileContents;
+
+	if ( f != NULL )
+	{
+		fseek( f, 0, SEEK_END );
+		int size = ftell( f );
+		fseek( f, 0, SEEK_SET );
+
+		vecFileContents.resize( size );
+		if ( fread( &vecFileContents[ 0 ], size, 1, f ) == 1 )
+		{
+		}
+		else
+		{
+			vecFileContents.clear();
+		}
+
+		fclose( f );
+	}
+
+	return vecFileContents ;
+}
+
+
 unsigned char * Path_ReadBinaryFile( const std::string &strFilename, int *pSize )
 {
 	FILE *f;
diff --git a/src/vrcommon/pathtools_public.h b/src/vrcommon/pathtools_public.h
index 9a120f4..f6a2be2 100644
--- a/src/vrcommon/pathtools_public.h
+++ b/src/vrcommon/pathtools_public.h
@@ -2,6 +2,7 @@
 #pragma once
 
 #include <string>
+#include <vector>
 #include <stdint.h>
 
 /** Returns the path (including filename) to the current executable */
@@ -93,6 +94,7 @@ bool Path_MakeWritable( const std::string &strFilename );
 /** Path operations to read or write text/binary files */
 unsigned char * Path_ReadBinaryFile( const std::string &strFilename, int *pSize );
 uint32_t  Path_ReadBinaryFile( const std::string &strFilename, unsigned char *pBuffer, uint32_t unSize );
+std::vector<uint8_t> Path_ReadBinaryFile( const std::string & strFilename );
 bool Path_WriteBinaryFile( const std::string &strFilename, unsigned char *pData, unsigned nSize );
 std::string Path_ReadTextFile( const std::string &strFilename );
 bool Path_WriteStringToTextFile( const std::string &strFilename, const char *pchData );