From d07a2d5adcc30a36c53aeebb096af80cc40c5024 Mon Sep 17 00:00:00 2001 From: jrhodnik Date: Thu, 23 May 2019 22:06:17 -0400 Subject: [PATCH] First commit, before I switch away from AcquireNextFrame --- .gitignore | 338 ++ VDash.sln | 31 + VDash/App.config | 6 + VDash/App.xaml | 9 + VDash/App.xaml.cs | 17 + VDash/MainWindow.xaml | 15 + VDash/MainWindow.xaml.cs | 50 + VDash/OpenVR/openvr_api.cs | 6487 ++++++++++++++++++++++++ VDash/Overlay/DashOverlay.cs | 34 + VDash/Overlay/WindowOverlay.cs | 254 + VDash/Properties/AssemblyInfo.cs | 55 + VDash/Properties/Resources.Designer.cs | 71 + VDash/Properties/Resources.resx | 117 + VDash/Properties/Settings.Designer.cs | 30 + VDash/Properties/Settings.settings | 7 + VDash/ScreenStateLogger.cs | 138 + VDash/VDash.csproj | 138 + VDash/openvr_api.dll | Bin 0 -> 598816 bytes VDash/packages.config | 6 + 19 files changed, 7803 insertions(+) create mode 100644 .gitignore create mode 100644 VDash.sln create mode 100644 VDash/App.config create mode 100644 VDash/App.xaml create mode 100644 VDash/App.xaml.cs create mode 100644 VDash/MainWindow.xaml create mode 100644 VDash/MainWindow.xaml.cs create mode 100644 VDash/OpenVR/openvr_api.cs create mode 100644 VDash/Overlay/DashOverlay.cs create mode 100644 VDash/Overlay/WindowOverlay.cs create mode 100644 VDash/Properties/AssemblyInfo.cs create mode 100644 VDash/Properties/Resources.Designer.cs create mode 100644 VDash/Properties/Resources.resx create mode 100644 VDash/Properties/Settings.Designer.cs create mode 100644 VDash/Properties/Settings.settings create mode 100644 VDash/ScreenStateLogger.cs create mode 100644 VDash/VDash.csproj create mode 100644 VDash/openvr_api.dll create mode 100644 VDash/packages.config diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4ba92b0 --- /dev/null +++ b/.gitignore @@ -0,0 +1,338 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUNIT +*.VisualState.xml +TestResult.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ +# ASP.NET Core default setup: bower directory is configured as wwwroot/lib/ and bower restore is true +**/wwwroot/lib/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# JetBrains Rider +.idea/ +*.sln.iml + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ diff --git a/VDash.sln b/VDash.sln new file mode 100644 index 0000000..f1f037d --- /dev/null +++ b/VDash.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.28010.2019 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VDash", "VDash\VDash.csproj", "{C12CDA63-DDBB-427B-B66A-72FA42291B04}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C12CDA63-DDBB-427B-B66A-72FA42291B04}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C12CDA63-DDBB-427B-B66A-72FA42291B04}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C12CDA63-DDBB-427B-B66A-72FA42291B04}.Debug|x64.ActiveCfg = Debug|x64 + {C12CDA63-DDBB-427B-B66A-72FA42291B04}.Debug|x64.Build.0 = Debug|x64 + {C12CDA63-DDBB-427B-B66A-72FA42291B04}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C12CDA63-DDBB-427B-B66A-72FA42291B04}.Release|Any CPU.Build.0 = Release|Any CPU + {C12CDA63-DDBB-427B-B66A-72FA42291B04}.Release|x64.ActiveCfg = Release|x64 + {C12CDA63-DDBB-427B-B66A-72FA42291B04}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {BEAB4AD2-8C81-44E3-B498-655CC3039D29} + EndGlobalSection +EndGlobal diff --git a/VDash/App.config b/VDash/App.config new file mode 100644 index 0000000..8e15646 --- /dev/null +++ b/VDash/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/VDash/App.xaml b/VDash/App.xaml new file mode 100644 index 0000000..5aed587 --- /dev/null +++ b/VDash/App.xaml @@ -0,0 +1,9 @@ + + + + + diff --git a/VDash/App.xaml.cs b/VDash/App.xaml.cs new file mode 100644 index 0000000..43b8922 --- /dev/null +++ b/VDash/App.xaml.cs @@ -0,0 +1,17 @@ +using System; +using System.Collections.Generic; +using System.Configuration; +using System.Data; +using System.Linq; +using System.Threading.Tasks; +using System.Windows; + +namespace VDash +{ + /// + /// Interaction logic for App.xaml + /// + public partial class App : Application + { + } +} diff --git a/VDash/MainWindow.xaml b/VDash/MainWindow.xaml new file mode 100644 index 0000000..9200877 --- /dev/null +++ b/VDash/MainWindow.xaml @@ -0,0 +1,15 @@ + + + + + + + + diff --git a/VDash/MainWindow.xaml.cs b/VDash/MainWindow.xaml.cs new file mode 100644 index 0000000..badb8e8 --- /dev/null +++ b/VDash/MainWindow.xaml.cs @@ -0,0 +1,50 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Data; +using System.Windows.Documents; +using System.Windows.Input; +using System.Windows.Media; +using System.Windows.Media.Imaging; +using System.Windows.Navigation; +using System.Windows.Shapes; +using Valve.VR; + +namespace VDash +{ + /// + /// Interaction logic for MainWindow.xaml + /// + public partial class MainWindow : Window + { + public MainWindow() + { + InitializeComponent(); + + //Connect to VR runtime... + EVRInitError initError = EVRInitError.None; + + var ret = OpenVR.Init(ref initError, EVRApplicationType.VRApplication_Overlay); + + if (initError != EVRInitError.None) + { + throw new Exception($"Error connecting to VR: {initError.ToString()}"); + } + + Overlay.WindowOverlay overlay = new Overlay.WindowOverlay("TestKey", "Window Dash"); + overlay.Create(); + + + //var screenStateLogger = new ScreenStateLogger(); + //screenStateLogger.ScreenRefreshed += (sender, data) => + //{ + // Console.WriteLine("Got screen data!"); + //}; + //screenStateLogger.Start(); + } + } +} diff --git a/VDash/OpenVR/openvr_api.cs b/VDash/OpenVR/openvr_api.cs new file mode 100644 index 0000000..c1e8a20 --- /dev/null +++ b/VDash/OpenVR/openvr_api.cs @@ -0,0 +1,6487 @@ +//======= Copyright (c) Valve Corporation, All rights reserved. =============== +// +// Purpose: This file contains C#/managed code bindings for the OpenVR interfaces +// This file is auto-generated, do not edit it. +// +//============================================================================= + +using System; +using System.Runtime.InteropServices; +using Valve.VR; + +namespace Valve.VR +{ + + [StructLayout(LayoutKind.Sequential)] + public struct IVRSystem + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetRecommendedRenderTargetSize(ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRecommendedRenderTargetSize GetRecommendedRenderTargetSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix44_t _GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetProjectionMatrix GetProjectionMatrix; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetProjectionRaw(EVREye eEye, ref float pfLeft, ref float pfRight, ref float pfTop, ref float pfBottom); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetProjectionRaw GetProjectionRaw; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ComputeDistortion(EVREye eEye, float fU, float fV, ref DistortionCoordinates_t pDistortionCoordinates); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ComputeDistortion ComputeDistortion; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetEyeToHeadTransform(EVREye eEye); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEyeToHeadTransform GetEyeToHeadTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync, ref ulong pulFrameCounter); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTimeSinceLastVsync GetTimeSinceLastVsync; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetD3D9AdapterIndex(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetD3D9AdapterIndex GetD3D9AdapterIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDXGIOutputInfo GetDXGIOutputInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetOutputDevice(ref ulong pnDevice, ETextureType textureType, IntPtr pInstance); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOutputDevice GetOutputDevice; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsDisplayOnDesktop(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsDisplayOnDesktop IsDisplayOnDesktop; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _SetDisplayVisibility(bool bIsVisibleOnDesktop); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDisplayVisibility SetDisplayVisibility; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, [In, Out] TrackedDevicePose_t[] pTrackedDevicePoseArray, uint unTrackedDevicePoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDeviceToAbsoluteTrackingPose GetDeviceToAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ResetSeatedZeroPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ResetSeatedZeroPose ResetSeatedZeroPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSeatedZeroPoseToStandingAbsoluteTrackingPose GetSeatedZeroPoseToStandingAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetRawZeroPoseToStandingAbsoluteTrackingPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRawZeroPoseToStandingAbsoluteTrackingPose GetRawZeroPoseToStandingAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, [In, Out] uint[] punTrackedDeviceIndexArray, uint unTrackedDeviceIndexArrayCount, uint unRelativeToTrackedDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSortedTrackedDeviceIndicesOfClass GetSortedTrackedDeviceIndicesOfClass; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EDeviceActivityLevel _GetTrackedDeviceActivityLevel(uint unDeviceId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceActivityLevel GetTrackedDeviceActivityLevel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ApplyTransform(ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pTrackedDevicePose, ref HmdMatrix34_t pTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ApplyTransform ApplyTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceIndexForControllerRole GetTrackedDeviceIndexForControllerRole; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedControllerRole _GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerRoleForTrackedDeviceIndex GetControllerRoleForTrackedDeviceIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedDeviceClass _GetTrackedDeviceClass(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceClass GetTrackedDeviceClass; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsTrackedDeviceConnected(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsTrackedDeviceConnected IsTrackedDeviceConnected; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetBoolTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoolTrackedDeviceProperty GetBoolTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFloatTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFloatTrackedDeviceProperty GetFloatTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetInt32TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInt32TrackedDeviceProperty GetInt32TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetUint64TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetUint64TrackedDeviceProperty GetUint64TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetMatrix34TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMatrix34TrackedDeviceProperty GetMatrix34TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetArrayTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, uint propType, IntPtr pBuffer, uint unBufferSize, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetArrayTrackedDeviceProperty GetArrayTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetStringTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, System.Text.StringBuilder pchValue, uint unBufferSize, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetStringTrackedDeviceProperty GetStringTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetPropErrorNameFromEnum(ETrackedPropertyError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPropErrorNameFromEnum GetPropErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEvent(ref VREvent_t pEvent, uint uncbVREvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextEvent PollNextEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, ref VREvent_t pEvent, uint uncbVREvent, ref TrackedDevicePose_t pTrackedDevicePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextEventWithPose PollNextEventWithPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetEventTypeNameFromEnum(EVREventType eType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEventTypeNameFromEnum GetEventTypeNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HiddenAreaMesh_t _GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHiddenAreaMesh GetHiddenAreaMesh; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerState(uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerState GetControllerState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerStateWithPose GetControllerStateWithPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _TriggerHapticPulse(uint unControllerDeviceIndex, uint unAxisId, ushort usDurationMicroSec); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TriggerHapticPulse TriggerHapticPulse; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetButtonIdNameFromEnum(EVRButtonId eButtonId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetButtonIdNameFromEnum GetButtonIdNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerAxisTypeNameFromEnum GetControllerAxisTypeNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsInputAvailable(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsInputAvailable IsInputAvailable; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsSteamVRDrawingControllers(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsSteamVRDrawingControllers IsSteamVRDrawingControllers; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldApplicationPause(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldApplicationPause ShouldApplicationPause; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldApplicationReduceRenderingWork(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldApplicationReduceRenderingWork ShouldApplicationReduceRenderingWork; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _DriverDebugRequest(uint unDeviceIndex, string pchRequest, System.Text.StringBuilder pchResponseBuffer, uint unResponseBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DriverDebugRequest DriverDebugRequest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRFirmwareError _PerformFirmwareUpdate(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PerformFirmwareUpdate PerformFirmwareUpdate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _AcknowledgeQuit_Exiting(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcknowledgeQuit_Exiting AcknowledgeQuit_Exiting; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _AcknowledgeQuit_UserPrompt(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcknowledgeQuit_UserPrompt AcknowledgeQuit_UserPrompt; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRExtendedDisplay + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetWindowBounds(ref int pnX, ref int pnY, ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWindowBounds GetWindowBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetEyeOutputViewport(EVREye eEye, ref uint pnX, ref uint pnY, ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEyeOutputViewport GetEyeOutputViewport; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex, ref int pnAdapterOutputIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDXGIOutputInfo GetDXGIOutputInfo; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRTrackedCamera + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetCameraErrorNameFromEnum(EVRTrackedCameraError eCameraError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraErrorNameFromEnum GetCameraErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _HasCamera(uint nDeviceIndex, ref bool pHasCamera); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HasCamera HasCamera; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetCameraFrameSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref uint pnWidth, ref uint pnHeight, ref uint pnFrameBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraFrameSize GetCameraFrameSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetCameraIntrinsics(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, ref HmdVector2_t pFocalLength, ref HmdVector2_t pCenter); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraIntrinsics GetCameraIntrinsics; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetCameraProjection(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, ref HmdMatrix44_t pProjection); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraProjection GetCameraProjection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _AcquireVideoStreamingService(uint nDeviceIndex, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcquireVideoStreamingService AcquireVideoStreamingService; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _ReleaseVideoStreamingService(ulong hTrackedCamera); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseVideoStreamingService ReleaseVideoStreamingService; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetVideoStreamFrameBuffer(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pFrameBuffer, uint nFrameBufferSize, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVideoStreamFrameBuffer GetVideoStreamFrameBuffer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetVideoStreamTextureSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref VRTextureBounds_t pTextureBounds, ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVideoStreamTextureSize GetVideoStreamTextureSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetVideoStreamTextureD3D11(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVideoStreamTextureD3D11 GetVideoStreamTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetVideoStreamTextureGL(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, ref uint pglTextureId, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVideoStreamTextureGL GetVideoStreamTextureGL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _ReleaseVideoStreamTextureGL(ulong hTrackedCamera, uint glTextureId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseVideoStreamTextureGL ReleaseVideoStreamTextureGL; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRApplications + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _AddApplicationManifest(string pchApplicationManifestFullPath, bool bTemporary); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AddApplicationManifest AddApplicationManifest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _RemoveApplicationManifest(string pchApplicationManifestFullPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveApplicationManifest RemoveApplicationManifest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsApplicationInstalled(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsApplicationInstalled IsApplicationInstalled; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationCount GetApplicationCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetApplicationKeyByIndex(uint unApplicationIndex, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationKeyByIndex GetApplicationKeyByIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetApplicationKeyByProcessId(uint unProcessId, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationKeyByProcessId GetApplicationKeyByProcessId; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchApplication(string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchTemplateApplication LaunchTemplateApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchApplicationFromMimeType(string pchMimeType, string pchArgs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchApplicationFromMimeType LaunchApplicationFromMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchDashboardOverlay(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchDashboardOverlay LaunchDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CancelApplicationLaunch(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CancelApplicationLaunch CancelApplicationLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _IdentifyApplication(uint unProcessId, string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IdentifyApplication IdentifyApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationProcessId(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationProcessId GetApplicationProcessId; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetApplicationsErrorNameFromEnum(EVRApplicationError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsErrorNameFromEnum GetApplicationsErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationPropertyString(string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyBool GetApplicationPropertyBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetApplicationPropertyUint64(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyUint64 GetApplicationPropertyUint64; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _SetApplicationAutoLaunch(string pchAppKey, bool bAutoLaunch); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetApplicationAutoLaunch SetApplicationAutoLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationAutoLaunch(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationAutoLaunch GetApplicationAutoLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _SetDefaultApplicationForMimeType(string pchAppKey, string pchMimeType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDefaultApplicationForMimeType SetDefaultApplicationForMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetDefaultApplicationForMimeType(string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationSupportedMimeTypes GetApplicationSupportedMimeTypes; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationsThatSupportMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsThatSupportMimeType GetApplicationsThatSupportMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationLaunchArguments(uint unHandle, System.Text.StringBuilder pchArgs, uint unArgs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationLaunchArguments GetApplicationLaunchArguments; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetStartingApplication GetStartingApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationTransitionState _GetTransitionState(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTransitionState GetTransitionState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _PerformApplicationPrelaunchCheck(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PerformApplicationPrelaunchCheck PerformApplicationPrelaunchCheck; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsTransitionStateNameFromEnum GetApplicationsTransitionStateNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsQuitUserPromptRequested(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsQuitUserPromptRequested IsQuitUserPromptRequested; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchInternalProcess(string pchBinaryPath, string pchArguments, string pchWorkingDirectory); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchInternalProcess LaunchInternalProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetCurrentSceneProcessId(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentSceneProcessId GetCurrentSceneProcessId; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRChaperone + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ChaperoneCalibrationState _GetCalibrationState(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCalibrationState GetCalibrationState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetPlayAreaSize(ref float pSizeX, ref float pSizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPlayAreaSize GetPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetPlayAreaRect(ref HmdQuad_t rect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPlayAreaRect GetPlayAreaRect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReloadInfo(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReloadInfo ReloadInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetSceneColor(HmdColor_t color); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetSceneColor SetSceneColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetBoundsColor(ref HmdColor_t pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, ref HmdColor_t pOutputCameraColor); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoundsColor GetBoundsColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _AreBoundsVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AreBoundsVisible AreBoundsVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceBoundsVisible(bool bForce); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceBoundsVisible ForceBoundsVisible; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRChaperoneSetup + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CommitWorkingCopy(EChaperoneConfigFile configFile); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CommitWorkingCopy CommitWorkingCopy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RevertWorkingCopy(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RevertWorkingCopy RevertWorkingCopy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingPlayAreaSize(ref float pSizeX, ref float pSizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingPlayAreaSize GetWorkingPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingPlayAreaRect(ref HmdQuad_t rect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingPlayAreaRect GetWorkingPlayAreaRect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingCollisionBoundsInfo GetWorkingCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetLiveCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLiveCollisionBoundsInfo GetLiveCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingSeatedZeroPoseToRawTrackingPose GetWorkingSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingStandingZeroPoseToRawTrackingPose GetWorkingStandingZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingPlayAreaSize(float sizeX, float sizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingPlayAreaSize SetWorkingPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, uint unQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingCollisionBoundsInfo SetWorkingCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingPerimeter([In, Out] HmdVector2_t[] pPointBuffer, uint unPointCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingPerimeter SetWorkingPerimeter; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingSeatedZeroPoseToRawTrackingPose SetWorkingSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingStandingZeroPoseToRawTrackingPose SetWorkingStandingZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReloadFromDisk(EChaperoneConfigFile configFile); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReloadFromDisk ReloadFromDisk; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLiveSeatedZeroPoseToRawTrackingPose GetLiveSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ExportLiveToBuffer(System.Text.StringBuilder pBuffer, ref uint pnBufferLength); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ExportLiveToBuffer ExportLiveToBuffer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ImportFromBufferToWorking(string pBuffer, uint nImportFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ImportFromBufferToWorking ImportFromBufferToWorking; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowWorkingSetPreview(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowWorkingSetPreview ShowWorkingSetPreview; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideWorkingSetPreview(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideWorkingSetPreview HideWorkingSetPreview; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRCompositor + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetTrackingSpace(ETrackingUniverseOrigin eOrigin); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetTrackingSpace SetTrackingSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackingUniverseOrigin _GetTrackingSpace(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackingSpace GetTrackingSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _WaitGetPoses([In, Out] TrackedDevicePose_t[] pRenderPoseArray, uint unRenderPoseArrayCount, [In, Out] TrackedDevicePose_t[] pGamePoseArray, uint unGamePoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _WaitGetPoses WaitGetPoses; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetLastPoses([In, Out] TrackedDevicePose_t[] pRenderPoseArray, uint unRenderPoseArrayCount, [In, Out] TrackedDevicePose_t[] pGamePoseArray, uint unGamePoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastPoses GetLastPoses; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetLastPoseForTrackedDeviceIndex(uint unDeviceIndex, ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pOutputGamePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastPoseForTrackedDeviceIndex GetLastPoseForTrackedDeviceIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _Submit(EVREye eEye, ref Texture_t pTexture, ref VRTextureBounds_t pBounds, EVRSubmitFlags nSubmitFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Submit Submit; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ClearLastSubmittedFrame(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearLastSubmittedFrame ClearLastSubmittedFrame; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _PostPresentHandoff(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PostPresentHandoff PostPresentHandoff; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetFrameTiming(ref Compositor_FrameTiming pTiming, uint unFramesAgo); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFrameTiming GetFrameTiming; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetFrameTimings([In, Out] Compositor_FrameTiming[] pTiming, uint nFrames); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFrameTimings GetFrameTimings; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFrameTimeRemaining(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFrameTimeRemaining GetFrameTimeRemaining; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetCumulativeStats(ref Compositor_CumulativeStats pStats, uint nStatsSizeInBytes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCumulativeStats GetCumulativeStats; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FadeToColor FadeToColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdColor_t _GetCurrentFadeColor(bool bBackground); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentFadeColor GetCurrentFadeColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FadeGrid(float fSeconds, bool bFadeIn); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FadeGrid FadeGrid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetCurrentGridAlpha(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentGridAlpha GetCurrentGridAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SetSkyboxOverride([In, Out] Texture_t[] pTextures, uint unTextureCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetSkyboxOverride SetSkyboxOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ClearSkyboxOverride(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearSkyboxOverride ClearSkyboxOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorBringToFront(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorBringToFront CompositorBringToFront; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorGoToBack(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorGoToBack CompositorGoToBack; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorQuit(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorQuit CompositorQuit; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsFullscreen(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsFullscreen IsFullscreen; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetCurrentSceneFocusProcess(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentSceneFocusProcess GetCurrentSceneFocusProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetLastFrameRenderer(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastFrameRenderer GetLastFrameRenderer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CanRenderScene(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CanRenderScene CanRenderScene; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowMirrorWindow(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMirrorWindow ShowMirrorWindow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideMirrorWindow(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideMirrorWindow HideMirrorWindow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMirrorWindowVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMirrorWindowVisible IsMirrorWindowVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorDumpImages(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorDumpImages CompositorDumpImages; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldAppRenderWithLowResources(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldAppRenderWithLowResources ShouldAppRenderWithLowResources; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceInterleavedReprojectionOn(bool bOverride); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceInterleavedReprojectionOn ForceInterleavedReprojectionOn; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceReconnectProcess(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceReconnectProcess ForceReconnectProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SuspendRendering(bool bSuspend); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SuspendRendering SuspendRendering; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetMirrorTextureD3D11(EVREye eEye, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMirrorTextureD3D11 GetMirrorTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseMirrorTextureD3D11 ReleaseMirrorTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetMirrorTextureGL(EVREye eEye, ref uint pglTextureId, IntPtr pglSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMirrorTextureGL GetMirrorTextureGL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ReleaseSharedGLTexture(uint glTextureId, IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseSharedGLTexture ReleaseSharedGLTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LockGLSharedTextureForAccess LockGLSharedTextureForAccess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UnlockGLSharedTextureForAccess UnlockGLSharedTextureForAccess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanInstanceExtensionsRequired GetVulkanInstanceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanDeviceExtensionsRequired GetVulkanDeviceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetExplicitTimingMode SetExplicitTimingMode; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SubmitExplicitTimingData(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SubmitExplicitTimingData SubmitExplicitTimingData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMotionSmoothingEnabled(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMotionSmoothingEnabled IsMotionSmoothingEnabled; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVROverlay + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _FindOverlay(string pchOverlayKey, ref ulong pOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FindOverlay FindOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _CreateOverlay(string pchOverlayKey, string pchOverlayName, ref ulong pOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateOverlay CreateOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _DestroyOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DestroyOverlay DestroyOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetHighQualityOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetHighQualityOverlay SetHighQualityOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetHighQualityOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHighQualityOverlay GetHighQualityOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayKey(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayKey GetOverlayKey; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayName(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayName GetOverlayName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayName(ulong ulOverlayHandle, string pchName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayName SetOverlayName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayImageData(ulong ulOverlayHandle, IntPtr pvBuffer, uint unBufferSize, ref uint punWidth, ref uint punHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayImageData GetOverlayImageData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetOverlayErrorNameFromEnum(EVROverlayError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayErrorNameFromEnum GetOverlayErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRenderingPid(ulong ulOverlayHandle, uint unPID); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRenderingPid SetOverlayRenderingPid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayRenderingPid(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayRenderingPid GetOverlayRenderingPid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayFlag SetOverlayFlag; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, ref bool pbEnabled); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlag GetOverlayFlag; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayColor(ulong ulOverlayHandle, float fRed, float fGreen, float fBlue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayColor SetOverlayColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayColor(ulong ulOverlayHandle, ref float pfRed, ref float pfGreen, ref float pfBlue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayColor GetOverlayColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayAlpha(ulong ulOverlayHandle, float fAlpha); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayAlpha SetOverlayAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayAlpha(ulong ulOverlayHandle, ref float pfAlpha); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayAlpha GetOverlayAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTexelAspect(ulong ulOverlayHandle, float fTexelAspect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTexelAspect SetOverlayTexelAspect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTexelAspect(ulong ulOverlayHandle, ref float pfTexelAspect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTexelAspect GetOverlayTexelAspect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlaySortOrder(ulong ulOverlayHandle, uint unSortOrder); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlaySortOrder SetOverlaySortOrder; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlaySortOrder(ulong ulOverlayHandle, ref uint punSortOrder); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlaySortOrder GetOverlaySortOrder; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayWidthInMeters(ulong ulOverlayHandle, float fWidthInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayWidthInMeters SetOverlayWidthInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayWidthInMeters(ulong ulOverlayHandle, ref float pfWidthInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayWidthInMeters GetOverlayWidthInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayAutoCurveDistanceRangeInMeters SetOverlayAutoCurveDistanceRangeInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, ref float pfMinDistanceInMeters, ref float pfMaxDistanceInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayAutoCurveDistanceRangeInMeters GetOverlayAutoCurveDistanceRangeInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTextureColorSpace(ulong ulOverlayHandle, EColorSpace eTextureColorSpace); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTextureColorSpace SetOverlayTextureColorSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureColorSpace(ulong ulOverlayHandle, ref EColorSpace peTextureColorSpace); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureColorSpace GetOverlayTextureColorSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTextureBounds SetOverlayTextureBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureBounds GetOverlayTextureBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayRenderModel(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref HmdColor_t pColor, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayRenderModel GetOverlayRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRenderModel(ulong ulOverlayHandle, string pchRenderModel, ref HmdColor_t pColor); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRenderModel SetOverlayRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformType(ulong ulOverlayHandle, ref VROverlayTransformType peTransformType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformType GetOverlayTransformType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformAbsolute(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformAbsolute SetOverlayTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformAbsolute GetOverlayTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, uint unTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformTrackedDeviceRelative SetOverlayTransformTrackedDeviceRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, ref uint punTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformTrackedDeviceRelative GetOverlayTransformTrackedDeviceRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, string pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformTrackedDeviceComponent SetOverlayTransformTrackedDeviceComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, ref uint punDeviceIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformTrackedDeviceComponent GetOverlayTransformTrackedDeviceComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ref ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformOverlayRelative GetOverlayTransformOverlayRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformOverlayRelative SetOverlayTransformOverlayRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowOverlay ShowOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _HideOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideOverlay HideOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsOverlayVisible(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsOverlayVisible IsOverlayVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTransformForOverlayCoordinates GetTransformForOverlayCoordinates; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pEvent, uint uncbVREvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextOverlayEvent PollNextOverlayEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayInputMethod(ulong ulOverlayHandle, ref VROverlayInputMethod peInputMethod); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayInputMethod GetOverlayInputMethod; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayInputMethod(ulong ulOverlayHandle, VROverlayInputMethod eInputMethod); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayInputMethod SetOverlayInputMethod; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayMouseScale GetOverlayMouseScale; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayMouseScale SetOverlayMouseScale; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ComputeOverlayIntersection(ulong ulOverlayHandle, ref VROverlayIntersectionParams_t pParams, ref VROverlayIntersectionResults_t pResults); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ComputeOverlayIntersection ComputeOverlayIntersection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsHoverTargetOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsHoverTargetOverlay IsHoverTargetOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetGamepadFocusOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetGamepadFocusOverlay GetGamepadFocusOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetGamepadFocusOverlay(ulong ulNewFocusOverlay); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetGamepadFocusOverlay SetGamepadFocusOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayNeighbor(EOverlayDirection eDirection, ulong ulFrom, ulong ulTo); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayNeighbor SetOverlayNeighbor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _MoveGamepadFocusToNeighbor(EOverlayDirection eDirection, ulong ulFrom); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _MoveGamepadFocusToNeighbor MoveGamepadFocusToNeighbor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayDualAnalogTransform(ulong ulOverlay, EDualAnalogWhich eWhich, ref HmdVector2_t pvCenter, float fRadius); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayDualAnalogTransform SetOverlayDualAnalogTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayDualAnalogTransform(ulong ulOverlay, EDualAnalogWhich eWhich, ref HmdVector2_t pvCenter, ref float pfRadius); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayDualAnalogTransform GetOverlayDualAnalogTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTexture(ulong ulOverlayHandle, ref Texture_t pTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTexture SetOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ClearOverlayTexture(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearOverlayTexture ClearOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRaw(ulong ulOverlayHandle, IntPtr pvBuffer, uint unWidth, uint unHeight, uint unDepth); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRaw SetOverlayRaw; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayFromFile(ulong ulOverlayHandle, string pchFilePath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayFromFile SetOverlayFromFile; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref ETextureType pAPIType, ref EColorSpace pColorSpace, ref VRTextureBounds_t pTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTexture GetOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ReleaseNativeOverlayHandle(ulong ulOverlayHandle, IntPtr pNativeTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseNativeOverlayHandle ReleaseNativeOverlayHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureSize(ulong ulOverlayHandle, ref uint pWidth, ref uint pHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureSize GetOverlayTextureSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _CreateDashboardOverlay(string pchOverlayKey, string pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateDashboardOverlay CreateDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsDashboardVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsDashboardVisible IsDashboardVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsActiveDashboardOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsActiveDashboardOverlay IsActiveDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetDashboardOverlaySceneProcess(ulong ulOverlayHandle, uint unProcessId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDashboardOverlaySceneProcess SetDashboardOverlaySceneProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetDashboardOverlaySceneProcess(ulong ulOverlayHandle, ref uint punProcessId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDashboardOverlaySceneProcess GetDashboardOverlaySceneProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowDashboard(string pchOverlayToShow); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowDashboard ShowDashboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetPrimaryDashboardDevice(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPrimaryDashboardDevice GetPrimaryDashboardDevice; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowKeyboard(int eInputMode, int eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText, bool bUseMinimalMode, ulong uUserValue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowKeyboard ShowKeyboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowKeyboardForOverlay(ulong ulOverlayHandle, int eInputMode, int eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText, bool bUseMinimalMode, ulong uUserValue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowKeyboardForOverlay ShowKeyboardForOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetKeyboardText(System.Text.StringBuilder pchText, uint cchText); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetKeyboardText GetKeyboardText; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideKeyboard(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideKeyboard HideKeyboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetKeyboardTransformAbsolute SetKeyboardTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetKeyboardPositionForOverlay(ulong ulOverlayHandle, HmdRect2_t avoidRect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetKeyboardPositionForOverlay SetKeyboardPositionForOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayIntersectionMask(ulong ulOverlayHandle, ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives, uint unNumMaskPrimitives, uint unPrimitiveSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayIntersectionMask SetOverlayIntersectionMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlags(ulong ulOverlayHandle, ref uint pFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlags GetOverlayFlags; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate VRMessageOverlayResponse _ShowMessageOverlay(string pchText, string pchCaption, string pchButton0Text, string pchButton1Text, string pchButton2Text, string pchButton3Text); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMessageOverlay ShowMessageOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CloseMessageOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CloseMessageOverlay CloseMessageOverlay; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRRenderModels + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadRenderModel_Async(string pchRenderModelName, ref IntPtr ppRenderModel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadRenderModel_Async LoadRenderModel_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeRenderModel(IntPtr pRenderModel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeRenderModel FreeRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadTexture_Async(int textureId, ref IntPtr ppTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadTexture_Async LoadTexture_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeTexture(IntPtr pTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeTexture FreeTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadTextureD3D11_Async LoadTextureD3D11_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadIntoTextureD3D11_Async LoadIntoTextureD3D11_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeTextureD3D11(IntPtr pD3D11Texture2D); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeTextureD3D11 FreeTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelName GetRenderModelName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelCount GetRenderModelCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentCount(string pchRenderModelName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentCount GetComponentCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentName(string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentButtonMask GetComponentButtonMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentRenderModelName(string pchRenderModelName, string 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); + [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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentState GetComponentState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _RenderModelHasComponent(string pchRenderModelName, string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelThumbnailURL GetRenderModelThumbnailURL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelOriginalPath(string pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelOriginalPath GetRenderModelOriginalPath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetRenderModelErrorNameFromEnum(EVRRenderModelError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelErrorNameFromEnum GetRenderModelErrorNameFromEnum; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRNotifications + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRNotificationError _CreateNotification(ulong ulOverlayHandle, ulong ulUserValue, EVRNotificationType type, string pchText, EVRNotificationStyle style, ref NotificationBitmap_t pImage, ref uint pNotificationId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateNotification CreateNotification; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRNotificationError _RemoveNotification(uint notificationId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveNotification RemoveNotification; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRSettings + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetSettingsErrorNameFromEnum(EVRSettingsError eError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSettingsErrorNameFromEnum GetSettingsErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _Sync(bool bForce, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Sync Sync; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetBool(string pchSection, string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetInt32 SetInt32; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetFloat(string pchSection, string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetString SetString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetBool(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBool GetBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetInt32(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInt32 GetInt32; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFloat(string pchSection, string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetString GetString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RemoveSection(string pchSection, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveSection RemoveSection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RemoveKeyInSection(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveKeyInSection RemoveKeyInSection; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRScreenshots + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, string pchPreviewFilename, string pchVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RequestScreenshot RequestScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _HookScreenshot([In, Out] EVRScreenshotType[] pSupportedTypes, int numTypes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HookScreenshot HookScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotType _GetScreenshotPropertyType(uint screenshotHandle, ref EVRScreenshotError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetScreenshotPropertyType GetScreenshotPropertyType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetScreenshotPropertyFilename(uint screenshotHandle, EVRScreenshotPropertyFilenames filenameType, System.Text.StringBuilder pchFilename, uint cchFilename, ref EVRScreenshotError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetScreenshotPropertyFilename GetScreenshotPropertyFilename; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _UpdateScreenshotProgress(uint screenshotHandle, float flProgress); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UpdateScreenshotProgress UpdateScreenshotProgress; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _TakeStereoScreenshot(ref uint pOutScreenshotHandle, string pchPreviewFilename, string pchVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TakeStereoScreenshot TakeStereoScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _SubmitScreenshot(uint screenshotHandle, EVRScreenshotType type, string pchSourcePreviewFilename, string pchSourceVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SubmitScreenshot SubmitScreenshot; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRResources + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _LoadSharedResource(string 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); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetResourceFullPath GetResourceFullPath; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRDriverManager + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetDriverCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverCount GetDriverCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetDriverName(uint nDriver, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverName GetDriverName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetDriverHandle(string pchDriverName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverHandle GetDriverHandle; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRInput + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _SetActionManifestPath(string pchActionManifestPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetActionManifestPath SetActionManifestPath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionSetHandle(string pchActionSetName, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionSetHandle GetActionSetHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionHandle(string pchActionName, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionHandle GetActionHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetInputSourceHandle(string pchInputSourcePath, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInputSourceHandle GetInputSourceHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _UpdateActionState([In, Out] VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, uint unSetCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UpdateActionState UpdateActionState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetDigitalActionData(ulong action, ref InputDigitalActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDigitalActionData GetDigitalActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetAnalogActionData(ulong action, ref InputAnalogActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetAnalogActionData GetAnalogActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetPoseActionData(ulong action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, ref InputPoseActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPoseActionData GetPoseActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalActionData(ulong action, ref InputSkeletalActionData_t pActionData, uint unActionDataSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalActionData GetSkeletalActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetBoneCount(ulong action, ref uint pBoneCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoneCount GetBoneCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetBoneHierarchy(ulong action, [In, Out] int[] pParentIndices, uint unIndexArayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoneHierarchy GetBoneHierarchy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetBoneName(ulong action, int nBoneIndex, System.Text.StringBuilder pchBoneName, uint unNameBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoneName GetBoneName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalReferenceTransforms(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalReferenceTransforms GetSkeletalReferenceTransforms; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalTrackingLevel(ulong action, ref EVRSkeletalTrackingLevel pSkeletalTrackingLevel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalTrackingLevel GetSkeletalTrackingLevel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalBoneData(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalBoneData GetSkeletalBoneData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalSummaryData(ulong action, ref VRSkeletalSummaryData_t pSkeletalSummaryData); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalSummaryData GetSkeletalSummaryData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalBoneDataCompressed(ulong action, EVRSkeletalMotionRange eMotionRange, IntPtr pvCompressedData, uint unCompressedSize, ref uint punRequiredCompressedSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalBoneDataCompressed GetSkeletalBoneDataCompressed; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _DecompressSkeletalBoneData(IntPtr pvCompressedBuffer, uint unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DecompressSkeletalBoneData DecompressSkeletalBoneData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _TriggerHapticVibrationAction(ulong action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TriggerHapticVibrationAction TriggerHapticVibrationAction; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionOrigins(ulong actionSetHandle, ulong digitalActionHandle, [In, Out] ulong[] originsOut, uint originOutCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionOrigins GetActionOrigins; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetOriginLocalizedName(ulong origin, System.Text.StringBuilder pchNameArray, uint unNameArraySize, int unStringSectionsToInclude); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOriginLocalizedName GetOriginLocalizedName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetOriginTrackedDeviceInfo(ulong origin, ref InputOriginInfo_t pOriginInfo, uint unOriginInfoSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOriginTrackedDeviceInfo GetOriginTrackedDeviceInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _ShowActionOrigins(ulong actionSetHandle, ulong ulActionHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowActionOrigins ShowActionOrigins; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _ShowBindingsForActionSet([In, Out] VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, uint unSetCount, ulong originToHighlight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowBindingsForActionSet ShowBindingsForActionSet; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsUsingLegacyInput(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsUsingLegacyInput IsUsingLegacyInput; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRIOBuffer + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Open(string pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Open Open; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Close(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Close Close; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Read(ulong ulBuffer, IntPtr pDst, uint unBytes, ref uint punRead); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Read Read; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Write(ulong ulBuffer, IntPtr pSrc, uint unBytes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Write Write; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _PropertyContainer(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PropertyContainer PropertyContainer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _HasReaders(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HasReaders HasReaders; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRSpatialAnchors + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromDescriptor(string pchDescriptor, ref uint pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateSpatialAnchorFromDescriptor CreateSpatialAnchorFromDescriptor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromPose(uint unDeviceIndex, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPose, ref uint pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateSpatialAnchorFromPose CreateSpatialAnchorFromPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _GetSpatialAnchorPose(uint unHandle, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPoseOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSpatialAnchorPose GetSpatialAnchorPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _GetSpatialAnchorDescriptor(uint unHandle, System.Text.StringBuilder pchDescriptorOut, ref uint punDescriptorBufferLenInOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSpatialAnchorDescriptor GetSpatialAnchorDescriptor; + + } + + + public class CVRSystem + { + IVRSystem FnTable; + internal CVRSystem(IntPtr pInterface) + { + FnTable = (IVRSystem)Marshal.PtrToStructure(pInterface, typeof(IVRSystem)); + } + public void GetRecommendedRenderTargetSize(ref uint pnWidth, ref uint pnHeight) + { + pnWidth = 0; + pnHeight = 0; + FnTable.GetRecommendedRenderTargetSize(ref pnWidth, ref pnHeight); + } + public HmdMatrix44_t GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ) + { + HmdMatrix44_t result = FnTable.GetProjectionMatrix(eEye, fNearZ, fFarZ); + return result; + } + public void GetProjectionRaw(EVREye eEye, ref float pfLeft, ref float pfRight, ref float pfTop, ref float pfBottom) + { + pfLeft = 0; + pfRight = 0; + pfTop = 0; + pfBottom = 0; + FnTable.GetProjectionRaw(eEye, ref pfLeft, ref pfRight, ref pfTop, ref pfBottom); + } + public bool ComputeDistortion(EVREye eEye, float fU, float fV, ref DistortionCoordinates_t pDistortionCoordinates) + { + bool result = FnTable.ComputeDistortion(eEye, fU, fV, ref pDistortionCoordinates); + return result; + } + public HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) + { + HmdMatrix34_t result = FnTable.GetEyeToHeadTransform(eEye); + return result; + } + public bool GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync, ref ulong pulFrameCounter) + { + pfSecondsSinceLastVsync = 0; + pulFrameCounter = 0; + bool result = FnTable.GetTimeSinceLastVsync(ref pfSecondsSinceLastVsync, ref pulFrameCounter); + return result; + } + public int GetD3D9AdapterIndex() + { + int result = FnTable.GetD3D9AdapterIndex(); + return result; + } + public void GetDXGIOutputInfo(ref int pnAdapterIndex) + { + pnAdapterIndex = 0; + FnTable.GetDXGIOutputInfo(ref pnAdapterIndex); + } + public void GetOutputDevice(ref ulong pnDevice, ETextureType textureType, IntPtr pInstance) + { + pnDevice = 0; + FnTable.GetOutputDevice(ref pnDevice, textureType, pInstance); + } + public bool IsDisplayOnDesktop() + { + bool result = FnTable.IsDisplayOnDesktop(); + return result; + } + public bool SetDisplayVisibility(bool bIsVisibleOnDesktop) + { + bool result = FnTable.SetDisplayVisibility(bIsVisibleOnDesktop); + return result; + } + public void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t[] pTrackedDevicePoseArray) + { + FnTable.GetDeviceToAbsoluteTrackingPose(eOrigin, fPredictedSecondsToPhotonsFromNow, pTrackedDevicePoseArray, (uint)pTrackedDevicePoseArray.Length); + } + public void ResetSeatedZeroPose() + { + FnTable.ResetSeatedZeroPose(); + } + public HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() + { + HmdMatrix34_t result = FnTable.GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + return result; + } + public HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() + { + HmdMatrix34_t result = FnTable.GetRawZeroPoseToStandingAbsoluteTrackingPose(); + return result; + } + public uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, uint[] punTrackedDeviceIndexArray, uint unRelativeToTrackedDeviceIndex) + { + uint result = FnTable.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass, punTrackedDeviceIndexArray, (uint)punTrackedDeviceIndexArray.Length, unRelativeToTrackedDeviceIndex); + return result; + } + public EDeviceActivityLevel GetTrackedDeviceActivityLevel(uint unDeviceId) + { + EDeviceActivityLevel result = FnTable.GetTrackedDeviceActivityLevel(unDeviceId); + return result; + } + public void ApplyTransform(ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pTrackedDevicePose, ref HmdMatrix34_t pTransform) + { + FnTable.ApplyTransform(ref pOutputPose, ref pTrackedDevicePose, ref pTransform); + } + public uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType) + { + uint result = FnTable.GetTrackedDeviceIndexForControllerRole(unDeviceType); + return result; + } + public ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex) + { + ETrackedControllerRole result = FnTable.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex); + return result; + } + public ETrackedDeviceClass GetTrackedDeviceClass(uint unDeviceIndex) + { + ETrackedDeviceClass result = FnTable.GetTrackedDeviceClass(unDeviceIndex); + return result; + } + public bool IsTrackedDeviceConnected(uint unDeviceIndex) + { + bool result = FnTable.IsTrackedDeviceConnected(unDeviceIndex); + return result; + } + public bool GetBoolTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + bool result = FnTable.GetBoolTrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public float GetFloatTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + float result = FnTable.GetFloatTrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public int GetInt32TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + int result = FnTable.GetInt32TrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public ulong GetUint64TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + ulong result = FnTable.GetUint64TrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public HmdMatrix34_t GetMatrix34TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + HmdMatrix34_t result = FnTable.GetMatrix34TrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public uint GetArrayTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, uint propType, IntPtr pBuffer, uint unBufferSize, ref ETrackedPropertyError pError) + { + uint result = FnTable.GetArrayTrackedDeviceProperty(unDeviceIndex, prop, propType, pBuffer, unBufferSize, ref pError); + return result; + } + public uint GetStringTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, System.Text.StringBuilder pchValue, uint unBufferSize, ref ETrackedPropertyError pError) + { + uint result = FnTable.GetStringTrackedDeviceProperty(unDeviceIndex, prop, pchValue, unBufferSize, ref pError); + return result; + } + public string GetPropErrorNameFromEnum(ETrackedPropertyError error) + { + IntPtr result = FnTable.GetPropErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + // This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were + // originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEventPacked(ref VREvent_t_Packed pEvent, uint uncbVREvent); + [StructLayout(LayoutKind.Explicit)] + struct PollNextEventUnion + { + [FieldOffset(0)] + public IVRSystem._PollNextEvent pPollNextEvent; + [FieldOffset(0)] + public _PollNextEventPacked pPollNextEventPacked; + } + public bool PollNextEvent(ref VREvent_t pEvent, uint uncbVREvent) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + PollNextEventUnion u; + VREvent_t_Packed event_packed = new VREvent_t_Packed(); + u.pPollNextEventPacked = null; + u.pPollNextEvent = FnTable.PollNextEvent; + bool packed_result = u.pPollNextEventPacked(ref event_packed, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed))); + + event_packed.Unpack(ref pEvent); + return packed_result; + } +#endif + bool result = FnTable.PollNextEvent(ref pEvent, uncbVREvent); + return result; + } + public bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, ref VREvent_t pEvent, uint uncbVREvent, ref TrackedDevicePose_t pTrackedDevicePose) + { + bool result = FnTable.PollNextEventWithPose(eOrigin, ref pEvent, uncbVREvent, ref pTrackedDevicePose); + return result; + } + public string GetEventTypeNameFromEnum(EVREventType eType) + { + IntPtr result = FnTable.GetEventTypeNameFromEnum(eType); + return Marshal.PtrToStringAnsi(result); + } + public HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type) + { + HiddenAreaMesh_t result = FnTable.GetHiddenAreaMesh(eEye, type); + return result; + } + // This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were + // originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStatePacked(uint unControllerDeviceIndex, ref VRControllerState_t_Packed pControllerState, uint unControllerStateSize); + [StructLayout(LayoutKind.Explicit)] + struct GetControllerStateUnion + { + [FieldOffset(0)] + public IVRSystem._GetControllerState pGetControllerState; + [FieldOffset(0)] + public _GetControllerStatePacked pGetControllerStatePacked; + } + public bool GetControllerState(uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetControllerStateUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetControllerStatePacked = null; + u.pGetControllerState = FnTable.GetControllerState; + bool packed_result = u.pGetControllerStatePacked(unControllerDeviceIndex, ref state_packed, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed))); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetControllerState(unControllerDeviceIndex, ref pControllerState, unControllerStateSize); + return result; + } + // This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were + // originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStateWithPosePacked(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t_Packed pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose); + [StructLayout(LayoutKind.Explicit)] + struct GetControllerStateWithPoseUnion + { + [FieldOffset(0)] + public IVRSystem._GetControllerStateWithPose pGetControllerStateWithPose; + [FieldOffset(0)] + public _GetControllerStateWithPosePacked pGetControllerStateWithPosePacked; + } + public bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetControllerStateWithPoseUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetControllerStateWithPosePacked = null; + u.pGetControllerStateWithPose = FnTable.GetControllerStateWithPose; + bool packed_result = u.pGetControllerStateWithPosePacked(eOrigin, unControllerDeviceIndex, ref state_packed, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed)), ref pTrackedDevicePose); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetControllerStateWithPose(eOrigin, unControllerDeviceIndex, ref pControllerState, unControllerStateSize, ref pTrackedDevicePose); + return result; + } + public void TriggerHapticPulse(uint unControllerDeviceIndex, uint unAxisId, ushort usDurationMicroSec) + { + FnTable.TriggerHapticPulse(unControllerDeviceIndex, unAxisId, usDurationMicroSec); + } + public string GetButtonIdNameFromEnum(EVRButtonId eButtonId) + { + IntPtr result = FnTable.GetButtonIdNameFromEnum(eButtonId); + return Marshal.PtrToStringAnsi(result); + } + public string GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType) + { + IntPtr result = FnTable.GetControllerAxisTypeNameFromEnum(eAxisType); + return Marshal.PtrToStringAnsi(result); + } + public bool IsInputAvailable() + { + bool result = FnTable.IsInputAvailable(); + return result; + } + public bool IsSteamVRDrawingControllers() + { + bool result = FnTable.IsSteamVRDrawingControllers(); + return result; + } + public bool ShouldApplicationPause() + { + bool result = FnTable.ShouldApplicationPause(); + return result; + } + public bool ShouldApplicationReduceRenderingWork() + { + bool result = FnTable.ShouldApplicationReduceRenderingWork(); + return result; + } + public uint DriverDebugRequest(uint unDeviceIndex, string pchRequest, System.Text.StringBuilder pchResponseBuffer, uint unResponseBufferSize) + { + uint result = FnTable.DriverDebugRequest(unDeviceIndex, pchRequest, pchResponseBuffer, unResponseBufferSize); + return result; + } + public EVRFirmwareError PerformFirmwareUpdate(uint unDeviceIndex) + { + EVRFirmwareError result = FnTable.PerformFirmwareUpdate(unDeviceIndex); + return result; + } + public void AcknowledgeQuit_Exiting() + { + FnTable.AcknowledgeQuit_Exiting(); + } + public void AcknowledgeQuit_UserPrompt() + { + FnTable.AcknowledgeQuit_UserPrompt(); + } + } + + + public class CVRExtendedDisplay + { + IVRExtendedDisplay FnTable; + internal CVRExtendedDisplay(IntPtr pInterface) + { + FnTable = (IVRExtendedDisplay)Marshal.PtrToStructure(pInterface, typeof(IVRExtendedDisplay)); + } + public void GetWindowBounds(ref int pnX, ref int pnY, ref uint pnWidth, ref uint pnHeight) + { + pnX = 0; + pnY = 0; + pnWidth = 0; + pnHeight = 0; + FnTable.GetWindowBounds(ref pnX, ref pnY, ref pnWidth, ref pnHeight); + } + public void GetEyeOutputViewport(EVREye eEye, ref uint pnX, ref uint pnY, ref uint pnWidth, ref uint pnHeight) + { + pnX = 0; + pnY = 0; + pnWidth = 0; + pnHeight = 0; + FnTable.GetEyeOutputViewport(eEye, ref pnX, ref pnY, ref pnWidth, ref pnHeight); + } + public void GetDXGIOutputInfo(ref int pnAdapterIndex, ref int pnAdapterOutputIndex) + { + pnAdapterIndex = 0; + pnAdapterOutputIndex = 0; + FnTable.GetDXGIOutputInfo(ref pnAdapterIndex, ref pnAdapterOutputIndex); + } + } + + + public class CVRTrackedCamera + { + IVRTrackedCamera FnTable; + internal CVRTrackedCamera(IntPtr pInterface) + { + FnTable = (IVRTrackedCamera)Marshal.PtrToStructure(pInterface, typeof(IVRTrackedCamera)); + } + public string GetCameraErrorNameFromEnum(EVRTrackedCameraError eCameraError) + { + IntPtr result = FnTable.GetCameraErrorNameFromEnum(eCameraError); + return Marshal.PtrToStringAnsi(result); + } + public EVRTrackedCameraError HasCamera(uint nDeviceIndex, ref bool pHasCamera) + { + pHasCamera = false; + EVRTrackedCameraError result = FnTable.HasCamera(nDeviceIndex, ref pHasCamera); + return result; + } + public EVRTrackedCameraError GetCameraFrameSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref uint pnWidth, ref uint pnHeight, ref uint pnFrameBufferSize) + { + pnWidth = 0; + pnHeight = 0; + pnFrameBufferSize = 0; + EVRTrackedCameraError result = FnTable.GetCameraFrameSize(nDeviceIndex, eFrameType, ref pnWidth, ref pnHeight, ref pnFrameBufferSize); + return result; + } + public EVRTrackedCameraError GetCameraIntrinsics(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, ref HmdVector2_t pFocalLength, ref HmdVector2_t pCenter) + { + EVRTrackedCameraError result = FnTable.GetCameraIntrinsics(nDeviceIndex, nCameraIndex, eFrameType, ref pFocalLength, ref pCenter); + return result; + } + public EVRTrackedCameraError GetCameraProjection(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, ref HmdMatrix44_t pProjection) + { + EVRTrackedCameraError result = FnTable.GetCameraProjection(nDeviceIndex, nCameraIndex, eFrameType, flZNear, flZFar, ref pProjection); + return result; + } + public EVRTrackedCameraError AcquireVideoStreamingService(uint nDeviceIndex, ref ulong pHandle) + { + pHandle = 0; + EVRTrackedCameraError result = FnTable.AcquireVideoStreamingService(nDeviceIndex, ref pHandle); + return result; + } + public EVRTrackedCameraError ReleaseVideoStreamingService(ulong hTrackedCamera) + { + EVRTrackedCameraError result = FnTable.ReleaseVideoStreamingService(hTrackedCamera); + return result; + } + public EVRTrackedCameraError GetVideoStreamFrameBuffer(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pFrameBuffer, uint nFrameBufferSize, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize) + { + EVRTrackedCameraError result = FnTable.GetVideoStreamFrameBuffer(hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, ref pFrameHeader, nFrameHeaderSize); + return result; + } + public EVRTrackedCameraError GetVideoStreamTextureSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref VRTextureBounds_t pTextureBounds, ref uint pnWidth, ref uint pnHeight) + { + pnWidth = 0; + pnHeight = 0; + EVRTrackedCameraError result = FnTable.GetVideoStreamTextureSize(nDeviceIndex, eFrameType, ref pTextureBounds, ref pnWidth, ref pnHeight); + return result; + } + public EVRTrackedCameraError GetVideoStreamTextureD3D11(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize) + { + EVRTrackedCameraError result = FnTable.GetVideoStreamTextureD3D11(hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ref ppD3D11ShaderResourceView, ref pFrameHeader, nFrameHeaderSize); + return result; + } + public EVRTrackedCameraError GetVideoStreamTextureGL(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, ref uint pglTextureId, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize) + { + pglTextureId = 0; + EVRTrackedCameraError result = FnTable.GetVideoStreamTextureGL(hTrackedCamera, eFrameType, ref pglTextureId, ref pFrameHeader, nFrameHeaderSize); + return result; + } + public EVRTrackedCameraError ReleaseVideoStreamTextureGL(ulong hTrackedCamera, uint glTextureId) + { + EVRTrackedCameraError result = FnTable.ReleaseVideoStreamTextureGL(hTrackedCamera, glTextureId); + return result; + } + } + + + public class CVRApplications + { + IVRApplications FnTable; + internal CVRApplications(IntPtr pInterface) + { + FnTable = (IVRApplications)Marshal.PtrToStructure(pInterface, typeof(IVRApplications)); + } + public EVRApplicationError AddApplicationManifest(string pchApplicationManifestFullPath, bool bTemporary) + { + EVRApplicationError result = FnTable.AddApplicationManifest(pchApplicationManifestFullPath, bTemporary); + return result; + } + public EVRApplicationError RemoveApplicationManifest(string pchApplicationManifestFullPath) + { + EVRApplicationError result = FnTable.RemoveApplicationManifest(pchApplicationManifestFullPath); + return result; + } + public bool IsApplicationInstalled(string pchAppKey) + { + bool result = FnTable.IsApplicationInstalled(pchAppKey); + return result; + } + public uint GetApplicationCount() + { + uint result = FnTable.GetApplicationCount(); + return result; + } + public EVRApplicationError GetApplicationKeyByIndex(uint unApplicationIndex, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetApplicationKeyByIndex(unApplicationIndex, pchAppKeyBuffer, unAppKeyBufferLen); + return result; + } + public EVRApplicationError GetApplicationKeyByProcessId(uint unProcessId, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetApplicationKeyByProcessId(unProcessId, pchAppKeyBuffer, unAppKeyBufferLen); + return result; + } + public EVRApplicationError LaunchApplication(string pchAppKey) + { + EVRApplicationError result = FnTable.LaunchApplication(pchAppKey); + return result; + } + public EVRApplicationError LaunchTemplateApplication(string pchTemplateAppKey, string pchNewAppKey, AppOverrideKeys_t[] pKeys) + { + EVRApplicationError result = FnTable.LaunchTemplateApplication(pchTemplateAppKey, pchNewAppKey, pKeys, (uint)pKeys.Length); + return result; + } + public EVRApplicationError LaunchApplicationFromMimeType(string pchMimeType, string pchArgs) + { + EVRApplicationError result = FnTable.LaunchApplicationFromMimeType(pchMimeType, pchArgs); + return result; + } + public EVRApplicationError LaunchDashboardOverlay(string pchAppKey) + { + EVRApplicationError result = FnTable.LaunchDashboardOverlay(pchAppKey); + return result; + } + public bool CancelApplicationLaunch(string pchAppKey) + { + bool result = FnTable.CancelApplicationLaunch(pchAppKey); + return result; + } + public EVRApplicationError IdentifyApplication(uint unProcessId, string pchAppKey) + { + EVRApplicationError result = FnTable.IdentifyApplication(unProcessId, pchAppKey); + return result; + } + public uint GetApplicationProcessId(string pchAppKey) + { + uint result = FnTable.GetApplicationProcessId(pchAppKey); + return result; + } + public string GetApplicationsErrorNameFromEnum(EVRApplicationError error) + { + IntPtr result = FnTable.GetApplicationsErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public uint GetApplicationPropertyString(string pchAppKey, EVRApplicationProperty eProperty, System.Text.StringBuilder pchPropertyValueBuffer, uint unPropertyValueBufferLen, ref EVRApplicationError peError) + { + uint result = FnTable.GetApplicationPropertyString(pchAppKey, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen, ref peError); + return result; + } + public bool GetApplicationPropertyBool(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError) + { + bool result = FnTable.GetApplicationPropertyBool(pchAppKey, eProperty, ref peError); + return result; + } + public ulong GetApplicationPropertyUint64(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError) + { + ulong result = FnTable.GetApplicationPropertyUint64(pchAppKey, eProperty, ref peError); + return result; + } + public EVRApplicationError SetApplicationAutoLaunch(string pchAppKey, bool bAutoLaunch) + { + EVRApplicationError result = FnTable.SetApplicationAutoLaunch(pchAppKey, bAutoLaunch); + return result; + } + public bool GetApplicationAutoLaunch(string pchAppKey) + { + bool result = FnTable.GetApplicationAutoLaunch(pchAppKey); + return result; + } + public EVRApplicationError SetDefaultApplicationForMimeType(string pchAppKey, string pchMimeType) + { + EVRApplicationError result = FnTable.SetDefaultApplicationForMimeType(pchAppKey, pchMimeType); + return result; + } + public bool GetDefaultApplicationForMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen) + { + bool result = FnTable.GetDefaultApplicationForMimeType(pchMimeType, pchAppKeyBuffer, unAppKeyBufferLen); + return result; + } + public bool GetApplicationSupportedMimeTypes(string pchAppKey, System.Text.StringBuilder pchMimeTypesBuffer, uint unMimeTypesBuffer) + { + bool result = FnTable.GetApplicationSupportedMimeTypes(pchAppKey, pchMimeTypesBuffer, unMimeTypesBuffer); + return result; + } + public uint GetApplicationsThatSupportMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer) + { + uint result = FnTable.GetApplicationsThatSupportMimeType(pchMimeType, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer); + return result; + } + public uint GetApplicationLaunchArguments(uint unHandle, System.Text.StringBuilder pchArgs, uint unArgs) + { + uint result = FnTable.GetApplicationLaunchArguments(unHandle, pchArgs, unArgs); + return result; + } + public EVRApplicationError GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetStartingApplication(pchAppKeyBuffer, unAppKeyBufferLen); + return result; + } + public EVRApplicationTransitionState GetTransitionState() + { + EVRApplicationTransitionState result = FnTable.GetTransitionState(); + return result; + } + public EVRApplicationError PerformApplicationPrelaunchCheck(string pchAppKey) + { + EVRApplicationError result = FnTable.PerformApplicationPrelaunchCheck(pchAppKey); + return result; + } + public string GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state) + { + IntPtr result = FnTable.GetApplicationsTransitionStateNameFromEnum(state); + return Marshal.PtrToStringAnsi(result); + } + public bool IsQuitUserPromptRequested() + { + bool result = FnTable.IsQuitUserPromptRequested(); + return result; + } + public EVRApplicationError LaunchInternalProcess(string pchBinaryPath, string pchArguments, string pchWorkingDirectory) + { + EVRApplicationError result = FnTable.LaunchInternalProcess(pchBinaryPath, pchArguments, pchWorkingDirectory); + return result; + } + public uint GetCurrentSceneProcessId() + { + uint result = FnTable.GetCurrentSceneProcessId(); + return result; + } + } + + + public class CVRChaperone + { + IVRChaperone FnTable; + internal CVRChaperone(IntPtr pInterface) + { + FnTable = (IVRChaperone)Marshal.PtrToStructure(pInterface, typeof(IVRChaperone)); + } + public ChaperoneCalibrationState GetCalibrationState() + { + ChaperoneCalibrationState result = FnTable.GetCalibrationState(); + return result; + } + public bool GetPlayAreaSize(ref float pSizeX, ref float pSizeZ) + { + pSizeX = 0; + pSizeZ = 0; + bool result = FnTable.GetPlayAreaSize(ref pSizeX, ref pSizeZ); + return result; + } + public bool GetPlayAreaRect(ref HmdQuad_t rect) + { + bool result = FnTable.GetPlayAreaRect(ref rect); + return result; + } + public void ReloadInfo() + { + FnTable.ReloadInfo(); + } + public void SetSceneColor(HmdColor_t color) + { + FnTable.SetSceneColor(color); + } + public void GetBoundsColor(ref HmdColor_t pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, ref HmdColor_t pOutputCameraColor) + { + FnTable.GetBoundsColor(ref pOutputColorArray, nNumOutputColors, flCollisionBoundsFadeDistance, ref pOutputCameraColor); + } + public bool AreBoundsVisible() + { + bool result = FnTable.AreBoundsVisible(); + return result; + } + public void ForceBoundsVisible(bool bForce) + { + FnTable.ForceBoundsVisible(bForce); + } + } + + + public class CVRChaperoneSetup + { + IVRChaperoneSetup FnTable; + internal CVRChaperoneSetup(IntPtr pInterface) + { + FnTable = (IVRChaperoneSetup)Marshal.PtrToStructure(pInterface, typeof(IVRChaperoneSetup)); + } + public bool CommitWorkingCopy(EChaperoneConfigFile configFile) + { + bool result = FnTable.CommitWorkingCopy(configFile); + return result; + } + public void RevertWorkingCopy() + { + FnTable.RevertWorkingCopy(); + } + public bool GetWorkingPlayAreaSize(ref float pSizeX, ref float pSizeZ) + { + pSizeX = 0; + pSizeZ = 0; + bool result = FnTable.GetWorkingPlayAreaSize(ref pSizeX, ref pSizeZ); + return result; + } + public bool GetWorkingPlayAreaRect(ref HmdQuad_t rect) + { + bool result = FnTable.GetWorkingPlayAreaRect(ref rect); + return result; + } + public bool GetWorkingCollisionBoundsInfo(out HmdQuad_t[] pQuadsBuffer) + { + uint punQuadsCount = 0; + bool result = FnTable.GetWorkingCollisionBoundsInfo(null, ref punQuadsCount); + pQuadsBuffer = new HmdQuad_t[punQuadsCount]; + result = FnTable.GetWorkingCollisionBoundsInfo(pQuadsBuffer, ref punQuadsCount); + return result; + } + public bool GetLiveCollisionBoundsInfo(out HmdQuad_t[] pQuadsBuffer) + { + uint punQuadsCount = 0; + bool result = FnTable.GetLiveCollisionBoundsInfo(null, ref punQuadsCount); + pQuadsBuffer = new HmdQuad_t[punQuadsCount]; + result = FnTable.GetLiveCollisionBoundsInfo(pQuadsBuffer, ref punQuadsCount); + return result; + } + public bool GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetWorkingSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); + return result; + } + public bool GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetWorkingStandingZeroPoseToRawTrackingPose(ref pmatStandingZeroPoseToRawTrackingPose); + return result; + } + public void SetWorkingPlayAreaSize(float sizeX, float sizeZ) + { + FnTable.SetWorkingPlayAreaSize(sizeX, sizeZ); + } + public void SetWorkingCollisionBoundsInfo(HmdQuad_t[] pQuadsBuffer) + { + FnTable.SetWorkingCollisionBoundsInfo(pQuadsBuffer, (uint)pQuadsBuffer.Length); + } + public void SetWorkingPerimeter(HmdVector2_t[] pPointBuffer) + { + FnTable.SetWorkingPerimeter(pPointBuffer, (uint)pPointBuffer.Length); + } + public void SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose) + { + FnTable.SetWorkingSeatedZeroPoseToRawTrackingPose(ref pMatSeatedZeroPoseToRawTrackingPose); + } + public void SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose) + { + FnTable.SetWorkingStandingZeroPoseToRawTrackingPose(ref pMatStandingZeroPoseToRawTrackingPose); + } + public void ReloadFromDisk(EChaperoneConfigFile configFile) + { + FnTable.ReloadFromDisk(configFile); + } + public bool GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetLiveSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); + return result; + } + public bool ExportLiveToBuffer(System.Text.StringBuilder pBuffer, ref uint pnBufferLength) + { + pnBufferLength = 0; + bool result = FnTable.ExportLiveToBuffer(pBuffer, ref pnBufferLength); + return result; + } + public bool ImportFromBufferToWorking(string pBuffer, uint nImportFlags) + { + bool result = FnTable.ImportFromBufferToWorking(pBuffer, nImportFlags); + return result; + } + public void ShowWorkingSetPreview() + { + FnTable.ShowWorkingSetPreview(); + } + public void HideWorkingSetPreview() + { + FnTable.HideWorkingSetPreview(); + } + } + + + public class CVRCompositor + { + IVRCompositor FnTable; + internal CVRCompositor(IntPtr pInterface) + { + FnTable = (IVRCompositor)Marshal.PtrToStructure(pInterface, typeof(IVRCompositor)); + } + public void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) + { + FnTable.SetTrackingSpace(eOrigin); + } + public ETrackingUniverseOrigin GetTrackingSpace() + { + ETrackingUniverseOrigin result = FnTable.GetTrackingSpace(); + return result; + } + public EVRCompositorError WaitGetPoses(TrackedDevicePose_t[] pRenderPoseArray, TrackedDevicePose_t[] pGamePoseArray) + { + EVRCompositorError result = FnTable.WaitGetPoses(pRenderPoseArray, (uint)pRenderPoseArray.Length, pGamePoseArray, (uint)pGamePoseArray.Length); + return result; + } + public EVRCompositorError GetLastPoses(TrackedDevicePose_t[] pRenderPoseArray, TrackedDevicePose_t[] pGamePoseArray) + { + EVRCompositorError result = FnTable.GetLastPoses(pRenderPoseArray, (uint)pRenderPoseArray.Length, pGamePoseArray, (uint)pGamePoseArray.Length); + return result; + } + public EVRCompositorError GetLastPoseForTrackedDeviceIndex(uint unDeviceIndex, ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pOutputGamePose) + { + EVRCompositorError result = FnTable.GetLastPoseForTrackedDeviceIndex(unDeviceIndex, ref pOutputPose, ref pOutputGamePose); + return result; + } + public EVRCompositorError Submit(EVREye eEye, ref Texture_t pTexture, ref VRTextureBounds_t pBounds, EVRSubmitFlags nSubmitFlags) + { + EVRCompositorError result = FnTable.Submit(eEye, ref pTexture, ref pBounds, nSubmitFlags); + return result; + } + public void ClearLastSubmittedFrame() + { + FnTable.ClearLastSubmittedFrame(); + } + public void PostPresentHandoff() + { + FnTable.PostPresentHandoff(); + } + public bool GetFrameTiming(ref Compositor_FrameTiming pTiming, uint unFramesAgo) + { + bool result = FnTable.GetFrameTiming(ref pTiming, unFramesAgo); + return result; + } + public uint GetFrameTimings(Compositor_FrameTiming[] pTiming) + { + uint result = FnTable.GetFrameTimings(pTiming, (uint)pTiming.Length); + return result; + } + public float GetFrameTimeRemaining() + { + float result = FnTable.GetFrameTimeRemaining(); + return result; + } + public void GetCumulativeStats(ref Compositor_CumulativeStats pStats, uint nStatsSizeInBytes) + { + FnTable.GetCumulativeStats(ref pStats, nStatsSizeInBytes); + } + public void FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) + { + FnTable.FadeToColor(fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground); + } + public HmdColor_t GetCurrentFadeColor(bool bBackground) + { + HmdColor_t result = FnTable.GetCurrentFadeColor(bBackground); + return result; + } + public void FadeGrid(float fSeconds, bool bFadeIn) + { + FnTable.FadeGrid(fSeconds, bFadeIn); + } + public float GetCurrentGridAlpha() + { + float result = FnTable.GetCurrentGridAlpha(); + return result; + } + public EVRCompositorError SetSkyboxOverride(Texture_t[] pTextures) + { + EVRCompositorError result = FnTable.SetSkyboxOverride(pTextures, (uint)pTextures.Length); + return result; + } + public void ClearSkyboxOverride() + { + FnTable.ClearSkyboxOverride(); + } + public void CompositorBringToFront() + { + FnTable.CompositorBringToFront(); + } + public void CompositorGoToBack() + { + FnTable.CompositorGoToBack(); + } + public void CompositorQuit() + { + FnTable.CompositorQuit(); + } + public bool IsFullscreen() + { + bool result = FnTable.IsFullscreen(); + return result; + } + public uint GetCurrentSceneFocusProcess() + { + uint result = FnTable.GetCurrentSceneFocusProcess(); + return result; + } + public uint GetLastFrameRenderer() + { + uint result = FnTable.GetLastFrameRenderer(); + return result; + } + public bool CanRenderScene() + { + bool result = FnTable.CanRenderScene(); + return result; + } + public void ShowMirrorWindow() + { + FnTable.ShowMirrorWindow(); + } + public void HideMirrorWindow() + { + FnTable.HideMirrorWindow(); + } + public bool IsMirrorWindowVisible() + { + bool result = FnTable.IsMirrorWindowVisible(); + return result; + } + public void CompositorDumpImages() + { + FnTable.CompositorDumpImages(); + } + public bool ShouldAppRenderWithLowResources() + { + bool result = FnTable.ShouldAppRenderWithLowResources(); + return result; + } + public void ForceInterleavedReprojectionOn(bool bOverride) + { + FnTable.ForceInterleavedReprojectionOn(bOverride); + } + public void ForceReconnectProcess() + { + FnTable.ForceReconnectProcess(); + } + public void SuspendRendering(bool bSuspend) + { + FnTable.SuspendRendering(bSuspend); + } + public EVRCompositorError GetMirrorTextureD3D11(EVREye eEye, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView) + { + EVRCompositorError result = FnTable.GetMirrorTextureD3D11(eEye, pD3D11DeviceOrResource, ref ppD3D11ShaderResourceView); + return result; + } + public void ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView) + { + FnTable.ReleaseMirrorTextureD3D11(pD3D11ShaderResourceView); + } + public EVRCompositorError GetMirrorTextureGL(EVREye eEye, ref uint pglTextureId, IntPtr pglSharedTextureHandle) + { + pglTextureId = 0; + EVRCompositorError result = FnTable.GetMirrorTextureGL(eEye, ref pglTextureId, pglSharedTextureHandle); + return result; + } + public bool ReleaseSharedGLTexture(uint glTextureId, IntPtr glSharedTextureHandle) + { + bool result = FnTable.ReleaseSharedGLTexture(glTextureId, glSharedTextureHandle); + return result; + } + public void LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle) + { + FnTable.LockGLSharedTextureForAccess(glSharedTextureHandle); + } + public void UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle) + { + FnTable.UnlockGLSharedTextureForAccess(glSharedTextureHandle); + } + public uint GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue, uint unBufferSize) + { + uint result = FnTable.GetVulkanInstanceExtensionsRequired(pchValue, unBufferSize); + return result; + } + public uint GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice, System.Text.StringBuilder pchValue, uint unBufferSize) + { + uint result = FnTable.GetVulkanDeviceExtensionsRequired(pPhysicalDevice, pchValue, unBufferSize); + return result; + } + public void SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode) + { + FnTable.SetExplicitTimingMode(eTimingMode); + } + public EVRCompositorError SubmitExplicitTimingData() + { + EVRCompositorError result = FnTable.SubmitExplicitTimingData(); + return result; + } + public bool IsMotionSmoothingEnabled() + { + bool result = FnTable.IsMotionSmoothingEnabled(); + return result; + } + } + + + public class CVROverlay + { + IVROverlay FnTable; + internal CVROverlay(IntPtr pInterface) + { + FnTable = (IVROverlay)Marshal.PtrToStructure(pInterface, typeof(IVROverlay)); + } + public EVROverlayError FindOverlay(string pchOverlayKey, ref ulong pOverlayHandle) + { + pOverlayHandle = 0; + EVROverlayError result = FnTable.FindOverlay(pchOverlayKey, ref pOverlayHandle); + return result; + } + public EVROverlayError CreateOverlay(string pchOverlayKey, string pchOverlayName, ref ulong pOverlayHandle) + { + pOverlayHandle = 0; + EVROverlayError result = FnTable.CreateOverlay(pchOverlayKey, pchOverlayName, ref pOverlayHandle); + return result; + } + public EVROverlayError DestroyOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.DestroyOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError SetHighQualityOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.SetHighQualityOverlay(ulOverlayHandle); + return result; + } + public ulong GetHighQualityOverlay() + { + ulong result = FnTable.GetHighQualityOverlay(); + return result; + } + public uint GetOverlayKey(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayKey(ulOverlayHandle, pchValue, unBufferSize, ref pError); + return result; + } + public uint GetOverlayName(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayName(ulOverlayHandle, pchValue, unBufferSize, ref pError); + return result; + } + public EVROverlayError SetOverlayName(ulong ulOverlayHandle, string pchName) + { + EVROverlayError result = FnTable.SetOverlayName(ulOverlayHandle, pchName); + return result; + } + public EVROverlayError GetOverlayImageData(ulong ulOverlayHandle, IntPtr pvBuffer, uint unBufferSize, ref uint punWidth, ref uint punHeight) + { + punWidth = 0; + punHeight = 0; + EVROverlayError result = FnTable.GetOverlayImageData(ulOverlayHandle, pvBuffer, unBufferSize, ref punWidth, ref punHeight); + return result; + } + public string GetOverlayErrorNameFromEnum(EVROverlayError error) + { + IntPtr result = FnTable.GetOverlayErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public EVROverlayError SetOverlayRenderingPid(ulong ulOverlayHandle, uint unPID) + { + EVROverlayError result = FnTable.SetOverlayRenderingPid(ulOverlayHandle, unPID); + return result; + } + public uint GetOverlayRenderingPid(ulong ulOverlayHandle) + { + uint result = FnTable.GetOverlayRenderingPid(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) + { + EVROverlayError result = FnTable.SetOverlayFlag(ulOverlayHandle, eOverlayFlag, bEnabled); + return result; + } + public EVROverlayError GetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, ref bool pbEnabled) + { + pbEnabled = false; + EVROverlayError result = FnTable.GetOverlayFlag(ulOverlayHandle, eOverlayFlag, ref pbEnabled); + return result; + } + public EVROverlayError SetOverlayColor(ulong ulOverlayHandle, float fRed, float fGreen, float fBlue) + { + EVROverlayError result = FnTable.SetOverlayColor(ulOverlayHandle, fRed, fGreen, fBlue); + return result; + } + public EVROverlayError GetOverlayColor(ulong ulOverlayHandle, ref float pfRed, ref float pfGreen, ref float pfBlue) + { + pfRed = 0; + pfGreen = 0; + pfBlue = 0; + EVROverlayError result = FnTable.GetOverlayColor(ulOverlayHandle, ref pfRed, ref pfGreen, ref pfBlue); + return result; + } + public EVROverlayError SetOverlayAlpha(ulong ulOverlayHandle, float fAlpha) + { + EVROverlayError result = FnTable.SetOverlayAlpha(ulOverlayHandle, fAlpha); + return result; + } + public EVROverlayError GetOverlayAlpha(ulong ulOverlayHandle, ref float pfAlpha) + { + pfAlpha = 0; + EVROverlayError result = FnTable.GetOverlayAlpha(ulOverlayHandle, ref pfAlpha); + return result; + } + public EVROverlayError SetOverlayTexelAspect(ulong ulOverlayHandle, float fTexelAspect) + { + EVROverlayError result = FnTable.SetOverlayTexelAspect(ulOverlayHandle, fTexelAspect); + return result; + } + public EVROverlayError GetOverlayTexelAspect(ulong ulOverlayHandle, ref float pfTexelAspect) + { + pfTexelAspect = 0; + EVROverlayError result = FnTable.GetOverlayTexelAspect(ulOverlayHandle, ref pfTexelAspect); + return result; + } + public EVROverlayError SetOverlaySortOrder(ulong ulOverlayHandle, uint unSortOrder) + { + EVROverlayError result = FnTable.SetOverlaySortOrder(ulOverlayHandle, unSortOrder); + return result; + } + public EVROverlayError GetOverlaySortOrder(ulong ulOverlayHandle, ref uint punSortOrder) + { + punSortOrder = 0; + EVROverlayError result = FnTable.GetOverlaySortOrder(ulOverlayHandle, ref punSortOrder); + return result; + } + public EVROverlayError SetOverlayWidthInMeters(ulong ulOverlayHandle, float fWidthInMeters) + { + EVROverlayError result = FnTable.SetOverlayWidthInMeters(ulOverlayHandle, fWidthInMeters); + return result; + } + public EVROverlayError GetOverlayWidthInMeters(ulong ulOverlayHandle, ref float pfWidthInMeters) + { + pfWidthInMeters = 0; + EVROverlayError result = FnTable.GetOverlayWidthInMeters(ulOverlayHandle, ref pfWidthInMeters); + return result; + } + public EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters) + { + EVROverlayError result = FnTable.SetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle, fMinDistanceInMeters, fMaxDistanceInMeters); + return result; + } + public EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, ref float pfMinDistanceInMeters, ref float pfMaxDistanceInMeters) + { + pfMinDistanceInMeters = 0; + pfMaxDistanceInMeters = 0; + EVROverlayError result = FnTable.GetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle, ref pfMinDistanceInMeters, ref pfMaxDistanceInMeters); + return result; + } + public EVROverlayError SetOverlayTextureColorSpace(ulong ulOverlayHandle, EColorSpace eTextureColorSpace) + { + EVROverlayError result = FnTable.SetOverlayTextureColorSpace(ulOverlayHandle, eTextureColorSpace); + return result; + } + public EVROverlayError GetOverlayTextureColorSpace(ulong ulOverlayHandle, ref EColorSpace peTextureColorSpace) + { + EVROverlayError result = FnTable.GetOverlayTextureColorSpace(ulOverlayHandle, ref peTextureColorSpace); + return result; + } + public EVROverlayError SetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds) + { + EVROverlayError result = FnTable.SetOverlayTextureBounds(ulOverlayHandle, ref pOverlayTextureBounds); + return result; + } + public EVROverlayError GetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds) + { + EVROverlayError result = FnTable.GetOverlayTextureBounds(ulOverlayHandle, ref pOverlayTextureBounds); + return result; + } + public uint GetOverlayRenderModel(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref HmdColor_t pColor, ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayRenderModel(ulOverlayHandle, pchValue, unBufferSize, ref pColor, ref pError); + return result; + } + public EVROverlayError SetOverlayRenderModel(ulong ulOverlayHandle, string pchRenderModel, ref HmdColor_t pColor) + { + EVROverlayError result = FnTable.SetOverlayRenderModel(ulOverlayHandle, pchRenderModel, ref pColor); + return result; + } + public EVROverlayError GetOverlayTransformType(ulong ulOverlayHandle, ref VROverlayTransformType peTransformType) + { + EVROverlayError result = FnTable.GetOverlayTransformType(ulOverlayHandle, ref peTransformType); + return result; + } + public EVROverlayError SetOverlayTransformAbsolute(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformAbsolute(ulOverlayHandle, eTrackingOrigin, ref pmatTrackingOriginToOverlayTransform); + return result; + } + public EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) + { + EVROverlayError result = FnTable.GetOverlayTransformAbsolute(ulOverlayHandle, ref peTrackingOrigin, ref pmatTrackingOriginToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, uint unTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceRelative(ulOverlayHandle, unTrackedDevice, ref pmatTrackedDeviceToOverlayTransform); + return result; + } + public EVROverlayError GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, ref uint punTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform) + { + punTrackedDevice = 0; + EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceRelative(ulOverlayHandle, ref punTrackedDevice, ref pmatTrackedDeviceToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, string pchComponentName) + { + EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle, unDeviceIndex, pchComponentName); + return result; + } + public EVROverlayError GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, ref uint punDeviceIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameSize) + { + punDeviceIndex = 0; + EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceComponent(ulOverlayHandle, ref punDeviceIndex, pchComponentName, unComponentNameSize); + return result; + } + public EVROverlayError GetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ref ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform) + { + ulOverlayHandleParent = 0; + EVROverlayError result = FnTable.GetOverlayTransformOverlayRelative(ulOverlayHandle, ref ulOverlayHandleParent, ref pmatParentOverlayToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformOverlayRelative(ulOverlayHandle, ulOverlayHandleParent, ref pmatParentOverlayToOverlayTransform); + return result; + } + public EVROverlayError ShowOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ShowOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError HideOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.HideOverlay(ulOverlayHandle); + return result; + } + public bool IsOverlayVisible(ulong ulOverlayHandle) + { + bool result = FnTable.IsOverlayVisible(ulOverlayHandle); + return result; + } + public EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform) + { + EVROverlayError result = FnTable.GetTransformForOverlayCoordinates(ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, ref pmatTransform); + return result; + } + // This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were + // originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextOverlayEventPacked(ulong ulOverlayHandle, ref VREvent_t_Packed pEvent, uint uncbVREvent); + [StructLayout(LayoutKind.Explicit)] + struct PollNextOverlayEventUnion + { + [FieldOffset(0)] + public IVROverlay._PollNextOverlayEvent pPollNextOverlayEvent; + [FieldOffset(0)] + public _PollNextOverlayEventPacked pPollNextOverlayEventPacked; + } + public bool PollNextOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pEvent, uint uncbVREvent) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + PollNextOverlayEventUnion u; + VREvent_t_Packed event_packed = new VREvent_t_Packed(); + u.pPollNextOverlayEventPacked = null; + u.pPollNextOverlayEvent = FnTable.PollNextOverlayEvent; + bool packed_result = u.pPollNextOverlayEventPacked(ulOverlayHandle, ref event_packed, (uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed))); + + event_packed.Unpack(ref pEvent); + return packed_result; + } +#endif + bool result = FnTable.PollNextOverlayEvent(ulOverlayHandle, ref pEvent, uncbVREvent); + return result; + } + public EVROverlayError GetOverlayInputMethod(ulong ulOverlayHandle, ref VROverlayInputMethod peInputMethod) + { + EVROverlayError result = FnTable.GetOverlayInputMethod(ulOverlayHandle, ref peInputMethod); + return result; + } + public EVROverlayError SetOverlayInputMethod(ulong ulOverlayHandle, VROverlayInputMethod eInputMethod) + { + EVROverlayError result = FnTable.SetOverlayInputMethod(ulOverlayHandle, eInputMethod); + return result; + } + public EVROverlayError GetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale) + { + EVROverlayError result = FnTable.GetOverlayMouseScale(ulOverlayHandle, ref pvecMouseScale); + return result; + } + public EVROverlayError SetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale) + { + EVROverlayError result = FnTable.SetOverlayMouseScale(ulOverlayHandle, ref pvecMouseScale); + return result; + } + public bool ComputeOverlayIntersection(ulong ulOverlayHandle, ref VROverlayIntersectionParams_t pParams, ref VROverlayIntersectionResults_t pResults) + { + bool result = FnTable.ComputeOverlayIntersection(ulOverlayHandle, ref pParams, ref pResults); + return result; + } + public bool IsHoverTargetOverlay(ulong ulOverlayHandle) + { + bool result = FnTable.IsHoverTargetOverlay(ulOverlayHandle); + return result; + } + public ulong GetGamepadFocusOverlay() + { + ulong result = FnTable.GetGamepadFocusOverlay(); + return result; + } + public EVROverlayError SetGamepadFocusOverlay(ulong ulNewFocusOverlay) + { + EVROverlayError result = FnTable.SetGamepadFocusOverlay(ulNewFocusOverlay); + return result; + } + public EVROverlayError SetOverlayNeighbor(EOverlayDirection eDirection, ulong ulFrom, ulong ulTo) + { + EVROverlayError result = FnTable.SetOverlayNeighbor(eDirection, ulFrom, ulTo); + return result; + } + public EVROverlayError MoveGamepadFocusToNeighbor(EOverlayDirection eDirection, ulong ulFrom) + { + EVROverlayError result = FnTable.MoveGamepadFocusToNeighbor(eDirection, ulFrom); + return result; + } + public EVROverlayError SetOverlayDualAnalogTransform(ulong ulOverlay, EDualAnalogWhich eWhich, ref HmdVector2_t pvCenter, float fRadius) + { + EVROverlayError result = FnTable.SetOverlayDualAnalogTransform(ulOverlay, eWhich, ref pvCenter, fRadius); + return result; + } + public EVROverlayError GetOverlayDualAnalogTransform(ulong ulOverlay, EDualAnalogWhich eWhich, ref HmdVector2_t pvCenter, ref float pfRadius) + { + pfRadius = 0; + EVROverlayError result = FnTable.GetOverlayDualAnalogTransform(ulOverlay, eWhich, ref pvCenter, ref pfRadius); + return result; + } + public EVROverlayError SetOverlayTexture(ulong ulOverlayHandle, ref Texture_t pTexture) + { + EVROverlayError result = FnTable.SetOverlayTexture(ulOverlayHandle, ref pTexture); + return result; + } + public EVROverlayError ClearOverlayTexture(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ClearOverlayTexture(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayRaw(ulong ulOverlayHandle, IntPtr pvBuffer, uint unWidth, uint unHeight, uint unDepth) + { + EVROverlayError result = FnTable.SetOverlayRaw(ulOverlayHandle, pvBuffer, unWidth, unHeight, unDepth); + return result; + } + public EVROverlayError SetOverlayFromFile(ulong ulOverlayHandle, string pchFilePath) + { + EVROverlayError result = FnTable.SetOverlayFromFile(ulOverlayHandle, pchFilePath); + return result; + } + public EVROverlayError GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref ETextureType pAPIType, ref EColorSpace pColorSpace, ref VRTextureBounds_t pTextureBounds) + { + pWidth = 0; + pHeight = 0; + pNativeFormat = 0; + EVROverlayError result = FnTable.GetOverlayTexture(ulOverlayHandle, ref pNativeTextureHandle, pNativeTextureRef, ref pWidth, ref pHeight, ref pNativeFormat, ref pAPIType, ref pColorSpace, ref pTextureBounds); + return result; + } + public EVROverlayError ReleaseNativeOverlayHandle(ulong ulOverlayHandle, IntPtr pNativeTextureHandle) + { + EVROverlayError result = FnTable.ReleaseNativeOverlayHandle(ulOverlayHandle, pNativeTextureHandle); + return result; + } + public EVROverlayError GetOverlayTextureSize(ulong ulOverlayHandle, ref uint pWidth, ref uint pHeight) + { + pWidth = 0; + pHeight = 0; + EVROverlayError result = FnTable.GetOverlayTextureSize(ulOverlayHandle, ref pWidth, ref pHeight); + return result; + } + public EVROverlayError CreateDashboardOverlay(string pchOverlayKey, string pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle) + { + pMainHandle = 0; + pThumbnailHandle = 0; + EVROverlayError result = FnTable.CreateDashboardOverlay(pchOverlayKey, pchOverlayFriendlyName, ref pMainHandle, ref pThumbnailHandle); + return result; + } + public bool IsDashboardVisible() + { + bool result = FnTable.IsDashboardVisible(); + return result; + } + public bool IsActiveDashboardOverlay(ulong ulOverlayHandle) + { + bool result = FnTable.IsActiveDashboardOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError SetDashboardOverlaySceneProcess(ulong ulOverlayHandle, uint unProcessId) + { + EVROverlayError result = FnTable.SetDashboardOverlaySceneProcess(ulOverlayHandle, unProcessId); + return result; + } + public EVROverlayError GetDashboardOverlaySceneProcess(ulong ulOverlayHandle, ref uint punProcessId) + { + punProcessId = 0; + EVROverlayError result = FnTable.GetDashboardOverlaySceneProcess(ulOverlayHandle, ref punProcessId); + return result; + } + public void ShowDashboard(string pchOverlayToShow) + { + FnTable.ShowDashboard(pchOverlayToShow); + } + public uint GetPrimaryDashboardDevice() + { + uint result = FnTable.GetPrimaryDashboardDevice(); + return result; + } + public EVROverlayError ShowKeyboard(int eInputMode, int eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText, bool bUseMinimalMode, ulong uUserValue) + { + EVROverlayError result = FnTable.ShowKeyboard(eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText, bUseMinimalMode, uUserValue); + return result; + } + public EVROverlayError ShowKeyboardForOverlay(ulong ulOverlayHandle, int eInputMode, int eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText, bool bUseMinimalMode, ulong uUserValue) + { + EVROverlayError result = FnTable.ShowKeyboardForOverlay(ulOverlayHandle, eInputMode, eLineInputMode, pchDescription, unCharMax, pchExistingText, bUseMinimalMode, uUserValue); + return result; + } + public uint GetKeyboardText(System.Text.StringBuilder pchText, uint cchText) + { + uint result = FnTable.GetKeyboardText(pchText, cchText); + return result; + } + public void HideKeyboard() + { + FnTable.HideKeyboard(); + } + public void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform) + { + FnTable.SetKeyboardTransformAbsolute(eTrackingOrigin, ref pmatTrackingOriginToKeyboardTransform); + } + public void SetKeyboardPositionForOverlay(ulong ulOverlayHandle, HmdRect2_t avoidRect) + { + FnTable.SetKeyboardPositionForOverlay(ulOverlayHandle, avoidRect); + } + public EVROverlayError SetOverlayIntersectionMask(ulong ulOverlayHandle, ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives, uint unNumMaskPrimitives, uint unPrimitiveSize) + { + EVROverlayError result = FnTable.SetOverlayIntersectionMask(ulOverlayHandle, ref pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize); + return result; + } + public EVROverlayError GetOverlayFlags(ulong ulOverlayHandle, ref uint pFlags) + { + pFlags = 0; + EVROverlayError result = FnTable.GetOverlayFlags(ulOverlayHandle, ref pFlags); + return result; + } + 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); + return result; + } + public void CloseMessageOverlay() + { + FnTable.CloseMessageOverlay(); + } + } + + + public class CVRRenderModels + { + IVRRenderModels FnTable; + internal CVRRenderModels(IntPtr pInterface) + { + FnTable = (IVRRenderModels)Marshal.PtrToStructure(pInterface, typeof(IVRRenderModels)); + } + public EVRRenderModelError LoadRenderModel_Async(string pchRenderModelName, ref IntPtr ppRenderModel) + { + EVRRenderModelError result = FnTable.LoadRenderModel_Async(pchRenderModelName, ref ppRenderModel); + return result; + } + public void FreeRenderModel(IntPtr pRenderModel) + { + FnTable.FreeRenderModel(pRenderModel); + } + public EVRRenderModelError LoadTexture_Async(int textureId, ref IntPtr ppTexture) + { + EVRRenderModelError result = FnTable.LoadTexture_Async(textureId, ref ppTexture); + return result; + } + public void FreeTexture(IntPtr pTexture) + { + FnTable.FreeTexture(pTexture); + } + public EVRRenderModelError LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D) + { + EVRRenderModelError result = FnTable.LoadTextureD3D11_Async(textureId, pD3D11Device, ref ppD3D11Texture2D); + return result; + } + public EVRRenderModelError LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture) + { + EVRRenderModelError result = FnTable.LoadIntoTextureD3D11_Async(textureId, pDstTexture); + return result; + } + public void FreeTextureD3D11(IntPtr pD3D11Texture2D) + { + FnTable.FreeTextureD3D11(pD3D11Texture2D); + } + public uint GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen) + { + uint result = FnTable.GetRenderModelName(unRenderModelIndex, pchRenderModelName, unRenderModelNameLen); + return result; + } + public uint GetRenderModelCount() + { + uint result = FnTable.GetRenderModelCount(); + return result; + } + public uint GetComponentCount(string pchRenderModelName) + { + uint result = FnTable.GetComponentCount(pchRenderModelName); + return result; + } + public uint GetComponentName(string pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen) + { + uint result = FnTable.GetComponentName(pchRenderModelName, unComponentIndex, pchComponentName, unComponentNameLen); + return result; + } + public ulong GetComponentButtonMask(string pchRenderModelName, string pchComponentName) + { + ulong result = FnTable.GetComponentButtonMask(pchRenderModelName, pchComponentName); + return result; + } + public uint GetComponentRenderModelName(string pchRenderModelName, string pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen) + { + uint result = FnTable.GetComponentRenderModelName(pchRenderModelName, pchComponentName, pchComponentRenderModelName, unComponentRenderModelNameLen); + 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); + 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); + [StructLayout(LayoutKind.Explicit)] + struct GetComponentStateUnion + { + [FieldOffset(0)] + public IVRRenderModels._GetComponentState pGetComponentState; + [FieldOffset(0)] + public _GetComponentStatePacked pGetComponentStatePacked; + } + public bool GetComponentState(string pchRenderModelName, string pchComponentName, ref VRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetComponentStateUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetComponentStatePacked = null; + u.pGetComponentState = FnTable.GetComponentState; + bool packed_result = u.pGetComponentStatePacked(pchRenderModelName, pchComponentName, 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); + return result; + } + public bool RenderModelHasComponent(string pchRenderModelName, string pchComponentName) + { + bool result = FnTable.RenderModelHasComponent(pchRenderModelName, pchComponentName); + 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); + 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); + return result; + } + public string GetRenderModelErrorNameFromEnum(EVRRenderModelError error) + { + IntPtr result = FnTable.GetRenderModelErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + } + + + public class CVRNotifications + { + IVRNotifications FnTable; + internal CVRNotifications(IntPtr pInterface) + { + FnTable = (IVRNotifications)Marshal.PtrToStructure(pInterface, typeof(IVRNotifications)); + } + public EVRNotificationError CreateNotification(ulong ulOverlayHandle, ulong ulUserValue, EVRNotificationType type, string pchText, EVRNotificationStyle style, ref NotificationBitmap_t pImage, ref uint pNotificationId) + { + pNotificationId = 0; + EVRNotificationError result = FnTable.CreateNotification(ulOverlayHandle, ulUserValue, type, pchText, style, ref pImage, ref pNotificationId); + return result; + } + public EVRNotificationError RemoveNotification(uint notificationId) + { + EVRNotificationError result = FnTable.RemoveNotification(notificationId); + return result; + } + } + + + public class CVRSettings + { + IVRSettings FnTable; + internal CVRSettings(IntPtr pInterface) + { + FnTable = (IVRSettings)Marshal.PtrToStructure(pInterface, typeof(IVRSettings)); + } + public string GetSettingsErrorNameFromEnum(EVRSettingsError eError) + { + IntPtr result = FnTable.GetSettingsErrorNameFromEnum(eError); + return Marshal.PtrToStringAnsi(result); + } + public bool Sync(bool bForce, ref EVRSettingsError peError) + { + bool result = FnTable.Sync(bForce, ref peError); + return result; + } + public void SetBool(string pchSection, string pchSettingsKey, bool bValue, ref EVRSettingsError peError) + { + FnTable.SetBool(pchSection, pchSettingsKey, bValue, ref peError); + } + public void SetInt32(string pchSection, string pchSettingsKey, int nValue, ref EVRSettingsError peError) + { + FnTable.SetInt32(pchSection, pchSettingsKey, nValue, ref peError); + } + public void SetFloat(string pchSection, string pchSettingsKey, float flValue, ref EVRSettingsError peError) + { + FnTable.SetFloat(pchSection, pchSettingsKey, flValue, ref peError); + } + public void SetString(string pchSection, string pchSettingsKey, string pchValue, ref EVRSettingsError peError) + { + FnTable.SetString(pchSection, pchSettingsKey, pchValue, ref peError); + } + public bool GetBool(string pchSection, string pchSettingsKey, ref EVRSettingsError peError) + { + bool result = FnTable.GetBool(pchSection, pchSettingsKey, ref peError); + return result; + } + public int GetInt32(string pchSection, string pchSettingsKey, ref EVRSettingsError peError) + { + int result = FnTable.GetInt32(pchSection, pchSettingsKey, ref peError); + return result; + } + public float GetFloat(string pchSection, string pchSettingsKey, ref EVRSettingsError peError) + { + float result = FnTable.GetFloat(pchSection, pchSettingsKey, ref peError); + 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); + } + public void RemoveSection(string pchSection, ref EVRSettingsError peError) + { + FnTable.RemoveSection(pchSection, ref peError); + } + public void RemoveKeyInSection(string pchSection, string pchSettingsKey, ref EVRSettingsError peError) + { + FnTable.RemoveKeyInSection(pchSection, pchSettingsKey, ref peError); + } + } + + + public class CVRScreenshots + { + IVRScreenshots FnTable; + internal CVRScreenshots(IntPtr pInterface) + { + FnTable = (IVRScreenshots)Marshal.PtrToStructure(pInterface, typeof(IVRScreenshots)); + } + public EVRScreenshotError RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, string pchPreviewFilename, string pchVRFilename) + { + pOutScreenshotHandle = 0; + EVRScreenshotError result = FnTable.RequestScreenshot(ref pOutScreenshotHandle, type, pchPreviewFilename, pchVRFilename); + return result; + } + public EVRScreenshotError HookScreenshot(EVRScreenshotType[] pSupportedTypes) + { + EVRScreenshotError result = FnTable.HookScreenshot(pSupportedTypes, (int)pSupportedTypes.Length); + return result; + } + public EVRScreenshotType GetScreenshotPropertyType(uint screenshotHandle, ref EVRScreenshotError pError) + { + EVRScreenshotType result = FnTable.GetScreenshotPropertyType(screenshotHandle, ref pError); + return result; + } + public uint GetScreenshotPropertyFilename(uint screenshotHandle, EVRScreenshotPropertyFilenames filenameType, System.Text.StringBuilder pchFilename, uint cchFilename, ref EVRScreenshotError pError) + { + uint result = FnTable.GetScreenshotPropertyFilename(screenshotHandle, filenameType, pchFilename, cchFilename, ref pError); + return result; + } + public EVRScreenshotError UpdateScreenshotProgress(uint screenshotHandle, float flProgress) + { + EVRScreenshotError result = FnTable.UpdateScreenshotProgress(screenshotHandle, flProgress); + return result; + } + public EVRScreenshotError TakeStereoScreenshot(ref uint pOutScreenshotHandle, string pchPreviewFilename, string pchVRFilename) + { + pOutScreenshotHandle = 0; + EVRScreenshotError result = FnTable.TakeStereoScreenshot(ref pOutScreenshotHandle, pchPreviewFilename, pchVRFilename); + return result; + } + public EVRScreenshotError SubmitScreenshot(uint screenshotHandle, EVRScreenshotType type, string pchSourcePreviewFilename, string pchSourceVRFilename) + { + EVRScreenshotError result = FnTable.SubmitScreenshot(screenshotHandle, type, pchSourcePreviewFilename, pchSourceVRFilename); + return result; + } + } + + + public class CVRResources + { + IVRResources FnTable; + internal CVRResources(IntPtr pInterface) + { + FnTable = (IVRResources)Marshal.PtrToStructure(pInterface, typeof(IVRResources)); + } + public uint LoadSharedResource(string pchResourceName, string pchBuffer, uint unBufferLen) + { + uint result = FnTable.LoadSharedResource(pchResourceName, pchBuffer, unBufferLen); + return result; + } + public uint GetResourceFullPath(string pchResourceName, string pchResourceTypeDirectory, System.Text.StringBuilder pchPathBuffer, uint unBufferLen) + { + uint result = FnTable.GetResourceFullPath(pchResourceName, pchResourceTypeDirectory, pchPathBuffer, unBufferLen); + return result; + } + } + + + public class CVRDriverManager + { + IVRDriverManager FnTable; + internal CVRDriverManager(IntPtr pInterface) + { + FnTable = (IVRDriverManager)Marshal.PtrToStructure(pInterface, typeof(IVRDriverManager)); + } + public uint GetDriverCount() + { + uint result = FnTable.GetDriverCount(); + return result; + } + public uint GetDriverName(uint nDriver, System.Text.StringBuilder pchValue, uint unBufferSize) + { + uint result = FnTable.GetDriverName(nDriver, pchValue, unBufferSize); + return result; + } + public ulong GetDriverHandle(string pchDriverName) + { + ulong result = FnTable.GetDriverHandle(pchDriverName); + return result; + } + } + + + public class CVRInput + { + IVRInput FnTable; + internal CVRInput(IntPtr pInterface) + { + FnTable = (IVRInput)Marshal.PtrToStructure(pInterface, typeof(IVRInput)); + } + public EVRInputError SetActionManifestPath(string pchActionManifestPath) + { + EVRInputError result = FnTable.SetActionManifestPath(pchActionManifestPath); + return result; + } + public EVRInputError GetActionSetHandle(string pchActionSetName, ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetActionSetHandle(pchActionSetName, ref pHandle); + return result; + } + public EVRInputError GetActionHandle(string pchActionName, ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetActionHandle(pchActionName, ref pHandle); + return result; + } + public EVRInputError GetInputSourceHandle(string pchInputSourcePath, ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetInputSourceHandle(pchInputSourcePath, ref pHandle); + return result; + } + public EVRInputError UpdateActionState(VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t) + { + EVRInputError result = FnTable.UpdateActionState(pSets, unSizeOfVRSelectedActionSet_t, (uint)pSets.Length); + return result; + } + public EVRInputError GetDigitalActionData(ulong action, ref InputDigitalActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetDigitalActionData(action, ref pActionData, unActionDataSize, ulRestrictToDevice); + return result; + } + public EVRInputError GetAnalogActionData(ulong action, ref InputAnalogActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetAnalogActionData(action, ref pActionData, unActionDataSize, ulRestrictToDevice); + return result; + } + public EVRInputError GetPoseActionData(ulong action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, ref InputPoseActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetPoseActionData(action, eOrigin, fPredictedSecondsFromNow, ref pActionData, unActionDataSize, ulRestrictToDevice); + return result; + } + public EVRInputError GetSkeletalActionData(ulong action, ref InputSkeletalActionData_t pActionData, uint unActionDataSize) + { + EVRInputError result = FnTable.GetSkeletalActionData(action, ref pActionData, unActionDataSize); + return result; + } + public EVRInputError GetBoneCount(ulong action, ref uint pBoneCount) + { + pBoneCount = 0; + EVRInputError result = FnTable.GetBoneCount(action, ref pBoneCount); + return result; + } + public EVRInputError GetBoneHierarchy(ulong action, int[] pParentIndices) + { + EVRInputError result = FnTable.GetBoneHierarchy(action, pParentIndices, (uint)pParentIndices.Length); + return result; + } + public EVRInputError GetBoneName(ulong action, int nBoneIndex, System.Text.StringBuilder pchBoneName, uint unNameBufferSize) + { + EVRInputError result = FnTable.GetBoneName(action, nBoneIndex, pchBoneName, unNameBufferSize); + return result; + } + public EVRInputError GetSkeletalReferenceTransforms(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t[] pTransformArray) + { + EVRInputError result = FnTable.GetSkeletalReferenceTransforms(action, eTransformSpace, eReferencePose, pTransformArray, (uint)pTransformArray.Length); + return result; + } + public EVRInputError GetSkeletalTrackingLevel(ulong action, ref EVRSkeletalTrackingLevel pSkeletalTrackingLevel) + { + EVRInputError result = FnTable.GetSkeletalTrackingLevel(action, ref pSkeletalTrackingLevel); + return result; + } + public EVRInputError GetSkeletalBoneData(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t[] pTransformArray) + { + EVRInputError result = FnTable.GetSkeletalBoneData(action, eTransformSpace, eMotionRange, pTransformArray, (uint)pTransformArray.Length); + return result; + } + public EVRInputError GetSkeletalSummaryData(ulong action, ref VRSkeletalSummaryData_t pSkeletalSummaryData) + { + EVRInputError result = FnTable.GetSkeletalSummaryData(action, ref pSkeletalSummaryData); + return result; + } + public EVRInputError GetSkeletalBoneDataCompressed(ulong action, EVRSkeletalMotionRange eMotionRange, IntPtr pvCompressedData, uint unCompressedSize, ref uint punRequiredCompressedSize) + { + punRequiredCompressedSize = 0; + EVRInputError result = FnTable.GetSkeletalBoneDataCompressed(action, eMotionRange, pvCompressedData, unCompressedSize, ref punRequiredCompressedSize); + return result; + } + public EVRInputError DecompressSkeletalBoneData(IntPtr pvCompressedBuffer, uint unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t[] pTransformArray) + { + EVRInputError result = FnTable.DecompressSkeletalBoneData(pvCompressedBuffer, unCompressedBufferSize, eTransformSpace, pTransformArray, (uint)pTransformArray.Length); + return result; + } + public EVRInputError TriggerHapticVibrationAction(ulong action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.TriggerHapticVibrationAction(action, fStartSecondsFromNow, fDurationSeconds, fFrequency, fAmplitude, ulRestrictToDevice); + return result; + } + public EVRInputError GetActionOrigins(ulong actionSetHandle, ulong digitalActionHandle, ulong[] originsOut) + { + EVRInputError result = FnTable.GetActionOrigins(actionSetHandle, digitalActionHandle, originsOut, (uint)originsOut.Length); + return result; + } + public EVRInputError GetOriginLocalizedName(ulong origin, System.Text.StringBuilder pchNameArray, uint unNameArraySize, int unStringSectionsToInclude) + { + EVRInputError result = FnTable.GetOriginLocalizedName(origin, pchNameArray, unNameArraySize, unStringSectionsToInclude); + return result; + } + public EVRInputError GetOriginTrackedDeviceInfo(ulong origin, ref InputOriginInfo_t pOriginInfo, uint unOriginInfoSize) + { + EVRInputError result = FnTable.GetOriginTrackedDeviceInfo(origin, ref pOriginInfo, unOriginInfoSize); + return result; + } + public EVRInputError ShowActionOrigins(ulong actionSetHandle, ulong ulActionHandle) + { + EVRInputError result = FnTable.ShowActionOrigins(actionSetHandle, ulActionHandle); + return result; + } + public EVRInputError ShowBindingsForActionSet(VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, ulong originToHighlight) + { + EVRInputError result = FnTable.ShowBindingsForActionSet(pSets, unSizeOfVRSelectedActionSet_t, (uint)pSets.Length, originToHighlight); + return result; + } + public bool IsUsingLegacyInput() + { + bool result = FnTable.IsUsingLegacyInput(); + return result; + } + } + + + public class CVRIOBuffer + { + IVRIOBuffer FnTable; + internal CVRIOBuffer(IntPtr pInterface) + { + FnTable = (IVRIOBuffer)Marshal.PtrToStructure(pInterface, typeof(IVRIOBuffer)); + } + public EIOBufferError Open(string pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer) + { + pulBuffer = 0; + EIOBufferError result = FnTable.Open(pchPath, mode, unElementSize, unElements, ref pulBuffer); + return result; + } + public EIOBufferError Close(ulong ulBuffer) + { + EIOBufferError result = FnTable.Close(ulBuffer); + return result; + } + public EIOBufferError Read(ulong ulBuffer, IntPtr pDst, uint unBytes, ref uint punRead) + { + punRead = 0; + EIOBufferError result = FnTable.Read(ulBuffer, pDst, unBytes, ref punRead); + return result; + } + public EIOBufferError Write(ulong ulBuffer, IntPtr pSrc, uint unBytes) + { + EIOBufferError result = FnTable.Write(ulBuffer, pSrc, unBytes); + return result; + } + public ulong PropertyContainer(ulong ulBuffer) + { + ulong result = FnTable.PropertyContainer(ulBuffer); + return result; + } + public bool HasReaders(ulong ulBuffer) + { + bool result = FnTable.HasReaders(ulBuffer); + return result; + } + } + + + public class CVRSpatialAnchors + { + IVRSpatialAnchors FnTable; + internal CVRSpatialAnchors(IntPtr pInterface) + { + FnTable = (IVRSpatialAnchors)Marshal.PtrToStructure(pInterface, typeof(IVRSpatialAnchors)); + } + public EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor(string pchDescriptor, ref uint pHandleOut) + { + pHandleOut = 0; + EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromDescriptor(pchDescriptor, ref pHandleOut); + return result; + } + public EVRSpatialAnchorError CreateSpatialAnchorFromPose(uint unDeviceIndex, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPose, ref uint pHandleOut) + { + pHandleOut = 0; + EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromPose(unDeviceIndex, eOrigin, ref pPose, ref pHandleOut); + return result; + } + public EVRSpatialAnchorError GetSpatialAnchorPose(uint unHandle, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPoseOut) + { + EVRSpatialAnchorError result = FnTable.GetSpatialAnchorPose(unHandle, eOrigin, ref pPoseOut); + return result; + } + public EVRSpatialAnchorError GetSpatialAnchorDescriptor(uint unHandle, System.Text.StringBuilder pchDescriptorOut, ref uint punDescriptorBufferLenInOut) + { + punDescriptorBufferLenInOut = 0; + EVRSpatialAnchorError result = FnTable.GetSpatialAnchorDescriptor(unHandle, pchDescriptorOut, ref punDescriptorBufferLenInOut); + return result; + } + } + + + public class OpenVRInterop + { + [DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType); + [DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal2", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType, [In, MarshalAs(UnmanagedType.LPStr)] string pStartupInfo); + [DllImportAttribute("openvr_api", EntryPoint = "VR_ShutdownInternal", CallingConvention = CallingConvention.Cdecl)] + internal static extern void ShutdownInternal(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsHmdPresent", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsHmdPresent(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsRuntimeInstalled", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsRuntimeInstalled(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_RuntimePath", CallingConvention = CallingConvention.Cdecl)] + internal static extern string RuntimePath(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetStringForHmdError", CallingConvention = CallingConvention.Cdecl)] + internal static extern IntPtr GetStringForHmdError(EVRInitError error); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetGenericInterface", CallingConvention = CallingConvention.Cdecl)] + internal static extern IntPtr GetGenericInterface([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion, ref EVRInitError peError); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsInterfaceVersionValid", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsInterfaceVersionValid([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetInitToken", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint GetInitToken(); + } + + + public enum EVREye + { + Eye_Left = 0, + Eye_Right = 1, + } + public enum ETextureType + { + Invalid = -1, + DirectX = 0, + OpenGL = 1, + Vulkan = 2, + IOSurface = 3, + DirectX12 = 4, + DXGISharedHandle = 5, + Metal = 6, + } + public enum EColorSpace + { + Auto = 0, + Gamma = 1, + Linear = 2, + } + public enum ETrackingResult + { + Uninitialized = 1, + Calibrating_InProgress = 100, + Calibrating_OutOfRange = 101, + Running_OK = 200, + Running_OutOfRange = 201, + Fallback_RotationOnly = 300, + } + public enum ETrackedDeviceClass + { + Invalid = 0, + HMD = 1, + Controller = 2, + GenericTracker = 3, + TrackingReference = 4, + DisplayRedirect = 5, + Max = 6, + } + public enum ETrackedControllerRole + { + Invalid = 0, + LeftHand = 1, + RightHand = 2, + OptOut = 3, + Treadmill = 4, + Max = 4, + } + public enum ETrackingUniverseOrigin + { + TrackingUniverseSeated = 0, + TrackingUniverseStanding = 1, + TrackingUniverseRawAndUncalibrated = 2, + } + public enum EAdditionalRadioFeatures + { + None = 0, + HTCLinkBox = 1, + InternalDongle = 2, + ExternalDongle = 4, + } + public enum ETrackedDeviceProperty + { + Prop_Invalid = 0, + Prop_TrackingSystemName_String = 1000, + Prop_ModelNumber_String = 1001, + Prop_SerialNumber_String = 1002, + Prop_RenderModelName_String = 1003, + Prop_WillDriftInYaw_Bool = 1004, + Prop_ManufacturerName_String = 1005, + Prop_TrackingFirmwareVersion_String = 1006, + Prop_HardwareRevision_String = 1007, + Prop_AllWirelessDongleDescriptions_String = 1008, + Prop_ConnectedWirelessDongle_String = 1009, + Prop_DeviceIsWireless_Bool = 1010, + Prop_DeviceIsCharging_Bool = 1011, + Prop_DeviceBatteryPercentage_Float = 1012, + Prop_StatusDisplayTransform_Matrix34 = 1013, + Prop_Firmware_UpdateAvailable_Bool = 1014, + Prop_Firmware_ManualUpdate_Bool = 1015, + Prop_Firmware_ManualUpdateURL_String = 1016, + Prop_HardwareRevision_Uint64 = 1017, + Prop_FirmwareVersion_Uint64 = 1018, + Prop_FPGAVersion_Uint64 = 1019, + Prop_VRCVersion_Uint64 = 1020, + Prop_RadioVersion_Uint64 = 1021, + Prop_DongleVersion_Uint64 = 1022, + Prop_BlockServerShutdown_Bool = 1023, + Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024, + Prop_ContainsProximitySensor_Bool = 1025, + Prop_DeviceProvidesBatteryStatus_Bool = 1026, + Prop_DeviceCanPowerOff_Bool = 1027, + Prop_Firmware_ProgrammingTarget_String = 1028, + Prop_DeviceClass_Int32 = 1029, + Prop_HasCamera_Bool = 1030, + Prop_DriverVersion_String = 1031, + Prop_Firmware_ForceUpdateRequired_Bool = 1032, + Prop_ViveSystemButtonFixRequired_Bool = 1033, + Prop_ParentDriver_Uint64 = 1034, + Prop_ResourceRoot_String = 1035, + Prop_RegisteredDeviceType_String = 1036, + Prop_InputProfilePath_String = 1037, + Prop_NeverTracked_Bool = 1038, + Prop_NumCameras_Int32 = 1039, + Prop_CameraFrameLayout_Int32 = 1040, + Prop_CameraStreamFormat_Int32 = 1041, + Prop_AdditionalDeviceSettingsPath_String = 1042, + Prop_Identifiable_Bool = 1043, + Prop_BootloaderVersion_Uint64 = 1044, + Prop_AdditionalSystemReportData_String = 1045, + Prop_CompositeFirmwareVersion_String = 1046, + Prop_ReportsTimeSinceVSync_Bool = 2000, + Prop_SecondsFromVsyncToPhotons_Float = 2001, + Prop_DisplayFrequency_Float = 2002, + Prop_UserIpdMeters_Float = 2003, + Prop_CurrentUniverseId_Uint64 = 2004, + Prop_PreviousUniverseId_Uint64 = 2005, + Prop_DisplayFirmwareVersion_Uint64 = 2006, + Prop_IsOnDesktop_Bool = 2007, + Prop_DisplayMCType_Int32 = 2008, + Prop_DisplayMCOffset_Float = 2009, + Prop_DisplayMCScale_Float = 2010, + Prop_EdidVendorID_Int32 = 2011, + Prop_DisplayMCImageLeft_String = 2012, + Prop_DisplayMCImageRight_String = 2013, + Prop_DisplayGCBlackClamp_Float = 2014, + Prop_EdidProductID_Int32 = 2015, + Prop_CameraToHeadTransform_Matrix34 = 2016, + Prop_DisplayGCType_Int32 = 2017, + Prop_DisplayGCOffset_Float = 2018, + Prop_DisplayGCScale_Float = 2019, + Prop_DisplayGCPrescale_Float = 2020, + Prop_DisplayGCImage_String = 2021, + Prop_LensCenterLeftU_Float = 2022, + Prop_LensCenterLeftV_Float = 2023, + Prop_LensCenterRightU_Float = 2024, + Prop_LensCenterRightV_Float = 2025, + Prop_UserHeadToEyeDepthMeters_Float = 2026, + Prop_CameraFirmwareVersion_Uint64 = 2027, + Prop_CameraFirmwareDescription_String = 2028, + Prop_DisplayFPGAVersion_Uint64 = 2029, + Prop_DisplayBootloaderVersion_Uint64 = 2030, + Prop_DisplayHardwareVersion_Uint64 = 2031, + Prop_AudioFirmwareVersion_Uint64 = 2032, + Prop_CameraCompatibilityMode_Int32 = 2033, + Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034, + Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035, + Prop_DisplaySuppressed_Bool = 2036, + Prop_DisplayAllowNightMode_Bool = 2037, + Prop_DisplayMCImageWidth_Int32 = 2038, + Prop_DisplayMCImageHeight_Int32 = 2039, + Prop_DisplayMCImageNumChannels_Int32 = 2040, + Prop_DisplayMCImageData_Binary = 2041, + Prop_SecondsFromPhotonsToVblank_Float = 2042, + Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043, + Prop_DisplayDebugMode_Bool = 2044, + Prop_GraphicsAdapterLuid_Uint64 = 2045, + Prop_DriverProvidedChaperonePath_String = 2048, + Prop_ExpectedTrackingReferenceCount_Int32 = 2049, + Prop_ExpectedControllerCount_Int32 = 2050, + Prop_NamedIconPathControllerLeftDeviceOff_String = 2051, + Prop_NamedIconPathControllerRightDeviceOff_String = 2052, + Prop_NamedIconPathTrackingReferenceDeviceOff_String = 2053, + Prop_DoNotApplyPrediction_Bool = 2054, + Prop_CameraToHeadTransforms_Matrix34_Array = 2055, + Prop_DistortionMeshResolution_Int32 = 2056, + Prop_DriverIsDrawingControllers_Bool = 2057, + Prop_DriverRequestsApplicationPause_Bool = 2058, + Prop_DriverRequestsReducedRendering_Bool = 2059, + Prop_MinimumIpdStepMeters_Float = 2060, + Prop_AudioBridgeFirmwareVersion_Uint64 = 2061, + Prop_ImageBridgeFirmwareVersion_Uint64 = 2062, + Prop_ImuToHeadTransform_Matrix34 = 2063, + Prop_ImuFactoryGyroBias_Vector3 = 2064, + Prop_ImuFactoryGyroScale_Vector3 = 2065, + Prop_ImuFactoryAccelerometerBias_Vector3 = 2066, + Prop_ImuFactoryAccelerometerScale_Vector3 = 2067, + Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069, + Prop_AdditionalRadioFeatures_Uint64 = 2070, + Prop_CameraWhiteBalance_Vector4_Array = 2071, + Prop_CameraDistortionFunction_Int32_Array = 2072, + Prop_CameraDistortionCoefficients_Float_Array = 2073, + Prop_ExpectedControllerType_String = 2074, + Prop_DriverRequestedMuraCorrectionMode_Int32 = 2200, + Prop_DriverRequestedMuraFeather_InnerLeft_Int32 = 2201, + Prop_DriverRequestedMuraFeather_InnerRight_Int32 = 2202, + Prop_DriverRequestedMuraFeather_InnerTop_Int32 = 2203, + Prop_DriverRequestedMuraFeather_InnerBottom_Int32 = 2204, + Prop_DriverRequestedMuraFeather_OuterLeft_Int32 = 2205, + Prop_DriverRequestedMuraFeather_OuterRight_Int32 = 2206, + Prop_DriverRequestedMuraFeather_OuterTop_Int32 = 2207, + Prop_DriverRequestedMuraFeather_OuterBottom_Int32 = 2208, + Prop_AttachedDeviceId_String = 3000, + Prop_SupportedButtons_Uint64 = 3001, + Prop_Axis0Type_Int32 = 3002, + Prop_Axis1Type_Int32 = 3003, + Prop_Axis2Type_Int32 = 3004, + Prop_Axis3Type_Int32 = 3005, + Prop_Axis4Type_Int32 = 3006, + Prop_ControllerRoleHint_Int32 = 3007, + Prop_FieldOfViewLeftDegrees_Float = 4000, + Prop_FieldOfViewRightDegrees_Float = 4001, + Prop_FieldOfViewTopDegrees_Float = 4002, + Prop_FieldOfViewBottomDegrees_Float = 4003, + Prop_TrackingRangeMinimumMeters_Float = 4004, + Prop_TrackingRangeMaximumMeters_Float = 4005, + Prop_ModeLabel_String = 4006, + Prop_CanWirelessIdentify_Bool = 4007, + Prop_Nonce_Int32 = 4008, + Prop_IconPathName_String = 5000, + Prop_NamedIconPathDeviceOff_String = 5001, + Prop_NamedIconPathDeviceSearching_String = 5002, + Prop_NamedIconPathDeviceSearchingAlert_String = 5003, + Prop_NamedIconPathDeviceReady_String = 5004, + Prop_NamedIconPathDeviceReadyAlert_String = 5005, + Prop_NamedIconPathDeviceNotReady_String = 5006, + Prop_NamedIconPathDeviceStandby_String = 5007, + Prop_NamedIconPathDeviceAlertLow_String = 5008, + Prop_DisplayHiddenArea_Binary_Start = 5100, + Prop_DisplayHiddenArea_Binary_End = 5150, + Prop_ParentContainer = 5151, + Prop_UserConfigPath_String = 6000, + Prop_InstallPath_String = 6001, + Prop_HasDisplayComponent_Bool = 6002, + Prop_HasControllerComponent_Bool = 6003, + Prop_HasCameraComponent_Bool = 6004, + Prop_HasDriverDirectModeComponent_Bool = 6005, + Prop_HasVirtualDisplayComponent_Bool = 6006, + Prop_HasSpatialAnchorsSupport_Bool = 6007, + Prop_ControllerType_String = 7000, + Prop_LegacyInputProfile_String = 7001, + Prop_ControllerHandSelectionPriority_Int32 = 7002, + Prop_VendorSpecific_Reserved_Start = 10000, + Prop_VendorSpecific_Reserved_End = 10999, + Prop_TrackedDeviceProperty_Max = 1000000, + } + public enum ETrackedPropertyError + { + TrackedProp_Success = 0, + TrackedProp_WrongDataType = 1, + TrackedProp_WrongDeviceClass = 2, + TrackedProp_BufferTooSmall = 3, + TrackedProp_UnknownProperty = 4, + TrackedProp_InvalidDevice = 5, + TrackedProp_CouldNotContactServer = 6, + TrackedProp_ValueNotProvidedByDevice = 7, + TrackedProp_StringExceedsMaximumLength = 8, + TrackedProp_NotYetAvailable = 9, + TrackedProp_PermissionDenied = 10, + TrackedProp_InvalidOperation = 11, + TrackedProp_CannotWriteToWildcards = 12, + TrackedProp_IPCReadFailure = 13, + } + public enum EVRSubmitFlags + { + Submit_Default = 0, + Submit_LensDistortionAlreadyApplied = 1, + Submit_GlRenderBuffer = 2, + Submit_Reserved = 4, + Submit_TextureWithPose = 8, + Submit_TextureWithDepth = 16, + } + public enum EVRState + { + Undefined = -1, + Off = 0, + Searching = 1, + Searching_Alert = 2, + Ready = 3, + Ready_Alert = 4, + NotReady = 5, + Standby = 6, + Ready_Alert_Low = 7, + } + public enum EVREventType + { + VREvent_None = 0, + VREvent_TrackedDeviceActivated = 100, + VREvent_TrackedDeviceDeactivated = 101, + VREvent_TrackedDeviceUpdated = 102, + VREvent_TrackedDeviceUserInteractionStarted = 103, + VREvent_TrackedDeviceUserInteractionEnded = 104, + VREvent_IpdChanged = 105, + VREvent_EnterStandbyMode = 106, + VREvent_LeaveStandbyMode = 107, + VREvent_TrackedDeviceRoleChanged = 108, + VREvent_WatchdogWakeUpRequested = 109, + VREvent_LensDistortionChanged = 110, + VREvent_PropertyChanged = 111, + VREvent_WirelessDisconnect = 112, + VREvent_WirelessReconnect = 113, + VREvent_ButtonPress = 200, + VREvent_ButtonUnpress = 201, + VREvent_ButtonTouch = 202, + VREvent_ButtonUntouch = 203, + VREvent_DualAnalog_Press = 250, + VREvent_DualAnalog_Unpress = 251, + VREvent_DualAnalog_Touch = 252, + VREvent_DualAnalog_Untouch = 253, + VREvent_DualAnalog_Move = 254, + VREvent_DualAnalog_ModeSwitch1 = 255, + VREvent_DualAnalog_ModeSwitch2 = 256, + VREvent_DualAnalog_Cancel = 257, + VREvent_MouseMove = 300, + VREvent_MouseButtonDown = 301, + VREvent_MouseButtonUp = 302, + VREvent_FocusEnter = 303, + VREvent_FocusLeave = 304, + VREvent_ScrollDiscrete = 305, + VREvent_TouchPadMove = 306, + VREvent_OverlayFocusChanged = 307, + VREvent_ReloadOverlays = 308, + VREvent_ScrollSmooth = 309, + VREvent_InputFocusCaptured = 400, + VREvent_InputFocusReleased = 401, + VREvent_SceneFocusLost = 402, + VREvent_SceneFocusGained = 403, + VREvent_SceneApplicationChanged = 404, + VREvent_SceneFocusChanged = 405, + VREvent_InputFocusChanged = 406, + VREvent_SceneApplicationSecondaryRenderingStarted = 407, + VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, + VREvent_ActionBindingReloaded = 409, + VREvent_HideRenderModels = 410, + VREvent_ShowRenderModels = 411, + VREvent_ConsoleOpened = 420, + VREvent_ConsoleClosed = 421, + VREvent_OverlayShown = 500, + VREvent_OverlayHidden = 501, + VREvent_DashboardActivated = 502, + VREvent_DashboardDeactivated = 503, + VREvent_DashboardRequested = 505, + VREvent_ResetDashboard = 506, + VREvent_RenderToast = 507, + VREvent_ImageLoaded = 508, + VREvent_ShowKeyboard = 509, + VREvent_HideKeyboard = 510, + VREvent_OverlayGamepadFocusGained = 511, + VREvent_OverlayGamepadFocusLost = 512, + VREvent_OverlaySharedTextureChanged = 513, + VREvent_ScreenshotTriggered = 516, + VREvent_ImageFailed = 517, + VREvent_DashboardOverlayCreated = 518, + VREvent_SwitchGamepadFocus = 519, + VREvent_RequestScreenshot = 520, + VREvent_ScreenshotTaken = 521, + VREvent_ScreenshotFailed = 522, + VREvent_SubmitScreenshotToDashboard = 523, + VREvent_ScreenshotProgressToDashboard = 524, + VREvent_PrimaryDashboardDeviceChanged = 525, + VREvent_RoomViewShown = 526, + VREvent_RoomViewHidden = 527, + VREvent_ShowUI = 528, + VREvent_ShowDevTools = 529, + VREvent_Notification_Shown = 600, + VREvent_Notification_Hidden = 601, + VREvent_Notification_BeginInteraction = 602, + VREvent_Notification_Destroyed = 603, + VREvent_Quit = 700, + VREvent_ProcessQuit = 701, + VREvent_QuitAborted_UserPrompt = 702, + VREvent_QuitAcknowledged = 703, + VREvent_DriverRequestedQuit = 704, + VREvent_RestartRequested = 705, + VREvent_ChaperoneDataHasChanged = 800, + VREvent_ChaperoneUniverseHasChanged = 801, + VREvent_ChaperoneTempDataHasChanged = 802, + VREvent_ChaperoneSettingsHaveChanged = 803, + VREvent_SeatedZeroPoseReset = 804, + VREvent_ChaperoneFlushCache = 805, + VREvent_AudioSettingsHaveChanged = 820, + VREvent_BackgroundSettingHasChanged = 850, + VREvent_CameraSettingsHaveChanged = 851, + VREvent_ReprojectionSettingHasChanged = 852, + VREvent_ModelSkinSettingsHaveChanged = 853, + VREvent_EnvironmentSettingsHaveChanged = 854, + VREvent_PowerSettingsHaveChanged = 855, + VREvent_EnableHomeAppSettingsHaveChanged = 856, + VREvent_SteamVRSectionSettingChanged = 857, + VREvent_LighthouseSectionSettingChanged = 858, + VREvent_NullSectionSettingChanged = 859, + VREvent_UserInterfaceSectionSettingChanged = 860, + VREvent_NotificationsSectionSettingChanged = 861, + VREvent_KeyboardSectionSettingChanged = 862, + VREvent_PerfSectionSettingChanged = 863, + VREvent_DashboardSectionSettingChanged = 864, + VREvent_WebInterfaceSectionSettingChanged = 865, + VREvent_TrackersSectionSettingChanged = 866, + VREvent_LastKnownSectionSettingChanged = 867, + VREvent_DismissedWarningsSectionSettingChanged = 868, + VREvent_StatusUpdate = 900, + VREvent_WebInterface_InstallDriverCompleted = 950, + VREvent_MCImageUpdated = 1000, + VREvent_FirmwareUpdateStarted = 1100, + VREvent_FirmwareUpdateFinished = 1101, + VREvent_KeyboardClosed = 1200, + VREvent_KeyboardCharInput = 1201, + VREvent_KeyboardDone = 1202, + VREvent_ApplicationTransitionStarted = 1300, + VREvent_ApplicationTransitionAborted = 1301, + VREvent_ApplicationTransitionNewAppStarted = 1302, + VREvent_ApplicationListUpdated = 1303, + VREvent_ApplicationMimeTypeLoad = 1304, + VREvent_ApplicationTransitionNewAppLaunchComplete = 1305, + VREvent_ProcessConnected = 1306, + VREvent_ProcessDisconnected = 1307, + VREvent_Compositor_MirrorWindowShown = 1400, + VREvent_Compositor_MirrorWindowHidden = 1401, + VREvent_Compositor_ChaperoneBoundsShown = 1410, + VREvent_Compositor_ChaperoneBoundsHidden = 1411, + VREvent_Compositor_DisplayDisconnected = 1412, + VREvent_Compositor_DisplayReconnected = 1413, + VREvent_Compositor_HDCPError = 1414, + VREvent_Compositor_ApplicationNotResponding = 1415, + VREvent_Compositor_ApplicationResumed = 1416, + VREvent_TrackedCamera_StartVideoStream = 1500, + VREvent_TrackedCamera_StopVideoStream = 1501, + VREvent_TrackedCamera_PauseVideoStream = 1502, + VREvent_TrackedCamera_ResumeVideoStream = 1503, + VREvent_TrackedCamera_EditingSurface = 1550, + VREvent_PerformanceTest_EnableCapture = 1600, + VREvent_PerformanceTest_DisableCapture = 1601, + VREvent_PerformanceTest_FidelityLevel = 1602, + VREvent_MessageOverlay_Closed = 1650, + VREvent_MessageOverlayCloseRequested = 1651, + VREvent_Input_HapticVibration = 1700, + VREvent_Input_BindingLoadFailed = 1701, + VREvent_Input_BindingLoadSuccessful = 1702, + VREvent_Input_ActionManifestReloaded = 1703, + VREvent_Input_ActionManifestLoadFailed = 1704, + VREvent_Input_ProgressUpdate = 1705, + VREvent_Input_TrackerActivated = 1706, + VREvent_Input_BindingsUpdated = 1707, + VREvent_SpatialAnchors_PoseUpdated = 1800, + VREvent_SpatialAnchors_DescriptorUpdated = 1801, + VREvent_SpatialAnchors_RequestPoseUpdate = 1802, + VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, + VREvent_SystemReport_Started = 1900, + VREvent_VendorSpecific_Reserved_Start = 10000, + VREvent_VendorSpecific_Reserved_End = 19999, + } + public enum EDeviceActivityLevel + { + k_EDeviceActivityLevel_Unknown = -1, + k_EDeviceActivityLevel_Idle = 0, + k_EDeviceActivityLevel_UserInteraction = 1, + k_EDeviceActivityLevel_UserInteraction_Timeout = 2, + k_EDeviceActivityLevel_Standby = 3, + } + public enum EVRButtonId + { + k_EButton_System = 0, + k_EButton_ApplicationMenu = 1, + k_EButton_Grip = 2, + k_EButton_DPad_Left = 3, + k_EButton_DPad_Up = 4, + k_EButton_DPad_Right = 5, + k_EButton_DPad_Down = 6, + k_EButton_A = 7, + k_EButton_ProximitySensor = 31, + k_EButton_Axis0 = 32, + k_EButton_Axis1 = 33, + k_EButton_Axis2 = 34, + k_EButton_Axis3 = 35, + k_EButton_Axis4 = 36, + k_EButton_SteamVR_Touchpad = 32, + k_EButton_SteamVR_Trigger = 33, + k_EButton_Dashboard_Back = 2, + k_EButton_Knuckles_A = 2, + k_EButton_Knuckles_B = 1, + k_EButton_Knuckles_JoyStick = 35, + k_EButton_Max = 64, + } + public enum EVRMouseButton + { + Left = 1, + Right = 2, + Middle = 4, + } + public enum EDualAnalogWhich + { + k_EDualAnalog_Left = 0, + k_EDualAnalog_Right = 1, + } + public enum EShowUIType + { + ShowUI_ControllerBinding = 0, + ShowUI_ManageTrackers = 1, + ShowUI_QuickStart = 2, + ShowUI_Pairing = 3, + ShowUI_Settings = 4, + } + public enum EHDCPError + { + None = 0, + LinkLost = 1, + Tampered = 2, + DeviceRevoked = 3, + Unknown = 4, + } + public enum EVRInputError + { + None = 0, + NameNotFound = 1, + WrongType = 2, + InvalidHandle = 3, + InvalidParam = 4, + NoSteam = 5, + MaxCapacityReached = 6, + IPCError = 7, + NoActiveActionSet = 8, + InvalidDevice = 9, + InvalidSkeleton = 10, + InvalidBoneCount = 11, + InvalidCompressedData = 12, + NoData = 13, + BufferTooSmall = 14, + MismatchedActionManifest = 15, + MissingSkeletonData = 16, + InvalidBoneIndex = 17, + } + public enum EVRSpatialAnchorError + { + Success = 0, + Internal = 1, + UnknownHandle = 2, + ArrayTooSmall = 3, + InvalidDescriptorChar = 4, + NotYetAvailable = 5, + NotAvailableInThisUniverse = 6, + PermanentlyUnavailable = 7, + WrongDriver = 8, + DescriptorTooLong = 9, + Unknown = 10, + NoRoomCalibration = 11, + InvalidArgument = 12, + UnknownDriver = 13, + } + public enum EHiddenAreaMeshType + { + k_eHiddenAreaMesh_Standard = 0, + k_eHiddenAreaMesh_Inverse = 1, + k_eHiddenAreaMesh_LineLoop = 2, + k_eHiddenAreaMesh_Max = 3, + } + public enum EVRControllerAxisType + { + k_eControllerAxis_None = 0, + k_eControllerAxis_TrackPad = 1, + k_eControllerAxis_Joystick = 2, + k_eControllerAxis_Trigger = 3, + } + public enum EVRControllerEventOutputType + { + ControllerEventOutput_OSEvents = 0, + ControllerEventOutput_VREvents = 1, + } + public enum ECollisionBoundsStyle + { + COLLISION_BOUNDS_STYLE_BEGINNER = 0, + COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1, + COLLISION_BOUNDS_STYLE_SQUARES = 2, + COLLISION_BOUNDS_STYLE_ADVANCED = 3, + COLLISION_BOUNDS_STYLE_NONE = 4, + COLLISION_BOUNDS_STYLE_COUNT = 5, + } + public enum EVROverlayError + { + None = 0, + UnknownOverlay = 10, + InvalidHandle = 11, + PermissionDenied = 12, + OverlayLimitExceeded = 13, + WrongVisibilityType = 14, + KeyTooLong = 15, + NameTooLong = 16, + KeyInUse = 17, + WrongTransformType = 18, + InvalidTrackedDevice = 19, + InvalidParameter = 20, + ThumbnailCantBeDestroyed = 21, + ArrayTooSmall = 22, + RequestFailed = 23, + InvalidTexture = 24, + UnableToLoadFile = 25, + KeyboardAlreadyInUse = 26, + NoNeighbor = 27, + TooManyMaskPrimitives = 29, + BadMaskPrimitive = 30, + TextureAlreadyLocked = 31, + TextureLockCapacityReached = 32, + TextureNotLocked = 33, + } + public enum EVRApplicationType + { + VRApplication_Other = 0, + VRApplication_Scene = 1, + VRApplication_Overlay = 2, + VRApplication_Background = 3, + VRApplication_Utility = 4, + VRApplication_VRMonitor = 5, + VRApplication_SteamWatchdog = 6, + VRApplication_Bootstrapper = 7, + VRApplication_WebHelper = 8, + VRApplication_Max = 9, + } + public enum EVRFirmwareError + { + None = 0, + Success = 1, + Fail = 2, + } + public enum EVRNotificationError + { + OK = 0, + InvalidNotificationId = 100, + NotificationQueueFull = 101, + InvalidOverlayHandle = 102, + SystemWithUserValueAlreadyExists = 103, + } + public enum EVRSkeletalMotionRange + { + WithController = 0, + WithoutController = 1, + } + public enum EVRSkeletalTrackingLevel + { + VRSkeletalTracking_Estimated = 0, + VRSkeletalTracking_Partial = 1, + VRSkeletalTracking_Full = 2, + Count = 3, + Max = 2, + } + public enum EVRInitError + { + None = 0, + Unknown = 1, + Init_InstallationNotFound = 100, + Init_InstallationCorrupt = 101, + Init_VRClientDLLNotFound = 102, + Init_FileNotFound = 103, + Init_FactoryNotFound = 104, + Init_InterfaceNotFound = 105, + Init_InvalidInterface = 106, + Init_UserConfigDirectoryInvalid = 107, + Init_HmdNotFound = 108, + Init_NotInitialized = 109, + Init_PathRegistryNotFound = 110, + Init_NoConfigPath = 111, + Init_NoLogPath = 112, + Init_PathRegistryNotWritable = 113, + Init_AppInfoInitFailed = 114, + Init_Retry = 115, + Init_InitCanceledByUser = 116, + Init_AnotherAppLaunching = 117, + Init_SettingsInitFailed = 118, + Init_ShuttingDown = 119, + Init_TooManyObjects = 120, + Init_NoServerForBackgroundApp = 121, + Init_NotSupportedWithCompositor = 122, + Init_NotAvailableToUtilityApps = 123, + Init_Internal = 124, + Init_HmdDriverIdIsNone = 125, + Init_HmdNotFoundPresenceFailed = 126, + Init_VRMonitorNotFound = 127, + Init_VRMonitorStartupFailed = 128, + Init_LowPowerWatchdogNotSupported = 129, + Init_InvalidApplicationType = 130, + Init_NotAvailableToWatchdogApps = 131, + Init_WatchdogDisabledInSettings = 132, + Init_VRDashboardNotFound = 133, + Init_VRDashboardStartupFailed = 134, + Init_VRHomeNotFound = 135, + Init_VRHomeStartupFailed = 136, + Init_RebootingBusy = 137, + Init_FirmwareUpdateBusy = 138, + Init_FirmwareRecoveryBusy = 139, + Init_USBServiceBusy = 140, + Init_VRWebHelperStartupFailed = 141, + Init_TrackerManagerInitFailed = 142, + Init_AlreadyRunning = 143, + Driver_Failed = 200, + Driver_Unknown = 201, + Driver_HmdUnknown = 202, + Driver_NotLoaded = 203, + Driver_RuntimeOutOfDate = 204, + Driver_HmdInUse = 205, + Driver_NotCalibrated = 206, + Driver_CalibrationInvalid = 207, + Driver_HmdDisplayNotFound = 208, + Driver_TrackedDeviceInterfaceUnknown = 209, + Driver_HmdDriverIdOutOfBounds = 211, + Driver_HmdDisplayMirrored = 212, + IPC_ServerInitFailed = 300, + IPC_ConnectFailed = 301, + IPC_SharedStateInitFailed = 302, + IPC_CompositorInitFailed = 303, + IPC_MutexInitFailed = 304, + IPC_Failed = 305, + IPC_CompositorConnectFailed = 306, + IPC_CompositorInvalidConnectResponse = 307, + IPC_ConnectFailedAfterMultipleAttempts = 308, + Compositor_Failed = 400, + Compositor_D3D11HardwareRequired = 401, + Compositor_FirmwareRequiresUpdate = 402, + Compositor_OverlayInitFailed = 403, + Compositor_ScreenshotsInitFailed = 404, + Compositor_UnableToCreateDevice = 405, + Compositor_SharedStateIsNull = 406, + Compositor_NotificationManagerIsNull = 407, + Compositor_ResourceManagerClientIsNull = 408, + Compositor_MessageOverlaySharedStateInitFailure = 409, + Compositor_PropertiesInterfaceIsNull = 410, + Compositor_CreateFullscreenWindowFailed = 411, + Compositor_SettingsInterfaceIsNull = 412, + Compositor_FailedToShowWindow = 413, + Compositor_DistortInterfaceIsNull = 414, + Compositor_DisplayFrequencyFailure = 415, + Compositor_RendererInitializationFailed = 416, + Compositor_DXGIFactoryInterfaceIsNull = 417, + Compositor_DXGIFactoryCreateFailed = 418, + Compositor_DXGIFactoryQueryFailed = 419, + Compositor_InvalidAdapterDesktop = 420, + Compositor_InvalidHmdAttachment = 421, + Compositor_InvalidOutputDesktop = 422, + Compositor_InvalidDeviceProvided = 423, + Compositor_D3D11RendererInitializationFailed = 424, + Compositor_FailedToFindDisplayMode = 425, + Compositor_FailedToCreateSwapChain = 426, + Compositor_FailedToGetBackBuffer = 427, + Compositor_FailedToCreateRenderTarget = 428, + Compositor_FailedToCreateDXGI2SwapChain = 429, + Compositor_FailedtoGetDXGI2BackBuffer = 430, + Compositor_FailedToCreateDXGI2RenderTarget = 431, + Compositor_FailedToGetDXGIDeviceInterface = 432, + Compositor_SelectDisplayMode = 433, + Compositor_FailedToCreateNvAPIRenderTargets = 434, + Compositor_NvAPISetDisplayMode = 435, + Compositor_FailedToCreateDirectModeDisplay = 436, + Compositor_InvalidHmdPropertyContainer = 437, + Compositor_UpdateDisplayFrequency = 438, + Compositor_CreateRasterizerState = 439, + Compositor_CreateWireframeRasterizerState = 440, + Compositor_CreateSamplerState = 441, + Compositor_CreateClampToBorderSamplerState = 442, + Compositor_CreateAnisoSamplerState = 443, + Compositor_CreateOverlaySamplerState = 444, + Compositor_CreatePanoramaSamplerState = 445, + Compositor_CreateFontSamplerState = 446, + Compositor_CreateNoBlendState = 447, + Compositor_CreateBlendState = 448, + Compositor_CreateAlphaBlendState = 449, + Compositor_CreateBlendStateMaskR = 450, + Compositor_CreateBlendStateMaskG = 451, + Compositor_CreateBlendStateMaskB = 452, + Compositor_CreateDepthStencilState = 453, + Compositor_CreateDepthStencilStateNoWrite = 454, + Compositor_CreateDepthStencilStateNoDepth = 455, + Compositor_CreateFlushTexture = 456, + Compositor_CreateDistortionSurfaces = 457, + Compositor_CreateConstantBuffer = 458, + Compositor_CreateHmdPoseConstantBuffer = 459, + Compositor_CreateHmdPoseStagingConstantBuffer = 460, + Compositor_CreateSharedFrameInfoConstantBuffer = 461, + Compositor_CreateOverlayConstantBuffer = 462, + Compositor_CreateSceneTextureIndexConstantBuffer = 463, + Compositor_CreateReadableSceneTextureIndexConstantBuffer = 464, + Compositor_CreateLayerGraphicsTextureIndexConstantBuffer = 465, + Compositor_CreateLayerComputeTextureIndexConstantBuffer = 466, + Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer = 467, + Compositor_CreateComputeHmdPoseConstantBuffer = 468, + Compositor_CreateGeomConstantBuffer = 469, + Compositor_CreatePanelMaskConstantBuffer = 470, + Compositor_CreatePixelSimUBO = 471, + Compositor_CreateMSAARenderTextures = 472, + Compositor_CreateResolveRenderTextures = 473, + Compositor_CreateComputeResolveRenderTextures = 474, + Compositor_CreateDriverDirectModeResolveTextures = 475, + Compositor_OpenDriverDirectModeResolveTextures = 476, + Compositor_CreateFallbackSyncTexture = 477, + Compositor_ShareFallbackSyncTexture = 478, + Compositor_CreateOverlayIndexBuffer = 479, + Compositor_CreateOverlayVertextBuffer = 480, + Compositor_CreateTextVertexBuffer = 481, + Compositor_CreateTextIndexBuffer = 482, + Compositor_CreateMirrorTextures = 483, + Compositor_CreateLastFrameRenderTexture = 484, + VendorSpecific_UnableToConnectToOculusRuntime = 1000, + VendorSpecific_WindowsNotInDevMode = 1001, + VendorSpecific_HmdFound_CantOpenDevice = 1101, + VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102, + VendorSpecific_HmdFound_NoStoredConfig = 1103, + VendorSpecific_HmdFound_ConfigTooBig = 1104, + VendorSpecific_HmdFound_ConfigTooSmall = 1105, + VendorSpecific_HmdFound_UnableToInitZLib = 1106, + VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107, + VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108, + VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109, + VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110, + VendorSpecific_HmdFound_UserDataAddressRange = 1111, + VendorSpecific_HmdFound_UserDataError = 1112, + VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113, + Steam_SteamInstallationNotFound = 2000, + LastError = 2001, + } + public enum EVRScreenshotType + { + None = 0, + Mono = 1, + Stereo = 2, + Cubemap = 3, + MonoPanorama = 4, + StereoPanorama = 5, + } + public enum EVRScreenshotPropertyFilenames + { + Preview = 0, + VR = 1, + } + public enum EVRTrackedCameraError + { + None = 0, + OperationFailed = 100, + InvalidHandle = 101, + InvalidFrameHeaderVersion = 102, + OutOfHandles = 103, + IPCFailure = 104, + NotSupportedForThisDevice = 105, + SharedMemoryFailure = 106, + FrameBufferingFailure = 107, + StreamSetupFailure = 108, + InvalidGLTextureId = 109, + InvalidSharedTextureHandle = 110, + FailedToGetGLTextureId = 111, + SharedTextureFailure = 112, + NoFrameAvailable = 113, + InvalidArgument = 114, + InvalidFrameBufferSize = 115, + } + public enum EVRTrackedCameraFrameLayout + { + Mono = 1, + Stereo = 2, + VerticalLayout = 16, + HorizontalLayout = 32, + } + public enum EVRTrackedCameraFrameType + { + Distorted = 0, + Undistorted = 1, + MaximumUndistorted = 2, + MAX_CAMERA_FRAME_TYPES = 3, + } + public enum EVRDistortionFunctionType + { + None = 0, + FTheta = 1, + Extended_FTheta = 2, + MAX_DISTORTION_FUNCTION_TYPES = 3, + } + public enum EVSync + { + None = 0, + WaitRender = 1, + NoWaitRender = 2, + } + public enum EVRMuraCorrectionMode + { + Default = 0, + NoCorrection = 1, + } + public enum Imu_OffScaleFlags + { + OffScale_AccelX = 1, + OffScale_AccelY = 2, + OffScale_AccelZ = 4, + OffScale_GyroX = 8, + OffScale_GyroY = 16, + OffScale_GyroZ = 32, + } + public enum EVRApplicationError + { + None = 0, + AppKeyAlreadyExists = 100, + NoManifest = 101, + NoApplication = 102, + InvalidIndex = 103, + UnknownApplication = 104, + IPCFailed = 105, + ApplicationAlreadyRunning = 106, + InvalidManifest = 107, + InvalidApplication = 108, + LaunchFailed = 109, + ApplicationAlreadyStarting = 110, + LaunchInProgress = 111, + OldApplicationQuitting = 112, + TransitionAborted = 113, + IsTemplate = 114, + SteamVRIsExiting = 115, + BufferTooSmall = 200, + PropertyNotSet = 201, + UnknownProperty = 202, + InvalidParameter = 203, + } + public enum EVRApplicationProperty + { + Name_String = 0, + LaunchType_String = 11, + WorkingDirectory_String = 12, + BinaryPath_String = 13, + Arguments_String = 14, + URL_String = 15, + Description_String = 50, + NewsURL_String = 51, + ImagePath_String = 52, + Source_String = 53, + ActionManifestURL_String = 54, + IsDashboardOverlay_Bool = 60, + IsTemplate_Bool = 61, + IsInstanced_Bool = 62, + IsInternal_Bool = 63, + WantsCompositorPauseInStandby_Bool = 64, + LastLaunchTime_Uint64 = 70, + } + public enum EVRApplicationTransitionState + { + VRApplicationTransition_None = 0, + VRApplicationTransition_OldAppQuitSent = 10, + VRApplicationTransition_WaitingForExternalLaunch = 11, + VRApplicationTransition_NewAppLaunched = 20, + } + public enum ChaperoneCalibrationState + { + OK = 1, + Warning = 100, + Warning_BaseStationMayHaveMoved = 101, + Warning_BaseStationRemoved = 102, + Warning_SeatedBoundsInvalid = 103, + Error = 200, + Error_BaseStationUninitialized = 201, + Error_BaseStationConflict = 202, + Error_PlayAreaInvalid = 203, + Error_CollisionBoundsInvalid = 204, + } + public enum EChaperoneConfigFile + { + Live = 1, + Temp = 2, + } + public enum EChaperoneImportFlags + { + EChaperoneImport_BoundsOnly = 1, + } + public enum EVRCompositorError + { + None = 0, + RequestFailed = 1, + IncompatibleVersion = 100, + DoNotHaveFocus = 101, + InvalidTexture = 102, + IsNotSceneApplication = 103, + TextureIsOnWrongDevice = 104, + TextureUsesUnsupportedFormat = 105, + SharedTexturesNotSupported = 106, + IndexOutOfRange = 107, + AlreadySubmitted = 108, + InvalidBounds = 109, + } + public enum EVRCompositorTimingMode + { + Implicit = 0, + Explicit_RuntimePerformsPostPresentHandoff = 1, + Explicit_ApplicationPerformsPostPresentHandoff = 2, + } + public enum VROverlayInputMethod + { + None = 0, + Mouse = 1, + DualAnalog = 2, + } + public enum VROverlayTransformType + { + VROverlayTransform_Absolute = 0, + VROverlayTransform_TrackedDeviceRelative = 1, + VROverlayTransform_SystemOverlay = 2, + VROverlayTransform_TrackedComponent = 3, + } + public enum VROverlayFlags + { + None = 0, + Curved = 1, + RGSS4X = 2, + NoDashboardTab = 3, + AcceptsGamepadEvents = 4, + ShowGamepadFocus = 5, + SendVRDiscreteScrollEvents = 6, + SendVRTouchpadEvents = 7, + ShowTouchPadScrollWheel = 8, + TransferOwnershipToInternalProcess = 9, + SideBySide_Parallel = 10, + SideBySide_Crossed = 11, + Panorama = 12, + StereoPanorama = 13, + SortWithNonSceneOverlays = 14, + VisibleInDashboard = 15, + MakeOverlaysInteractiveIfVisible = 16, + SendVRSmoothScrollEvents = 17, + } + public enum VRMessageOverlayResponse + { + ButtonPress_0 = 0, + ButtonPress_1 = 1, + ButtonPress_2 = 2, + ButtonPress_3 = 3, + CouldntFindSystemOverlay = 4, + CouldntFindOrCreateClientOverlay = 5, + ApplicationQuit = 6, + } + public enum EGamepadTextInputMode + { + k_EGamepadTextInputModeNormal = 0, + k_EGamepadTextInputModePassword = 1, + k_EGamepadTextInputModeSubmit = 2, + } + public enum EGamepadTextInputLineMode + { + k_EGamepadTextInputLineModeSingleLine = 0, + k_EGamepadTextInputLineModeMultipleLines = 1, + } + public enum EOverlayDirection + { + Up = 0, + Down = 1, + Left = 2, + Right = 3, + Count = 4, + } + public enum EVROverlayIntersectionMaskPrimitiveType + { + OverlayIntersectionPrimitiveType_Rectangle = 0, + OverlayIntersectionPrimitiveType_Circle = 1, + } + public enum EVRRenderModelError + { + None = 0, + Loading = 100, + NotSupported = 200, + InvalidArg = 300, + InvalidModel = 301, + NoShapes = 302, + MultipleShapes = 303, + TooManyVertices = 304, + MultipleTextures = 305, + BufferTooSmall = 306, + NotEnoughNormals = 307, + NotEnoughTexCoords = 308, + InvalidTexture = 400, + } + public enum EVRComponentProperty + { + IsStatic = 1, + IsVisible = 2, + IsTouched = 4, + IsPressed = 8, + IsScrolled = 16, + } + public enum EVRNotificationType + { + Transient = 0, + Persistent = 1, + Transient_SystemWithUserValue = 2, + } + public enum EVRNotificationStyle + { + None = 0, + Application = 100, + Contact_Disabled = 200, + Contact_Enabled = 201, + Contact_Active = 202, + } + public enum EVRSettingsError + { + None = 0, + IPCFailed = 1, + WriteFailed = 2, + ReadFailed = 3, + JsonParseFailed = 4, + UnsetSettingHasNoDefault = 5, + } + public enum EVRScreenshotError + { + None = 0, + RequestFailed = 1, + IncompatibleVersion = 100, + NotFound = 101, + BufferTooSmall = 102, + ScreenshotAlreadyInProgress = 108, + } + public enum EVRSkeletalTransformSpace + { + Model = 0, + Parent = 1, + } + public enum EVRSkeletalReferencePose + { + BindPose = 0, + OpenHand = 1, + Fist = 2, + GripLimit = 3, + } + public enum EVRFinger + { + Thumb = 0, + Index = 1, + Middle = 2, + Ring = 3, + Pinky = 4, + Count = 5, + } + public enum EVRFingerSplay + { + Thumb_Index = 0, + Index_Middle = 1, + Middle_Ring = 2, + Ring_Pinky = 3, + Count = 4, + } + public enum EVRInputFilterCancelType + { + VRInputFilterCancel_Timers = 0, + VRInputFilterCancel_Momentum = 1, + } + public enum EVRInputStringBits + { + VRInputString_Hand = 1, + VRInputString_ControllerType = 2, + VRInputString_InputSource = 4, + VRInputString_All = -1, + } + public enum EIOBufferError + { + IOBuffer_Success = 0, + IOBuffer_OperationFailed = 100, + IOBuffer_InvalidHandle = 101, + IOBuffer_InvalidArgument = 102, + IOBuffer_PathExists = 103, + IOBuffer_PathDoesNotExist = 104, + IOBuffer_Permission = 105, + } + public enum EIOBufferMode + { + Read = 1, + Write = 2, + Create = 512, + } + + [StructLayout(LayoutKind.Explicit)] + public struct VREvent_Data_t + { + [FieldOffset(0)] public VREvent_Reserved_t reserved; + [FieldOffset(0)] public VREvent_Controller_t controller; + [FieldOffset(0)] public VREvent_Mouse_t mouse; + [FieldOffset(0)] public VREvent_Scroll_t scroll; + [FieldOffset(0)] public VREvent_Process_t process; + [FieldOffset(0)] public VREvent_Notification_t notification; + [FieldOffset(0)] public VREvent_Overlay_t overlay; + [FieldOffset(0)] public VREvent_Status_t status; + [FieldOffset(0)] public VREvent_Ipd_t ipd; + [FieldOffset(0)] public VREvent_Chaperone_t chaperone; + [FieldOffset(0)] public VREvent_PerformanceTest_t performanceTest; + [FieldOffset(0)] public VREvent_TouchPadMove_t touchPadMove; + [FieldOffset(0)] public VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + [FieldOffset(0)] public VREvent_Screenshot_t screenshot; + [FieldOffset(0)] public VREvent_ScreenshotProgress_t screenshotProgress; + [FieldOffset(0)] public VREvent_ApplicationLaunch_t applicationLaunch; + [FieldOffset(0)] public VREvent_EditingCameraSurface_t cameraSurface; + [FieldOffset(0)] public VREvent_MessageOverlay_t messageOverlay; + [FieldOffset(0)] public VREvent_Property_t property; + [FieldOffset(0)] public VREvent_DualAnalog_t dualAnalog; + [FieldOffset(0)] public VREvent_HapticVibration_t hapticVibration; + [FieldOffset(0)] public VREvent_WebConsole_t webConsole; + [FieldOffset(0)] public VREvent_InputBindingLoad_t inputBinding; + [FieldOffset(0)] public VREvent_SpatialAnchor_t spatialAnchor; + [FieldOffset(0)] public VREvent_InputActionManifestLoad_t actionManifest; + [FieldOffset(0)] public VREvent_ProgressUpdate_t progressUpdate; + [FieldOffset(0)] public VREvent_ShowUI_t showUi; + [FieldOffset(0)] public VREvent_ShowDevTools_t showDevTools; + [FieldOffset(0)] public VREvent_HDCPError_t hdcpError; + [FieldOffset(0)] public VREvent_Keyboard_t keyboard; // This has to be at the end due to a mono bug + } + + + [StructLayout(LayoutKind.Explicit)] + public struct VROverlayIntersectionMaskPrimitive_Data_t + { + [FieldOffset(0)] public IntersectionMaskRectangle_t m_Rectangle; + [FieldOffset(0)] public IntersectionMaskCircle_t m_Circle; + } + + [StructLayout(LayoutKind.Sequential)] + public struct HmdMatrix34_t + { + public float m0; //float[3][4] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + public float m9; + public float m10; + public float m11; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdMatrix33_t + { + public float m0; //float[3][3] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdMatrix44_t + { + public float m0; //float[4][4] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + public float m9; + public float m10; + public float m11; + public float m12; + public float m13; + public float m14; + public float m15; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdVector3_t + { + public float v0; //float[3] + public float v1; + public float v2; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdVector4_t + { + public float v0; //float[4] + public float v1; + public float v2; + public float v3; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdVector3d_t + { + public double v0; //double[3] + public double v1; + public double v2; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdVector2_t + { + public float v0; //float[2] + public float v1; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdQuaternion_t + { + public double w; + public double x; + public double y; + public double z; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdQuaternionf_t + { + public float w; + public float x; + public float y; + public float z; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdColor_t + { + public float r; + public float g; + public float b; + public float a; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdQuad_t + { + public HmdVector3_t vCorners0; //HmdVector3_t[4] + public HmdVector3_t vCorners1; + public HmdVector3_t vCorners2; + public HmdVector3_t vCorners3; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdRect2_t + { + public HmdVector2_t vTopLeft; + public HmdVector2_t vBottomRight; + } + [StructLayout(LayoutKind.Sequential)] + public struct DistortionCoordinates_t + { + public float rfRed0; //float[2] + public float rfRed1; + public float rfGreen0; //float[2] + public float rfGreen1; + public float rfBlue0; //float[2] + public float rfBlue1; + } + [StructLayout(LayoutKind.Sequential)] + public struct Texture_t + { + public IntPtr handle; // void * + public ETextureType eType; + public EColorSpace eColorSpace; + } + [StructLayout(LayoutKind.Sequential)] + public struct TrackedDevicePose_t + { + public HmdMatrix34_t mDeviceToAbsoluteTracking; + public HmdVector3_t vVelocity; + public HmdVector3_t vAngularVelocity; + public ETrackingResult eTrackingResult; + [MarshalAs(UnmanagedType.I1)] + public bool bPoseIsValid; + [MarshalAs(UnmanagedType.I1)] + public bool bDeviceIsConnected; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureBounds_t + { + public float uMin; + public float vMin; + public float uMax; + public float vMax; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureWithPose_t + { + public HmdMatrix34_t mDeviceToAbsoluteTracking; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureDepthInfo_t + { + public IntPtr handle; // void * + public HmdMatrix44_t mProjection; + public HmdVector2_t vRange; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureWithDepth_t + { + public VRTextureDepthInfo_t depth; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureWithPoseAndDepth_t + { + public VRTextureDepthInfo_t depth; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRVulkanTextureData_t + { + public ulong m_nImage; + public IntPtr m_pDevice; // struct VkDevice_T * + public IntPtr m_pPhysicalDevice; // struct VkPhysicalDevice_T * + public IntPtr m_pInstance; // struct VkInstance_T * + public IntPtr m_pQueue; // struct VkQueue_T * + public uint m_nQueueFamilyIndex; + public uint m_nWidth; + public uint m_nHeight; + public uint m_nFormat; + public uint m_nSampleCount; + } + [StructLayout(LayoutKind.Sequential)] + public struct D3D12TextureData_t + { + public IntPtr m_pResource; // struct ID3D12Resource * + public IntPtr m_pCommandQueue; // struct ID3D12CommandQueue * + public uint m_nNodeMask; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Controller_t + { + public uint button; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Mouse_t + { + public float x; + public float y; + public uint button; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Scroll_t + { + public float xdelta; + public float ydelta; + public uint unused; + public float viewportscale; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_TouchPadMove_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bFingerDown; + public float flSecondsFingerDown; + public float fValueXFirst; + public float fValueYFirst; + public float fValueXRaw; + public float fValueYRaw; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Notification_t + { + public ulong ulUserValue; + public uint notificationId; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Process_t + { + public uint pid; + public uint oldPid; + [MarshalAs(UnmanagedType.I1)] + public bool bForced; + [MarshalAs(UnmanagedType.I1)] + public bool bConnectionLost; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Overlay_t + { + public ulong overlayHandle; + public ulong devicePath; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Status_t + { + public uint statusState; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Keyboard_t + { + public byte cNewInput0, cNewInput1, cNewInput2, cNewInput3, cNewInput4, cNewInput5, cNewInput6, cNewInput7; + public string cNewInput + { + get + { + return new string(new char[] { + (char)cNewInput0, + (char)cNewInput1, + (char)cNewInput2, + (char)cNewInput3, + (char)cNewInput4, + (char)cNewInput5, + (char)cNewInput6, + (char)cNewInput7 + }).TrimEnd('\0'); + } + } + public ulong uUserValue; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Ipd_t + { + public float ipdMeters; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Chaperone_t + { + public ulong m_nPreviousUniverse; + public ulong m_nCurrentUniverse; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Reserved_t + { + public ulong reserved0; + public ulong reserved1; + public ulong reserved2; + public ulong reserved3; + public ulong reserved4; + public ulong reserved5; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_PerformanceTest_t + { + public uint m_nFidelityLevel; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_SeatedZeroPoseReset_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bResetBySystemMenu; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Screenshot_t + { + public uint handle; + public uint type; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ScreenshotProgress_t + { + public float progress; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ApplicationLaunch_t + { + public uint pid; + public uint unArgsHandle; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_EditingCameraSurface_t + { + public ulong overlayHandle; + public uint nVisualMode; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_MessageOverlay_t + { + public uint unVRMessageOverlayResponse; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Property_t + { + public ulong container; + public ETrackedDeviceProperty prop; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_DualAnalog_t + { + public float x; + public float y; + public float transformedX; + public float transformedY; + public EDualAnalogWhich which; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_HapticVibration_t + { + public ulong containerHandle; + public ulong componentHandle; + public float fDurationSeconds; + public float fFrequency; + public float fAmplitude; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_WebConsole_t + { + public ulong webConsoleHandle; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_InputBindingLoad_t + { + public ulong ulAppContainer; + public ulong pathMessage; + public ulong pathUrl; + public ulong pathControllerType; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_InputActionManifestLoad_t + { + public ulong pathAppKey; + public ulong pathMessage; + public ulong pathMessageParam; + public ulong pathManifestPath; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_SpatialAnchor_t + { + public uint unHandle; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ProgressUpdate_t + { + public ulong ulApplicationPropertyContainer; + public ulong pathDevice; + public ulong pathInputSource; + public ulong pathProgressAction; + public ulong pathIcon; + public float fProgress; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ShowUI_t + { + public EShowUIType eType; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ShowDevTools_t + { + public int nBrowserIdentifier; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_HDCPError_t + { + public EHDCPError eCode; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_t + { + public uint eventType; + public uint trackedDeviceIndex; + public float eventAgeSeconds; + public VREvent_Data_t data; + } + // This structure is for backwards binary compatibility on Linux and OSX only + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct VREvent_t_Packed + { + public uint eventType; + public uint trackedDeviceIndex; + public float eventAgeSeconds; + public VREvent_Data_t data; + public VREvent_t_Packed(VREvent_t unpacked) + { + this.eventType = unpacked.eventType; + this.trackedDeviceIndex = unpacked.trackedDeviceIndex; + this.eventAgeSeconds = unpacked.eventAgeSeconds; + this.data = unpacked.data; + } + public void Unpack(ref VREvent_t unpacked) + { + unpacked.eventType = this.eventType; + unpacked.trackedDeviceIndex = this.trackedDeviceIndex; + unpacked.eventAgeSeconds = this.eventAgeSeconds; + unpacked.data = this.data; + } + } + [StructLayout(LayoutKind.Sequential)] + public struct HiddenAreaMesh_t + { + public IntPtr pVertexData; // const struct vr::HmdVector2_t * + public uint unTriangleCount; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRControllerAxis_t + { + public float x; + public float y; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRControllerState_t + { + public uint unPacketNum; + public ulong ulButtonPressed; + public ulong ulButtonTouched; + public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5] + public VRControllerAxis_t rAxis1; + public VRControllerAxis_t rAxis2; + public VRControllerAxis_t rAxis3; + public VRControllerAxis_t rAxis4; + } + // This structure is for backwards binary compatibility on Linux and OSX only + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct VRControllerState_t_Packed + { + public uint unPacketNum; + public ulong ulButtonPressed; + public ulong ulButtonTouched; + public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5] + public VRControllerAxis_t rAxis1; + public VRControllerAxis_t rAxis2; + public VRControllerAxis_t rAxis3; + public VRControllerAxis_t rAxis4; + public VRControllerState_t_Packed(VRControllerState_t unpacked) + { + this.unPacketNum = unpacked.unPacketNum; + this.ulButtonPressed = unpacked.ulButtonPressed; + this.ulButtonTouched = unpacked.ulButtonTouched; + this.rAxis0 = unpacked.rAxis0; + this.rAxis1 = unpacked.rAxis1; + this.rAxis2 = unpacked.rAxis2; + this.rAxis3 = unpacked.rAxis3; + this.rAxis4 = unpacked.rAxis4; + } + public void Unpack(ref VRControllerState_t unpacked) + { + unpacked.unPacketNum = this.unPacketNum; + unpacked.ulButtonPressed = this.ulButtonPressed; + unpacked.ulButtonTouched = this.ulButtonTouched; + unpacked.rAxis0 = this.rAxis0; + unpacked.rAxis1 = this.rAxis1; + unpacked.rAxis2 = this.rAxis2; + unpacked.rAxis3 = this.rAxis3; + unpacked.rAxis4 = this.rAxis4; + } + } + [StructLayout(LayoutKind.Sequential)] + public struct Compositor_OverlaySettings + { + public uint size; + [MarshalAs(UnmanagedType.I1)] + public bool curved; + [MarshalAs(UnmanagedType.I1)] + public bool antialias; + public float scale; + public float distance; + public float alpha; + public float uOffset; + public float vOffset; + public float uScale; + public float vScale; + public float gridDivs; + public float gridWidth; + public float gridScale; + public HmdMatrix44_t transform; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRBoneTransform_t + { + public HmdVector4_t position; + public HmdQuaternionf_t orientation; + } + [StructLayout(LayoutKind.Sequential)] + public struct CameraVideoStreamFrameHeader_t + { + public EVRTrackedCameraFrameType eFrameType; + public uint nWidth; + public uint nHeight; + public uint nBytesPerPixel; + public uint nFrameSequence; + public TrackedDevicePose_t standingTrackedDevicePose; + public ulong ulFrameExposureTime; + } + [StructLayout(LayoutKind.Sequential)] + public struct DriverDirectMode_FrameTiming + { + public uint m_nSize; + public uint m_nNumFramePresents; + public uint m_nNumMisPresented; + public uint m_nNumDroppedFrames; + public uint m_nReprojectionFlags; + } + [StructLayout(LayoutKind.Sequential)] + public struct ImuSample_t + { + public double fSampleTime; + public HmdVector3d_t vAccel; + public HmdVector3d_t vGyro; + public uint unOffScaleFlags; + } + [StructLayout(LayoutKind.Sequential)] + public struct AppOverrideKeys_t + { + public IntPtr pchKey; // const char * + public IntPtr pchValue; // const char * + } + [StructLayout(LayoutKind.Sequential)] + public struct Compositor_FrameTiming + { + public uint m_nSize; + public uint m_nFrameIndex; + public uint m_nNumFramePresents; + public uint m_nNumMisPresented; + public uint m_nNumDroppedFrames; + public uint m_nReprojectionFlags; + public double m_flSystemTimeInSeconds; + public float m_flPreSubmitGpuMs; + public float m_flPostSubmitGpuMs; + public float m_flTotalRenderGpuMs; + public float m_flCompositorRenderGpuMs; + public float m_flCompositorRenderCpuMs; + public float m_flCompositorIdleCpuMs; + public float m_flClientFrameIntervalMs; + public float m_flPresentCallCpuMs; + public float m_flWaitForPresentCpuMs; + public float m_flSubmitFrameMs; + public float m_flWaitGetPosesCalledMs; + public float m_flNewPosesReadyMs; + public float m_flNewFrameReadyMs; + public float m_flCompositorUpdateStartMs; + public float m_flCompositorUpdateEndMs; + public float m_flCompositorRenderStartMs; + public TrackedDevicePose_t m_HmdPose; + public uint m_nNumVSyncsReadyForUse; + public uint m_nNumVSyncsToFirstView; + } + [StructLayout(LayoutKind.Sequential)] + public struct Compositor_CumulativeStats + { + public uint m_nPid; + public uint m_nNumFramePresents; + public uint m_nNumDroppedFrames; + public uint m_nNumReprojectedFrames; + public uint m_nNumFramePresentsOnStartup; + public uint m_nNumDroppedFramesOnStartup; + public uint m_nNumReprojectedFramesOnStartup; + public uint m_nNumLoading; + public uint m_nNumFramePresentsLoading; + public uint m_nNumDroppedFramesLoading; + public uint m_nNumReprojectedFramesLoading; + public uint m_nNumTimedOut; + public uint m_nNumFramePresentsTimedOut; + public uint m_nNumDroppedFramesTimedOut; + public uint m_nNumReprojectedFramesTimedOut; + } + [StructLayout(LayoutKind.Sequential)] + public struct VROverlayIntersectionParams_t + { + public HmdVector3_t vSource; + public HmdVector3_t vDirection; + public ETrackingUniverseOrigin eOrigin; + } + [StructLayout(LayoutKind.Sequential)] + public struct VROverlayIntersectionResults_t + { + public HmdVector3_t vPoint; + public HmdVector3_t vNormal; + public HmdVector2_t vUVs; + public float fDistance; + } + [StructLayout(LayoutKind.Sequential)] + public struct IntersectionMaskRectangle_t + { + public float m_flTopLeftX; + public float m_flTopLeftY; + public float m_flWidth; + public float m_flHeight; + } + [StructLayout(LayoutKind.Sequential)] + public struct IntersectionMaskCircle_t + { + public float m_flCenterX; + public float m_flCenterY; + public float m_flRadius; + } + [StructLayout(LayoutKind.Sequential)] + public struct VROverlayIntersectionMaskPrimitive_t + { + public EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType; + public VROverlayIntersectionMaskPrimitive_Data_t m_Primitive; + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_ComponentState_t + { + public HmdMatrix34_t mTrackingToComponentRenderModel; + public HmdMatrix34_t mTrackingToComponentLocal; + public uint uProperties; + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_Vertex_t + { + public HmdVector3_t vPosition; + public HmdVector3_t vNormal; + public float rfTextureCoord0; //float[2] + public float rfTextureCoord1; + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_TextureMap_t + { + public ushort unWidth; + public ushort unHeight; + public IntPtr rubTextureMapData; // const uint8_t * + } + // This structure is for backwards binary compatibility on Linux and OSX only + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct RenderModel_TextureMap_t_Packed + { + public ushort unWidth; + public ushort unHeight; + public IntPtr rubTextureMapData; // const uint8_t * + public RenderModel_TextureMap_t_Packed(RenderModel_TextureMap_t unpacked) + { + this.unWidth = unpacked.unWidth; + this.unHeight = unpacked.unHeight; + this.rubTextureMapData = unpacked.rubTextureMapData; + } + public void Unpack(ref RenderModel_TextureMap_t unpacked) + { + unpacked.unWidth = this.unWidth; + unpacked.unHeight = this.unHeight; + unpacked.rubTextureMapData = this.rubTextureMapData; + } + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_t + { + public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t * + public uint unVertexCount; + public IntPtr rIndexData; // const uint16_t * + public uint unTriangleCount; + public int diffuseTextureId; + } + // This structure is for backwards binary compatibility on Linux and OSX only + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct RenderModel_t_Packed + { + public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t * + public uint unVertexCount; + public IntPtr rIndexData; // const uint16_t * + public uint unTriangleCount; + public int diffuseTextureId; + public RenderModel_t_Packed(RenderModel_t unpacked) + { + this.rVertexData = unpacked.rVertexData; + this.unVertexCount = unpacked.unVertexCount; + this.rIndexData = unpacked.rIndexData; + this.unTriangleCount = unpacked.unTriangleCount; + this.diffuseTextureId = unpacked.diffuseTextureId; + } + public void Unpack(ref RenderModel_t unpacked) + { + unpacked.rVertexData = this.rVertexData; + unpacked.unVertexCount = this.unVertexCount; + unpacked.rIndexData = this.rIndexData; + unpacked.unTriangleCount = this.unTriangleCount; + unpacked.diffuseTextureId = this.diffuseTextureId; + } + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_ControllerMode_State_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bScrollWheelVisible; + } + [StructLayout(LayoutKind.Sequential)] + public struct NotificationBitmap_t + { + public IntPtr m_pImageData; // void * + public int m_nWidth; + public int m_nHeight; + public int m_nBytesPerPixel; + } + [StructLayout(LayoutKind.Sequential)] + public struct CVRSettingHelper + { + public IntPtr m_pSettings; // class vr::IVRSettings * + } + [StructLayout(LayoutKind.Sequential)] + public struct InputAnalogActionData_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + public float x; + public float y; + public float z; + public float deltaX; + public float deltaY; + public float deltaZ; + public float fUpdateTime; + } + [StructLayout(LayoutKind.Sequential)] + public struct InputDigitalActionData_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + [MarshalAs(UnmanagedType.I1)] + public bool bState; + [MarshalAs(UnmanagedType.I1)] + public bool bChanged; + public float fUpdateTime; + } + [StructLayout(LayoutKind.Sequential)] + public struct InputPoseActionData_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + public TrackedDevicePose_t pose; + } + [StructLayout(LayoutKind.Sequential)] + public struct InputSkeletalActionData_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + } + [StructLayout(LayoutKind.Sequential)] + public struct InputOriginInfo_t + { + public ulong devicePath; + public uint trackedDeviceIndex; + public byte rchRenderModelComponentName0, rchRenderModelComponentName1, rchRenderModelComponentName2, rchRenderModelComponentName3, rchRenderModelComponentName4, rchRenderModelComponentName5, rchRenderModelComponentName6, rchRenderModelComponentName7, rchRenderModelComponentName8, rchRenderModelComponentName9, rchRenderModelComponentName10, rchRenderModelComponentName11, rchRenderModelComponentName12, rchRenderModelComponentName13, rchRenderModelComponentName14, rchRenderModelComponentName15, rchRenderModelComponentName16, rchRenderModelComponentName17, rchRenderModelComponentName18, rchRenderModelComponentName19, rchRenderModelComponentName20, rchRenderModelComponentName21, rchRenderModelComponentName22, rchRenderModelComponentName23, rchRenderModelComponentName24, rchRenderModelComponentName25, rchRenderModelComponentName26, rchRenderModelComponentName27, rchRenderModelComponentName28, rchRenderModelComponentName29, rchRenderModelComponentName30, rchRenderModelComponentName31, rchRenderModelComponentName32, rchRenderModelComponentName33, rchRenderModelComponentName34, rchRenderModelComponentName35, rchRenderModelComponentName36, rchRenderModelComponentName37, rchRenderModelComponentName38, rchRenderModelComponentName39, rchRenderModelComponentName40, rchRenderModelComponentName41, rchRenderModelComponentName42, rchRenderModelComponentName43, rchRenderModelComponentName44, rchRenderModelComponentName45, rchRenderModelComponentName46, rchRenderModelComponentName47, rchRenderModelComponentName48, rchRenderModelComponentName49, rchRenderModelComponentName50, rchRenderModelComponentName51, rchRenderModelComponentName52, rchRenderModelComponentName53, rchRenderModelComponentName54, rchRenderModelComponentName55, rchRenderModelComponentName56, rchRenderModelComponentName57, rchRenderModelComponentName58, rchRenderModelComponentName59, rchRenderModelComponentName60, rchRenderModelComponentName61, rchRenderModelComponentName62, rchRenderModelComponentName63, rchRenderModelComponentName64, rchRenderModelComponentName65, rchRenderModelComponentName66, rchRenderModelComponentName67, rchRenderModelComponentName68, rchRenderModelComponentName69, rchRenderModelComponentName70, rchRenderModelComponentName71, rchRenderModelComponentName72, rchRenderModelComponentName73, rchRenderModelComponentName74, rchRenderModelComponentName75, rchRenderModelComponentName76, rchRenderModelComponentName77, rchRenderModelComponentName78, rchRenderModelComponentName79, rchRenderModelComponentName80, rchRenderModelComponentName81, rchRenderModelComponentName82, rchRenderModelComponentName83, rchRenderModelComponentName84, rchRenderModelComponentName85, rchRenderModelComponentName86, rchRenderModelComponentName87, rchRenderModelComponentName88, rchRenderModelComponentName89, rchRenderModelComponentName90, rchRenderModelComponentName91, rchRenderModelComponentName92, rchRenderModelComponentName93, rchRenderModelComponentName94, rchRenderModelComponentName95, rchRenderModelComponentName96, rchRenderModelComponentName97, rchRenderModelComponentName98, rchRenderModelComponentName99, rchRenderModelComponentName100, rchRenderModelComponentName101, rchRenderModelComponentName102, rchRenderModelComponentName103, rchRenderModelComponentName104, rchRenderModelComponentName105, rchRenderModelComponentName106, rchRenderModelComponentName107, rchRenderModelComponentName108, rchRenderModelComponentName109, rchRenderModelComponentName110, rchRenderModelComponentName111, rchRenderModelComponentName112, rchRenderModelComponentName113, rchRenderModelComponentName114, rchRenderModelComponentName115, rchRenderModelComponentName116, rchRenderModelComponentName117, rchRenderModelComponentName118, rchRenderModelComponentName119, rchRenderModelComponentName120, rchRenderModelComponentName121, rchRenderModelComponentName122, rchRenderModelComponentName123, rchRenderModelComponentName124, rchRenderModelComponentName125, rchRenderModelComponentName126, rchRenderModelComponentName127; + public string rchRenderModelComponentName + { + get + { + return new string(new char[] { + (char)rchRenderModelComponentName0, + (char)rchRenderModelComponentName1, + (char)rchRenderModelComponentName2, + (char)rchRenderModelComponentName3, + (char)rchRenderModelComponentName4, + (char)rchRenderModelComponentName5, + (char)rchRenderModelComponentName6, + (char)rchRenderModelComponentName7, + (char)rchRenderModelComponentName8, + (char)rchRenderModelComponentName9, + (char)rchRenderModelComponentName10, + (char)rchRenderModelComponentName11, + (char)rchRenderModelComponentName12, + (char)rchRenderModelComponentName13, + (char)rchRenderModelComponentName14, + (char)rchRenderModelComponentName15, + (char)rchRenderModelComponentName16, + (char)rchRenderModelComponentName17, + (char)rchRenderModelComponentName18, + (char)rchRenderModelComponentName19, + (char)rchRenderModelComponentName20, + (char)rchRenderModelComponentName21, + (char)rchRenderModelComponentName22, + (char)rchRenderModelComponentName23, + (char)rchRenderModelComponentName24, + (char)rchRenderModelComponentName25, + (char)rchRenderModelComponentName26, + (char)rchRenderModelComponentName27, + (char)rchRenderModelComponentName28, + (char)rchRenderModelComponentName29, + (char)rchRenderModelComponentName30, + (char)rchRenderModelComponentName31, + (char)rchRenderModelComponentName32, + (char)rchRenderModelComponentName33, + (char)rchRenderModelComponentName34, + (char)rchRenderModelComponentName35, + (char)rchRenderModelComponentName36, + (char)rchRenderModelComponentName37, + (char)rchRenderModelComponentName38, + (char)rchRenderModelComponentName39, + (char)rchRenderModelComponentName40, + (char)rchRenderModelComponentName41, + (char)rchRenderModelComponentName42, + (char)rchRenderModelComponentName43, + (char)rchRenderModelComponentName44, + (char)rchRenderModelComponentName45, + (char)rchRenderModelComponentName46, + (char)rchRenderModelComponentName47, + (char)rchRenderModelComponentName48, + (char)rchRenderModelComponentName49, + (char)rchRenderModelComponentName50, + (char)rchRenderModelComponentName51, + (char)rchRenderModelComponentName52, + (char)rchRenderModelComponentName53, + (char)rchRenderModelComponentName54, + (char)rchRenderModelComponentName55, + (char)rchRenderModelComponentName56, + (char)rchRenderModelComponentName57, + (char)rchRenderModelComponentName58, + (char)rchRenderModelComponentName59, + (char)rchRenderModelComponentName60, + (char)rchRenderModelComponentName61, + (char)rchRenderModelComponentName62, + (char)rchRenderModelComponentName63, + (char)rchRenderModelComponentName64, + (char)rchRenderModelComponentName65, + (char)rchRenderModelComponentName66, + (char)rchRenderModelComponentName67, + (char)rchRenderModelComponentName68, + (char)rchRenderModelComponentName69, + (char)rchRenderModelComponentName70, + (char)rchRenderModelComponentName71, + (char)rchRenderModelComponentName72, + (char)rchRenderModelComponentName73, + (char)rchRenderModelComponentName74, + (char)rchRenderModelComponentName75, + (char)rchRenderModelComponentName76, + (char)rchRenderModelComponentName77, + (char)rchRenderModelComponentName78, + (char)rchRenderModelComponentName79, + (char)rchRenderModelComponentName80, + (char)rchRenderModelComponentName81, + (char)rchRenderModelComponentName82, + (char)rchRenderModelComponentName83, + (char)rchRenderModelComponentName84, + (char)rchRenderModelComponentName85, + (char)rchRenderModelComponentName86, + (char)rchRenderModelComponentName87, + (char)rchRenderModelComponentName88, + (char)rchRenderModelComponentName89, + (char)rchRenderModelComponentName90, + (char)rchRenderModelComponentName91, + (char)rchRenderModelComponentName92, + (char)rchRenderModelComponentName93, + (char)rchRenderModelComponentName94, + (char)rchRenderModelComponentName95, + (char)rchRenderModelComponentName96, + (char)rchRenderModelComponentName97, + (char)rchRenderModelComponentName98, + (char)rchRenderModelComponentName99, + (char)rchRenderModelComponentName100, + (char)rchRenderModelComponentName101, + (char)rchRenderModelComponentName102, + (char)rchRenderModelComponentName103, + (char)rchRenderModelComponentName104, + (char)rchRenderModelComponentName105, + (char)rchRenderModelComponentName106, + (char)rchRenderModelComponentName107, + (char)rchRenderModelComponentName108, + (char)rchRenderModelComponentName109, + (char)rchRenderModelComponentName110, + (char)rchRenderModelComponentName111, + (char)rchRenderModelComponentName112, + (char)rchRenderModelComponentName113, + (char)rchRenderModelComponentName114, + (char)rchRenderModelComponentName115, + (char)rchRenderModelComponentName116, + (char)rchRenderModelComponentName117, + (char)rchRenderModelComponentName118, + (char)rchRenderModelComponentName119, + (char)rchRenderModelComponentName120, + (char)rchRenderModelComponentName121, + (char)rchRenderModelComponentName122, + (char)rchRenderModelComponentName123, + (char)rchRenderModelComponentName124, + (char)rchRenderModelComponentName125, + (char)rchRenderModelComponentName126, + (char)rchRenderModelComponentName127 + }).TrimEnd('\0'); + } + } + } + [StructLayout(LayoutKind.Sequential)] + public struct VRActiveActionSet_t + { + public ulong ulActionSet; + public ulong ulRestrictedToDevice; + public ulong ulSecondaryActionSet; + public uint unPadding; + public int nPriority; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRSkeletalSummaryData_t + { + public float flFingerCurl0; //float[5] + public float flFingerCurl1; + public float flFingerCurl2; + public float flFingerCurl3; + public float flFingerCurl4; + public float flFingerSplay0; //float[4] + public float flFingerSplay1; + public float flFingerSplay2; + public float flFingerSplay3; + } + [StructLayout(LayoutKind.Sequential)] + public struct SpatialAnchorPose_t + { + public HmdMatrix34_t mAnchorToAbsoluteTracking; + } + [StructLayout(LayoutKind.Sequential)] + public struct COpenVRContext + { + public IntPtr m_pVRSystem; // class vr::IVRSystem * + public IntPtr m_pVRChaperone; // class vr::IVRChaperone * + public IntPtr m_pVRChaperoneSetup; // class vr::IVRChaperoneSetup * + public IntPtr m_pVRCompositor; // class vr::IVRCompositor * + public IntPtr m_pVROverlay; // class vr::IVROverlay * + public IntPtr m_pVRResources; // class vr::IVRResources * + public IntPtr m_pVRRenderModels; // class vr::IVRRenderModels * + public IntPtr m_pVRExtendedDisplay; // class vr::IVRExtendedDisplay * + public IntPtr m_pVRSettings; // class vr::IVRSettings * + public IntPtr m_pVRApplications; // class vr::IVRApplications * + public IntPtr m_pVRTrackedCamera; // class vr::IVRTrackedCamera * + public IntPtr m_pVRScreenshots; // class vr::IVRScreenshots * + public IntPtr m_pVRDriverManager; // class vr::IVRDriverManager * + public IntPtr m_pVRInput; // class vr::IVRInput * + public IntPtr m_pVRIOBuffer; // class vr::IVRIOBuffer * + public IntPtr m_pVRSpatialAnchors; // class vr::IVRSpatialAnchors * + public IntPtr m_pVRNotifications; // class vr::IVRNotifications * + } + + public class OpenVR + { + + public static uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType) + { + return OpenVRInterop.InitInternal(ref peError, eApplicationType); + } + + public static uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType, string pchStartupInfo) + { + return OpenVRInterop.InitInternal2(ref peError, eApplicationType, pchStartupInfo); + } + + public static void ShutdownInternal() + { + OpenVRInterop.ShutdownInternal(); + } + + public static bool IsHmdPresent() + { + return OpenVRInterop.IsHmdPresent(); + } + + public static bool IsRuntimeInstalled() + { + return OpenVRInterop.IsRuntimeInstalled(); + } + + public static string RuntimePath() + { + return OpenVRInterop.RuntimePath(); + } + + public static string GetStringForHmdError(EVRInitError error) + { + return Marshal.PtrToStringAnsi(OpenVRInterop.GetStringForHmdError(error)); + } + + public static IntPtr GetGenericInterface(string pchInterfaceVersion, ref EVRInitError peError) + { + return OpenVRInterop.GetGenericInterface(pchInterfaceVersion, ref peError); + } + + public static bool IsInterfaceVersionValid(string pchInterfaceVersion) + { + return OpenVRInterop.IsInterfaceVersionValid(pchInterfaceVersion); + } + + public static uint GetInitToken() + { + return OpenVRInterop.GetInitToken(); + } + + public const uint k_nDriverNone = 4294967295; + public const uint k_unMaxDriverDebugResponseSize = 32768; + public const uint k_unTrackedDeviceIndex_Hmd = 0; + public const uint k_unMaxTrackedDeviceCount = 64; + public const uint k_unTrackedDeviceIndexOther = 4294967294; + public const uint k_unTrackedDeviceIndexInvalid = 4294967295; + public const ulong k_ulInvalidPropertyContainer = 0; + public const uint k_unInvalidPropertyTag = 0; + public const ulong k_ulInvalidDriverHandle = 0; + public const uint k_unFloatPropertyTag = 1; + public const uint k_unInt32PropertyTag = 2; + public const uint k_unUint64PropertyTag = 3; + public const uint k_unBoolPropertyTag = 4; + public const uint k_unStringPropertyTag = 5; + public const uint k_unHmdMatrix34PropertyTag = 20; + public const uint k_unHmdMatrix44PropertyTag = 21; + public const uint k_unHmdVector3PropertyTag = 22; + public const uint k_unHmdVector4PropertyTag = 23; + public const uint k_unHmdVector2PropertyTag = 24; + public const uint k_unHmdQuadPropertyTag = 25; + public const uint k_unHiddenAreaPropertyTag = 30; + public const uint k_unPathHandleInfoTag = 31; + public const uint k_unActionPropertyTag = 32; + public const uint k_unInputValuePropertyTag = 33; + public const uint k_unWildcardPropertyTag = 34; + public const uint k_unHapticVibrationPropertyTag = 35; + public const uint k_unSkeletonPropertyTag = 36; + public const uint k_unSpatialAnchorPosePropertyTag = 40; + public const uint k_unJsonPropertyTag = 41; + public const uint k_unActiveActionSetPropertyTag = 42; + public const uint k_unOpenVRInternalReserved_Start = 1000; + public const uint k_unOpenVRInternalReserved_End = 10000; + public const uint k_unMaxPropertyStringSize = 32768; + public const ulong k_ulInvalidActionHandle = 0; + public const ulong k_ulInvalidActionSetHandle = 0; + public const ulong k_ulInvalidInputValueHandle = 0; + public const uint k_unControllerStateAxisCount = 5; + public const ulong k_ulOverlayHandleInvalid = 0; + public const uint k_unMaxDistortionFunctionParameters = 8; + public const uint k_unScreenshotHandleInvalid = 0; + public const string IVRSystem_Version = "IVRSystem_019"; + public const string IVRExtendedDisplay_Version = "IVRExtendedDisplay_001"; + public const string IVRTrackedCamera_Version = "IVRTrackedCamera_005"; + public const uint k_unMaxApplicationKeyLength = 128; + public const string k_pch_MimeType_HomeApp = "vr/home"; + public const string k_pch_MimeType_GameTheater = "vr/game_theater"; + public const string IVRApplications_Version = "IVRApplications_006"; + public const string IVRChaperone_Version = "IVRChaperone_003"; + public const string IVRChaperoneSetup_Version = "IVRChaperoneSetup_006"; + public const string IVRCompositor_Version = "IVRCompositor_022"; + public const uint k_unVROverlayMaxKeyLength = 128; + public const uint k_unVROverlayMaxNameLength = 128; + public const uint k_unMaxOverlayCount = 64; + public const uint k_unMaxOverlayIntersectionMaskPrimitivesCount = 32; + public const string IVROverlay_Version = "IVROverlay_019"; + public const string k_pch_Controller_Component_GDC2015 = "gdc2015"; + public const string k_pch_Controller_Component_Base = "base"; + public const string k_pch_Controller_Component_Tip = "tip"; + public const string k_pch_Controller_Component_HandGrip = "handgrip"; + public const string k_pch_Controller_Component_Status = "status"; + public const string IVRRenderModels_Version = "IVRRenderModels_006"; + public const uint k_unNotificationTextMaxSize = 256; + public const string IVRNotifications_Version = "IVRNotifications_002"; + public const uint k_unMaxSettingsKeyLength = 128; + public const string IVRSettings_Version = "IVRSettings_002"; + public const string k_pch_SteamVR_Section = "steamvr"; + public const string k_pch_SteamVR_RequireHmd_String = "requireHmd"; + public const string k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver"; + public const string k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd"; + public const string k_pch_SteamVR_DisplayDebug_Bool = "displayDebug"; + public const string k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe"; + public const string k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX"; + public const string k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY"; + public const string k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps"; + public const string k_pch_SteamVR_LogLevel_Int32 = "loglevel"; + public const string k_pch_SteamVR_IPD_Float = "ipd"; + public const string k_pch_SteamVR_Background_String = "background"; + public const string k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection"; + public const string k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight"; + public const string k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius"; + public const string k_pch_SteamVR_GridColor_String = "gridColor"; + public const string k_pch_SteamVR_PlayAreaColor_String = "playAreaColor"; + public const string k_pch_SteamVR_ShowStage_Bool = "showStage"; + public const string k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers"; + public const string k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers"; + public const string k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees"; + public const string k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement"; + public const string k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses"; + public const string k_pch_SteamVR_SupersampleScale_Float = "supersampleScale"; + public const string k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution"; + public const string k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing"; + public const string k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride"; + public const string k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking"; + public const string k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView"; + public const string k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView"; + public const string k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry"; + public const string k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized"; + public const string k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch"; + public const string k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch"; + public const string k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch"; + public const string k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard"; + public const string k_pch_SteamVR_EnableHomeApp = "enableHomeApp"; + public const string k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec"; + public const string k_pch_SteamVR_RetailDemo_Bool = "retailDemo"; + public const string k_pch_SteamVR_IpdOffset_Float = "ipdOffset"; + public const string k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering"; + public const string k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride"; + public const string k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync"; + public const string k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode"; + public const string k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver"; + public const string k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor"; + public const string k_pch_SteamVR_DebugInput = "debugInput"; + public const string k_pch_SteamVR_DebugInputBinding = "debugInputBinding"; + public const string k_pch_SteamVR_InputBindingUIBlock = "inputBindingUI"; + public const string k_pch_SteamVR_RenderCameraMode = "renderCameraMode"; + public const string k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling"; + public const string k_pch_SteamVR_EnableSafeMode = "enableSafeMode"; + public const string k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate"; + public const string k_pch_SteamVR_LastVersionNotice = "lastVersionNotice"; + public const string k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate"; + public const string k_pch_DirectMode_Section = "direct_mode"; + public const string k_pch_DirectMode_Enable_Bool = "enable"; + public const string k_pch_DirectMode_Count_Int32 = "count"; + public const string k_pch_DirectMode_EdidVid_Int32 = "edidVid"; + public const string k_pch_DirectMode_EdidPid_Int32 = "edidPid"; + public const string k_pch_Lighthouse_Section = "driver_lighthouse"; + public const string k_pch_Lighthouse_DisableIMU_Bool = "disableimu"; + public const string k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd"; + public const string k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation"; + public const string k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug"; + public const string k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation"; + public const string k_pch_Lighthouse_DBHistory_Bool = "dbhistory"; + public const string k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth"; + public const string k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations"; + public const string k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2"; + public const string k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback"; + public const string k_pch_Lighthouse_NewPairing_Bool = "newPairing"; + public const string k_pch_Null_Section = "driver_null"; + public const string k_pch_Null_SerialNumber_String = "serialNumber"; + public const string k_pch_Null_ModelNumber_String = "modelNumber"; + public const string k_pch_Null_WindowX_Int32 = "windowX"; + public const string k_pch_Null_WindowY_Int32 = "windowY"; + public const string k_pch_Null_WindowWidth_Int32 = "windowWidth"; + public const string k_pch_Null_WindowHeight_Int32 = "windowHeight"; + public const string k_pch_Null_RenderWidth_Int32 = "renderWidth"; + public const string k_pch_Null_RenderHeight_Int32 = "renderHeight"; + public const string k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons"; + public const string k_pch_Null_DisplayFrequency_Float = "displayFrequency"; + public const string k_pch_UserInterface_Section = "userinterface"; + public const string k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop"; + public const string k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray"; + public const string k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized"; + public const string k_pch_UserInterface_Screenshots_Bool = "screenshots"; + public const string k_pch_UserInterface_ScreenshotType_Int = "screenshotType"; + public const string k_pch_Notifications_Section = "notifications"; + public const string k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb"; + public const string k_pch_Keyboard_Section = "keyboard"; + public const string k_pch_Keyboard_TutorialCompletions = "TutorialCompletions"; + public const string k_pch_Keyboard_ScaleX = "ScaleX"; + public const string k_pch_Keyboard_ScaleY = "ScaleY"; + public const string k_pch_Keyboard_OffsetLeftX = "OffsetLeftX"; + public const string k_pch_Keyboard_OffsetRightX = "OffsetRightX"; + public const string k_pch_Keyboard_OffsetY = "OffsetY"; + public const string k_pch_Keyboard_Smoothing = "Smoothing"; + public const string k_pch_Perf_Section = "perfcheck"; + public const string k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD"; + public const string k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore"; + public const string k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit"; + public const string k_pch_Perf_TestData_Float = "perfTestData"; + public const string k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling"; + public const string k_pch_CollisionBounds_Section = "collisionBounds"; + public const string k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle"; + public const string k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn"; + public const string k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn"; + public const string k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn"; + public const string k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance"; + public const string k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR"; + public const string k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG"; + public const string k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB"; + public const string k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA"; + public const string k_pch_Camera_Section = "camera"; + public const string k_pch_Camera_EnableCamera_Bool = "enableCamera"; + public const string k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard"; + public const string k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds"; + public const string k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView"; + public const string k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR"; + public const string k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG"; + public const string k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB"; + public const string k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA"; + public const string k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength"; + public const string k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode"; + public const string k_pch_audio_Section = "audio"; + public const string k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice"; + public const string k_pch_audio_OnRecordDevice_String = "onRecordDevice"; + public const string k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice"; + public const string k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice"; + public const string k_pch_audio_OffRecordDevice_String = "offRecordDevice"; + public const string k_pch_audio_VIVEHDMIGain = "viveHDMIGain"; + public const string k_pch_Power_Section = "power"; + public const string k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit"; + public const string k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout"; + public const string k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout"; + public const string k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout"; + public const string k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress"; + public const string k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby"; + public const string k_pch_Dashboard_Section = "dashboard"; + public const string k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard"; + public const string k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode"; + public const string k_pch_Dashboard_UseWebDashboard = "useWebDashboard"; + public const string k_pch_Dashboard_UseWebSettings = "useWebSettings"; + public const string k_pch_Dashboard_UseWebIPD = "useWebIPD"; + public const string k_pch_Dashboard_UseWebPowerMenu = "useWebPowerMenu"; + public const string k_pch_modelskin_Section = "modelskins"; + public const string k_pch_Driver_Enable_Bool = "enable"; + public const string k_pch_WebInterface_Section = "WebInterface"; + public const string k_pch_WebInterface_WebEnable_Bool = "WebEnable"; + public const string k_pch_WebInterface_WebPort_String = "WebPort"; + public const string k_pch_VRWebHelper_Section = "VRWebHelper"; + public const string k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled"; + public const string k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort"; + public const string k_pch_TrackingOverride_Section = "TrackingOverrides"; + public const string k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL"; + public const string k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL"; + public const string k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave"; + public const string k_pch_Trackers_Section = "trackers"; + public const string k_pch_DesktopUI_Section = "DesktopUI"; + public const string k_pch_LastKnown_Section = "LastKnown"; + public const string k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer"; + public const string k_pch_LastKnown_HMDModel_String = "HMDModel"; + public const string k_pch_DismissedWarnings_Section = "DismissedWarnings"; + public const string IVRScreenshots_Version = "IVRScreenshots_001"; + public const string IVRResources_Version = "IVRResources_001"; + public const string IVRDriverManager_Version = "IVRDriverManager_001"; + public const uint k_unMaxActionNameLength = 64; + public const uint k_unMaxActionSetNameLength = 64; + public const uint k_unMaxActionOriginCount = 16; + public const uint k_unMaxBoneNameLength = 32; + public const string IVRInput_Version = "IVRInput_005"; + public const ulong k_ulInvalidIOBufferHandle = 0; + public const string IVRIOBuffer_Version = "IVRIOBuffer_002"; + public const uint k_ulInvalidSpatialAnchorHandle = 0; + public const string IVRSpatialAnchors_Version = "IVRSpatialAnchors_001"; + + static uint VRToken { get; set; } + + const string FnTable_Prefix = "FnTable:"; + + class COpenVRContext + { + public COpenVRContext() { Clear(); } + + public void Clear() + { + m_pVRSystem = null; + m_pVRChaperone = null; + m_pVRChaperoneSetup = null; + m_pVRCompositor = null; + m_pVROverlay = null; + m_pVRRenderModels = null; + m_pVRExtendedDisplay = null; + m_pVRSettings = null; + m_pVRApplications = null; + m_pVRScreenshots = null; + m_pVRTrackedCamera = null; + m_pVRInput = null; + m_pVRIOBuffer = null; + m_pVRSpatialAnchors = null; + m_pVRNotifications = null; + } + + void CheckClear() + { + if (VRToken != GetInitToken()) + { + Clear(); + VRToken = GetInitToken(); + } + } + + public CVRSystem VRSystem() + { + CheckClear(); + if (m_pVRSystem == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSystem_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSystem = new CVRSystem(pInterface); + } + return m_pVRSystem; + } + + public CVRChaperone VRChaperone() + { + CheckClear(); + if (m_pVRChaperone == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRChaperone_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRChaperone = new CVRChaperone(pInterface); + } + return m_pVRChaperone; + } + + public CVRChaperoneSetup VRChaperoneSetup() + { + CheckClear(); + if (m_pVRChaperoneSetup == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRChaperoneSetup_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRChaperoneSetup = new CVRChaperoneSetup(pInterface); + } + return m_pVRChaperoneSetup; + } + + public CVRCompositor VRCompositor() + { + CheckClear(); + if (m_pVRCompositor == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRCompositor_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRCompositor = new CVRCompositor(pInterface); + } + return m_pVRCompositor; + } + + public CVROverlay VROverlay() + { + CheckClear(); + if (m_pVROverlay == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVROverlay_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVROverlay = new CVROverlay(pInterface); + } + return m_pVROverlay; + } + + public CVRRenderModels VRRenderModels() + { + CheckClear(); + if (m_pVRRenderModels == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRRenderModels_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRRenderModels = new CVRRenderModels(pInterface); + } + return m_pVRRenderModels; + } + + public CVRExtendedDisplay VRExtendedDisplay() + { + CheckClear(); + if (m_pVRExtendedDisplay == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRExtendedDisplay_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRExtendedDisplay = new CVRExtendedDisplay(pInterface); + } + return m_pVRExtendedDisplay; + } + + public CVRSettings VRSettings() + { + CheckClear(); + if (m_pVRSettings == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSettings_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSettings = new CVRSettings(pInterface); + } + return m_pVRSettings; + } + + public CVRApplications VRApplications() + { + CheckClear(); + if (m_pVRApplications == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRApplications_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRApplications = new CVRApplications(pInterface); + } + return m_pVRApplications; + } + + public CVRScreenshots VRScreenshots() + { + CheckClear(); + if (m_pVRScreenshots == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRScreenshots_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRScreenshots = new CVRScreenshots(pInterface); + } + return m_pVRScreenshots; + } + + public CVRTrackedCamera VRTrackedCamera() + { + CheckClear(); + if (m_pVRTrackedCamera == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRTrackedCamera_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRTrackedCamera = new CVRTrackedCamera(pInterface); + } + return m_pVRTrackedCamera; + } + + public CVRInput VRInput() + { + CheckClear(); + if (m_pVRInput == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRInput_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRInput = new CVRInput(pInterface); + } + return m_pVRInput; + } + + public CVRIOBuffer VRIOBuffer() + { + CheckClear(); + if (m_pVRIOBuffer == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRIOBuffer_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRIOBuffer = new CVRIOBuffer(pInterface); + } + return m_pVRIOBuffer; + } + + public CVRSpatialAnchors VRSpatialAnchors() + { + CheckClear(); + if (m_pVRSpatialAnchors == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSpatialAnchors_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSpatialAnchors = new CVRSpatialAnchors(pInterface); + } + return m_pVRSpatialAnchors; + } + + public CVRNotifications VRNotifications() + { + CheckClear(); + if (m_pVRNotifications == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRNotifications_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRNotifications = new CVRNotifications(pInterface); + } + return m_pVRNotifications; + } + + private CVRSystem m_pVRSystem; + private CVRChaperone m_pVRChaperone; + private CVRChaperoneSetup m_pVRChaperoneSetup; + private CVRCompositor m_pVRCompositor; + private CVROverlay m_pVROverlay; + private CVRRenderModels m_pVRRenderModels; + private CVRExtendedDisplay m_pVRExtendedDisplay; + private CVRSettings m_pVRSettings; + private CVRApplications m_pVRApplications; + private CVRScreenshots m_pVRScreenshots; + private CVRTrackedCamera m_pVRTrackedCamera; + private CVRInput m_pVRInput; + private CVRIOBuffer m_pVRIOBuffer; + private CVRSpatialAnchors m_pVRSpatialAnchors; + private CVRNotifications m_pVRNotifications; + }; + + private static COpenVRContext _OpenVRInternal_ModuleContext = null; + static COpenVRContext OpenVRInternal_ModuleContext + { + get + { + if (_OpenVRInternal_ModuleContext == null) + _OpenVRInternal_ModuleContext = new COpenVRContext(); + return _OpenVRInternal_ModuleContext; + } + } + + public static CVRSystem System { get { return OpenVRInternal_ModuleContext.VRSystem(); } } + public static CVRChaperone Chaperone { get { return OpenVRInternal_ModuleContext.VRChaperone(); } } + public static CVRChaperoneSetup ChaperoneSetup { get { return OpenVRInternal_ModuleContext.VRChaperoneSetup(); } } + public static CVRCompositor Compositor { get { return OpenVRInternal_ModuleContext.VRCompositor(); } } + public static CVROverlay Overlay { get { return OpenVRInternal_ModuleContext.VROverlay(); } } + public static CVRRenderModels RenderModels { get { return OpenVRInternal_ModuleContext.VRRenderModels(); } } + public static CVRExtendedDisplay ExtendedDisplay { get { return OpenVRInternal_ModuleContext.VRExtendedDisplay(); } } + public static CVRSettings Settings { get { return OpenVRInternal_ModuleContext.VRSettings(); } } + public static CVRApplications Applications { get { return OpenVRInternal_ModuleContext.VRApplications(); } } + public static CVRScreenshots Screenshots { get { return OpenVRInternal_ModuleContext.VRScreenshots(); } } + public static CVRTrackedCamera TrackedCamera { get { return OpenVRInternal_ModuleContext.VRTrackedCamera(); } } + public static CVRInput Input { get { return OpenVRInternal_ModuleContext.VRInput(); } } + public static CVRIOBuffer IOBuffer { get { return OpenVRInternal_ModuleContext.VRIOBuffer(); } } + public static CVRSpatialAnchors SpatialAnchors { get { return OpenVRInternal_ModuleContext.VRSpatialAnchors(); } } + public static CVRNotifications Notifications { get { return OpenVRInternal_ModuleContext.VRNotifications(); } } + + /** Finds the active installation of vrclient.dll and initializes it */ + public static CVRSystem Init(ref EVRInitError peError, EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene, string pchStartupInfo = "") + { + try + { + VRToken = InitInternal2(ref peError, eApplicationType, pchStartupInfo); + } + catch (EntryPointNotFoundException) + { + VRToken = InitInternal(ref peError, eApplicationType); + } + + OpenVRInternal_ModuleContext.Clear(); + + if (peError != EVRInitError.None) + return null; + + bool bInterfaceValid = IsInterfaceVersionValid(IVRSystem_Version); + if (!bInterfaceValid) + { + ShutdownInternal(); + peError = EVRInitError.Init_InterfaceNotFound; + return null; + } + + return OpenVR.System; + } + + /** unloads vrclient.dll. Any interface pointers from the interface are + * invalid after this point */ + public static void Shutdown() + { + ShutdownInternal(); + } + + } +} diff --git a/VDash/Overlay/DashOverlay.cs b/VDash/Overlay/DashOverlay.cs new file mode 100644 index 0000000..9b168cc --- /dev/null +++ b/VDash/Overlay/DashOverlay.cs @@ -0,0 +1,34 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Valve.VR; + +namespace VDash.Overlay +{ + public class DashOverlay + { + internal ulong m_Handle; + public ulong Handle + { + get + { + return m_Handle; + } + } + + internal string m_Key; + public string Key { get { return m_Key; } } + + internal string m_Name; + public string Name { get { return m_Name; } } + + + public DashOverlay(string key, string name) + { + m_Key = key; + m_Name = name; + } + } +} diff --git a/VDash/Overlay/WindowOverlay.cs b/VDash/Overlay/WindowOverlay.cs new file mode 100644 index 0000000..26a7cc4 --- /dev/null +++ b/VDash/Overlay/WindowOverlay.cs @@ -0,0 +1,254 @@ +using SharpDX; +using SharpDX.Direct3D11; +using SharpDX.DXGI; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Threading.Tasks; +using Valve.VR; + +namespace VDash.Overlay +{ + public class WindowOverlay : DashOverlay,IDisposable + { + public CVRSystem VRSystem { get; private set; } + private Task m_EventPumpTask = null; + bool m_Created = false; + bool m_Running = true; + + public WindowOverlay(string key, string name) : base(key, name) + { + } + + public void Create() + { + ConsoleManager.Show(); + ulong thumbHandle = OpenVR.k_ulOverlayHandleInvalid; + + //Actually create the overlay + var overlay = OpenVR.Overlay; + EVROverlayError err = overlay.CreateDashboardOverlay(m_Key, m_Name, ref m_Handle, ref thumbHandle); + + if (err != EVROverlayError.None) + { + throw new Exception($"Error creating overlay: {err}"); + } + + overlay.SetOverlayWidthInMeters(m_Handle, 2.5f); + overlay.SetOverlayInputMethod(m_Handle, VROverlayInputMethod.Mouse); + m_EventPumpTask = Task.Factory.StartNew(() => { EventPump(); }); + m_Created = true; + } + + private void EventPump() + { + #region Rendering setup + var overlay = OpenVR.Overlay; + + //Skip rendering if overlay isn't visible + if ((m_Handle == OpenVR.k_ulOverlayHandleInvalid) || overlay == null || (!overlay.IsOverlayVisible(m_Handle))) + { + //return; + } + + //Taken from here: https://stackoverflow.com/questions/6812068/c-sharp-which-is-the-fastest-way-to-take-a-screen-shot + + var factory = new Factory1(); + //Get first adapter + var adapter = factory.GetAdapter1(0); + //Get device from adapter + var device = new SharpDX.Direct3D11.Device(adapter); + //Get front buffer of the adapter + var output = adapter.GetOutput(0); + var output1 = output.QueryInterface(); + + // Width/Height of desktop to capture + int width = output.Description.DesktopBounds.Right; + int height = output.Description.DesktopBounds.Bottom; + + // Create Staging texture CPU-accessible + var textureDesc = new Texture2DDescription + { + CpuAccessFlags = CpuAccessFlags.Read, + BindFlags = BindFlags.None, + Format = Format.B8G8R8A8_UNorm, + Width = width, + Height = height, + OptionFlags = ResourceOptionFlags.None, + MipLevels = 1, + ArraySize = 1, + SampleDescription = { Count = 1, Quality = 0 }, + Usage = ResourceUsage.Staging + }; + var screenTexture = new Texture2D(device, textureDesc); + #endregion + int frames = 0; + DateTime lastFps = DateTime.MinValue; + + while (m_Running) + { + VREvent_t vrEvent = new VREvent_t(); + + while (OpenVR.Overlay.PollNextOverlayEvent(m_Handle, ref vrEvent, (uint)Marshal.SizeOf(vrEvent))) + { + switch ((EVREventType)vrEvent.eventType) + { + case EVREventType.VREvent_MouseMove: + { + var x = vrEvent.data.mouse.x; + var y = vrEvent.data.mouse.y; + break; + } + + case EVREventType.VREvent_MouseButtonDown: + { + var clickType = (EVRMouseButton)vrEvent.data.mouse.button; + break; + } + + case EVREventType.VREvent_MouseButtonUp: + { + var clickType = (EVRMouseButton)vrEvent.data.mouse.button; + break; + } + case EVREventType.VREvent_OverlayShown: + { + Console.WriteLine("Overlay Shown!"); + break; + } + } + + } + + + #region Acutally Render + + using (var duplicatedOutput = output1.DuplicateOutput(device)) + { + SharpDX.DXGI.Resource screenResource = null; + try + { + OutputDuplicateFrameInformation duplicateFrameInformation; + + + // Try to get duplicated frame within given time is ms + + + duplicatedOutput.AcquireNextFrame(10000, out duplicateFrameInformation, out screenResource); + + + + #region junk + // copy resource into memory that can be accessed by the CPU + //using (var screenTexture2D = screenResource.QueryInterface()) + //{ + // device.ImmediateContext.CopyResource(screenTexture2D, screenTexture); + //} + + // Get the desktop capture texture + var mapSource = device.ImmediateContext.MapSubresource(screenTexture, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None); + + // Create Drawing.Bitmap + //using (var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb)) + //{ + // var boundsRect = new Rectangle(0, 0, width, height); + + // // Copy pixels from screen capture Texture to GDI bitmap + // var mapDest = bitmap.LockBits(boundsRect, ImageLockMode.WriteOnly, bitmap.PixelFormat); + // var sourcePtr = mapSource.DataPointer; + // var destPtr = mapDest.Scan0; + + + if (duplicateFrameInformation.AccumulatedFrames > 0) + { + //Console.WriteLine($"Frames: {duplicateFrameInformation.AccumulatedFrames}"); + var texture = new Texture_t(); + texture.handle = screenTexture.NativePointer; + texture.eType = ETextureType.DirectX; + texture.eColorSpace = EColorSpace.Auto; + EVROverlayError result = overlay.SetOverlayTexture(m_Handle, ref texture); + if (result != EVROverlayError.None) + { + Console.WriteLine($"Error rendering: {result}"); + } + + frames++; + } + + //for (int y = 0; y < height; y++) + //{ + // Copy a single line + // Utilities.CopyMemory(destPtr, sourcePtr, width * 4); + + // Advance pointers + // sourcePtr = IntPtr.Add(sourcePtr, mapSource.RowPitch); + // destPtr = IntPtr.Add(destPtr, mapDest.Stride); + //} + + //// // Release source and dest locks + //bitmap.UnlockBits(mapDest); + device.ImmediateContext.UnmapSubresource(screenTexture, 0); + + //using (var ms = new FileStream(@"C:\Users\jrhodnik\Desktop\ss.bmp", FileMode.Create)) + //{ + // bitmap.Save(ms, ImageFormat.Bmp); + //} + + //} + #endregion + + } + catch (Exception ex) + { + Console.WriteLine(ex.ToString()); + } + finally + { + if (screenResource != null) + { + screenResource.Dispose(); + } + duplicatedOutput.ReleaseFrame(); + } + } + #endregion + + //Thread.Sleep(20); + + if(DateTime.Now.Subtract(lastFps).TotalMilliseconds > 1000) + { + Console.WriteLine($"{frames} fps."); + frames = 0; + lastFps = DateTime.Now; + } + } + } + + private class User32 + { + [StructLayout(LayoutKind.Sequential)] + public struct Rect + { + public int left; + public int top; + public int right; + public int bottom; + } + + [DllImport("user32.dll")] + public static extern IntPtr GetWindowRect(IntPtr hWnd, ref Rect rect); + } + + public void Dispose() + { + //FIXME: Actually implement this... + } + } +} diff --git a/VDash/Properties/AssemblyInfo.cs b/VDash/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..a81f65b --- /dev/null +++ b/VDash/Properties/AssemblyInfo.cs @@ -0,0 +1,55 @@ +using System.Reflection; +using System.Resources; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Windows; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("VDash")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("VDash")] +[assembly: AssemblyCopyright("Copyright © 2019")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +//In order to begin building localizable applications, set +//CultureYouAreCodingWith in your .csproj file +//inside a . For example, if you are using US english +//in your source files, set the to en-US. Then uncomment +//the NeutralResourceLanguage attribute below. Update the "en-US" in +//the line below to match the UICulture setting in the project file. + +//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)] + + +[assembly: ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] + + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/VDash/Properties/Resources.Designer.cs b/VDash/Properties/Resources.Designer.cs new file mode 100644 index 0000000..2efdc0c --- /dev/null +++ b/VDash/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace VDash.Properties +{ + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VDash.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/VDash/Properties/Resources.resx b/VDash/Properties/Resources.resx new file mode 100644 index 0000000..af7dbeb --- /dev/null +++ b/VDash/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/VDash/Properties/Settings.Designer.cs b/VDash/Properties/Settings.Designer.cs new file mode 100644 index 0000000..0923f6d --- /dev/null +++ b/VDash/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace VDash.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/VDash/Properties/Settings.settings b/VDash/Properties/Settings.settings new file mode 100644 index 0000000..033d7a5 --- /dev/null +++ b/VDash/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/VDash/ScreenStateLogger.cs b/VDash/ScreenStateLogger.cs new file mode 100644 index 0000000..d61cd82 --- /dev/null +++ b/VDash/ScreenStateLogger.cs @@ -0,0 +1,138 @@ +using SharpDX; +using SharpDX.Direct3D11; +using SharpDX.DXGI; +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Drawing; +using System.Drawing.Imaging; +using System.IO; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace VDash +{ + public class ScreenStateLogger + { + private byte[] _previousScreen; + private bool _run, _init; + + public int Size { get; private set; } + public ScreenStateLogger() + { + + } + + public void Start() + { + _run = true; + var factory = new Factory1(); + //Get first adapter + var adapter = factory.GetAdapter1(0); + //Get device from adapter + var device = new SharpDX.Direct3D11.Device(adapter); + //Get front buffer of the adapter + var output = adapter.GetOutput(0); + var output1 = output.QueryInterface(); + + // Width/Height of desktop to capture + int width = output.Description.DesktopBounds.Right; + int height = output.Description.DesktopBounds.Bottom; + + // Create Staging texture CPU-accessible + var textureDesc = new Texture2DDescription + { + CpuAccessFlags = CpuAccessFlags.Read, + BindFlags = BindFlags.None, + Format = Format.B8G8R8A8_UNorm, + Width = width, + Height = height, + OptionFlags = ResourceOptionFlags.None, + MipLevels = 1, + ArraySize = 1, + SampleDescription = { Count = 1, Quality = 0 }, + Usage = ResourceUsage.Staging + }; + var screenTexture = new Texture2D(device, textureDesc); + + Task.Factory.StartNew(() => + { + // Duplicate the output + using (var duplicatedOutput = output1.DuplicateOutput(device)) + { + while (_run) + { + try + { + SharpDX.DXGI.Resource screenResource; + OutputDuplicateFrameInformation duplicateFrameInformation; + + // Try to get duplicated frame within given time is ms + duplicatedOutput.AcquireNextFrame(5, out duplicateFrameInformation, out screenResource); + + // copy resource into memory that can be accessed by the CPU + using (var screenTexture2D = screenResource.QueryInterface()) + device.ImmediateContext.CopyResource(screenTexture2D, screenTexture); + + // Get the desktop capture texture + var mapSource = device.ImmediateContext.MapSubresource(screenTexture, 0, MapMode.Read, SharpDX.Direct3D11.MapFlags.None); + + // Create Drawing.Bitmap + using (var bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb)) + { + var boundsRect = new Rectangle(0, 0, width, height); + + // Copy pixels from screen capture Texture to GDI bitmap + var mapDest = bitmap.LockBits(boundsRect, ImageLockMode.WriteOnly, bitmap.PixelFormat); + var sourcePtr = mapSource.DataPointer; + var destPtr = mapDest.Scan0; + for (int y = 0; y < height; y++) + { + // Copy a single line + Utilities.CopyMemory(destPtr, sourcePtr, width * 4); + + // Advance pointers + sourcePtr = IntPtr.Add(sourcePtr, mapSource.RowPitch); + destPtr = IntPtr.Add(destPtr, mapDest.Stride); + } + + // Release source and dest locks + bitmap.UnlockBits(mapDest); + device.ImmediateContext.UnmapSubresource(screenTexture, 0); + + using (var ms = new MemoryStream()) + { + bitmap.Save(ms, ImageFormat.Bmp); + if (duplicateFrameInformation.AccumulatedFrames > 0) + { + ScreenRefreshed?.Invoke(this, ms.ToArray()); + } + _init = true; + } + } + screenResource.Dispose(); + duplicatedOutput.ReleaseFrame(); + } + catch (SharpDXException e) + { + if (e.ResultCode.Code != SharpDX.DXGI.ResultCode.WaitTimeout.Result.Code) + { + Trace.TraceError(e.Message); + Trace.TraceError(e.StackTrace); + } + } + } + } + }); + while (!_init) ; + } + + public void Stop() + { + _run = false; + } + + public EventHandler ScreenRefreshed; + } +} diff --git a/VDash/VDash.csproj b/VDash/VDash.csproj new file mode 100644 index 0000000..ac7a33d --- /dev/null +++ b/VDash/VDash.csproj @@ -0,0 +1,138 @@ + + + + + Debug + AnyCPU + {C12CDA63-DDBB-427B-B66A-72FA42291B04} + WinExe + VDash + VDash + v4.5 + 512 + {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + 4 + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + true + bin\x64\Debug\ + DEBUG;TRACE + full + x64 + prompt + MinimumRecommendedRules.ruleset + true + + + bin\x64\Release\ + TRACE + true + pdbonly + x64 + prompt + MinimumRecommendedRules.ruleset + true + + + + ..\packages\SharpDX.4.2.0\lib\net45\SharpDX.dll + + + ..\packages\SharpDX.Direct3D11.4.2.0\lib\net45\SharpDX.Direct3D11.dll + + + ..\packages\SharpDX.DXGI.4.2.0\lib\net45\SharpDX.DXGI.dll + + + + + + + + + + + + 4.0 + + + + + + + + MSBuild:Compile + Designer + + + + MSBuild:Compile + Designer + + + App.xaml + Code + + + + MainWindow.xaml + Code + + + + + + + + Code + + + True + True + Resources.resx + + + True + Settings.settings + True + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + + + + + + PreserveNewest + + + + \ No newline at end of file diff --git a/VDash/openvr_api.dll b/VDash/openvr_api.dll new file mode 100644 index 0000000000000000000000000000000000000000..7c9a0b17f62b2ff475c91bc6bb1183e003ca00a4 GIT binary patch literal 598816 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�ap<3@{a^-twnKAtB0D&a8Rw>9DS$uSIV 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 z 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

L_k)|RdutL{kYGJZD0z*t55WHXs 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 z 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 + + + + + \ No newline at end of file