From b718fabe3d35567c45baba51b23c2b136ba1d12a Mon Sep 17 00:00:00 2001 From: Steven Lee Date: Wed, 22 Mar 2023 09:19:16 +0800 Subject: [PATCH 1/5] work sync --- VRGameOverlay/VRGameOverlay.csproj | 26 + .../VROverlayWindow/CaptureScreen.cs | 387 + VRGameOverlay/VROverlayWindow/ChromaKey.cs | 85 + .../VROverlayWindow/CursorInteraction.cs | 1210 +++ .../VROverlayWindow/DeviceManager.cs | 210 + VRGameOverlay/VROverlayWindow/DeviceState.cs | 12 + VRGameOverlay/VROverlayWindow/Extentions.cs | 168 + VRGameOverlay/VROverlayWindow/GDIStuff.cs | 40 + VRGameOverlay/VROverlayWindow/MathUtil.cs | 721 ++ VRGameOverlay/VROverlayWindow/RECT.cs | 97 + VRGameOverlay/VROverlayWindow/SteamVR.cs | 259 + .../VROverlayWindow/TouchController.cs | 87 + .../VROverlayWindow/TouchControllerButton.cs | 68 + .../VROverlayWindow/TouchControllerHand.cs | 11 + .../VROverlayWindow/TrackedDevices.cs | 315 + .../VROverlayWindow/VROverlayConfiguration.cs | 70 + .../VROverlayWindow/VROverlayWindow.cs | 469 + VRGameOverlay/VROverlayWindow/Win32Stuff.cs | 361 + VRGameOverlay/VROverlayWindow/openvr_api.cs | 8322 +++++++++++++++++ VRGameOverlay/openvr_api.dll | Bin 0 -> 818904 bytes ZTMZ.PacenoteTool.Base/Config.cs | 69 +- ZTMZ.PacenoteTool.sln | 18 +- ZTMZ.PacenoteTool/GameOverlayManager.cs | 3 + ZTMZ.PacenoteTool/MainWindow.xaml | 2 + ZTMZ.PacenoteTool/MainWindow.xaml.cs | 24 + ZTMZ.PacenoteTool/SettingsWindow.xaml | 72 +- ZTMZ.PacenoteTool/SettingsWindow.xaml.cs | 13 + ZTMZ.PacenoteTool/VRGameOverlayManager.cs | 58 + ZTMZ.PacenoteTool/ZTMZ.PacenoteTool.csproj | 1 + ZTMZ.PacenoteTool/lang/en-us.json | 25 +- ZTMZ.PacenoteTool/lang/zh-cn.json | 29 +- 31 files changed, 13212 insertions(+), 20 deletions(-) create mode 100644 VRGameOverlay/VRGameOverlay.csproj create mode 100644 VRGameOverlay/VROverlayWindow/CaptureScreen.cs create mode 100644 VRGameOverlay/VROverlayWindow/ChromaKey.cs create mode 100644 VRGameOverlay/VROverlayWindow/CursorInteraction.cs create mode 100644 VRGameOverlay/VROverlayWindow/DeviceManager.cs create mode 100644 VRGameOverlay/VROverlayWindow/DeviceState.cs create mode 100644 VRGameOverlay/VROverlayWindow/Extentions.cs create mode 100644 VRGameOverlay/VROverlayWindow/GDIStuff.cs create mode 100644 VRGameOverlay/VROverlayWindow/MathUtil.cs create mode 100644 VRGameOverlay/VROverlayWindow/RECT.cs create mode 100644 VRGameOverlay/VROverlayWindow/SteamVR.cs create mode 100644 VRGameOverlay/VROverlayWindow/TouchController.cs create mode 100644 VRGameOverlay/VROverlayWindow/TouchControllerButton.cs create mode 100644 VRGameOverlay/VROverlayWindow/TouchControllerHand.cs create mode 100644 VRGameOverlay/VROverlayWindow/TrackedDevices.cs create mode 100644 VRGameOverlay/VROverlayWindow/VROverlayConfiguration.cs create mode 100644 VRGameOverlay/VROverlayWindow/VROverlayWindow.cs create mode 100644 VRGameOverlay/VROverlayWindow/Win32Stuff.cs create mode 100644 VRGameOverlay/VROverlayWindow/openvr_api.cs create mode 100644 VRGameOverlay/openvr_api.dll create mode 100644 ZTMZ.PacenoteTool/VRGameOverlayManager.cs diff --git a/VRGameOverlay/VRGameOverlay.csproj b/VRGameOverlay/VRGameOverlay.csproj new file mode 100644 index 0000000..d320f08 --- /dev/null +++ b/VRGameOverlay/VRGameOverlay.csproj @@ -0,0 +1,26 @@ + + + + net6.0 + enable + enable + False + + + + + + + + + + + + + + + Always + + + + diff --git a/VRGameOverlay/VROverlayWindow/CaptureScreen.cs b/VRGameOverlay/VROverlayWindow/CaptureScreen.cs new file mode 100644 index 0000000..0167e53 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/CaptureScreen.cs @@ -0,0 +1,387 @@ + +using SharpDX.Direct3D11; +using SharpDX.DXGI; +using System; +using System.Diagnostics; +using System.Drawing; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using Graphics = System.Drawing.Graphics; +using Device = SharpDX.Direct3D11.Device; +using SharpDX; +using D2D = SharpDX.Direct2D1; +using SharpDX.Mathematics.Interop; + +namespace VRGameOverlay.VROverlayWindow +{ + public class Direct3D11CaptureSource : IDisposable + { + private OutputDuplicationSource[] outputDuplications; + private Device device; + private DeviceManager deviceManager; + private CVRSystem _vrSystem = null; + + public Direct3D11CaptureSource(DeviceManager deviceManager, CVRSystem vrSystem) + { + device = deviceManager.device; + this.deviceManager = deviceManager; + _vrSystem = vrSystem; + Initialize(); + } + + private void Initialize() + { + int adapterIndex = 0; + if (_vrSystem != null) + { + _vrSystem.GetDXGIOutputInfo(ref adapterIndex); + } + + using (var factory = new Factory4()) + using (var adapter = factory.GetAdapter(adapterIndex)) + { + // properties in SharpDX are very deceptive + // calling adapter.Outputs will construct N new instances of Output that must be disposed by OutputDuplicationSource + outputDuplications = adapter.Outputs.Select(o => OutputDuplicationSource.FromOutput(device, o)).ToArray(); + } + } + + private void OnDeviceAccessLost() + { + Dispose(); + Initialize(); + } + + public void Capture(List windows) + { + if (device == null) + { + return; + } + + foreach (var dub in outputDuplications) + { + bool captureDone = false; + List currentBatch = new List(); + foreach (VROverlayWindow w in windows) + { + var info = new Win32Stuff.WINDOWINFO(); + info.cbSize = (uint)Marshal.SizeOf(info); + if (!w.isDisplay) + { + var gotWindowInfo = Win32Stuff.GetWindowInfo(w.hWnd, ref info); + if (!gotWindowInfo || info.dwStyle.HasFlag(Win32Stuff.WindowStyle.Iconic) || !info.dwStyle.HasFlag(Win32Stuff.WindowStyle.Visible)) + continue; + + if (info.rcClient.Width < 1 || info.rcClient.Height < 1) + continue; + + if (!dub.Contains(info.rcClient)) + continue; + if (w.forceTopMost) + w.MakeTopmost(); + } + else if (w.Name != dub.deviceName) + continue; + + + // update the window size for display, may need to create a new texture + var rect = new SharpDX.Rectangle(0, 0, dub.width, dub.height); + + w.TryUpdateSize(rect, () => new Texture2D(device, new Texture2DDescription + { + CpuAccessFlags = CpuAccessFlags.Read | CpuAccessFlags.Write, + BindFlags = BindFlags.None, + Format = dub.outputDuplication.Description.ModeDescription.Format, + Width = w.rectAbs.Width, + Height = w.rectAbs.Height, + OptionFlags = ResourceOptionFlags.None, + MipLevels = 1, + ArraySize = 1, + SampleDescription = { Count = 1, Quality = 0 }, + Usage = ResourceUsage.Staging + }) + { + DebugName = nameof(w.copiedScreenTexture) + }); + + currentBatch.Add(w); + } + + if (currentBatch.Count < 1) + continue; + + const int MAX_CAPTURE_RETRY_COUNT = 5; + int captureRetry = 0; + for (; !captureDone && captureRetry < MAX_CAPTURE_RETRY_COUNT; captureRetry++) + { + try + { + OutputDuplicateFrameInformation duplicateFrameInformation; + var result = dub.outputDuplication.TryAcquireNextFrame(100, out duplicateFrameInformation, out SharpDX.DXGI.Resource screenResource); + if (result.Code == SharpDX.DXGI.ResultCode.AccessLost.Result.Code) + { + OnDeviceAccessLost(); + Console.WriteLine("CaptureScreen.Capture: device access lost = " + SharpDX.DXGI.ResultCode.AccessLost.ApiCode); + continue; + } + else if (result.Code == SharpDX.DXGI.ResultCode.WaitTimeout.Result.Code) + { + continue; + } + else if (result.Success) + { + using (var screenTexture = screenResource.QueryInterface()) + { + screenTexture.DebugName = "screenTexture"; + foreach (var overlayWindow in currentBatch) + { + using (var imageProcessor = new OverlayDecorator(this, overlayWindow, dub) + { + //HighlightColor = ColorTranslator.FromHtml(_VRConfig.HighlightColor), + //MousePoint = overlayWindow.GetMousePoint() + }) + { + imageProcessor.Draw(screenTexture); + } + + overlayWindow.shouldDraw = true; + } + } + captureDone = true; + screenResource?.Dispose(); + screenResource = null; + dub.outputDuplication.ReleaseFrame(); +#if DEBUG + Trace.WriteLine($"ObjectTracker.FindActiveObjects: {SharpDX.Diagnostics.ObjectTracker.FindActiveObjects().Count}"); +#endif + } + else if (result.Code != SharpDX.DXGI.ResultCode.WaitTimeout.Result.Code) + { + Console.WriteLine("CaptureScreen.Capture: screen capturing failed = " + result.Code.ToString()); + } + } + catch (SharpDXException e) + { + if (e.ResultCode.Code == SharpDX.DXGI.ResultCode.AccessLost.Result.Code) + { + OnDeviceAccessLost(); + Console.WriteLine("CaptureScreen.Capture: device access lost = " + e.Message); + + return; // OnDeviceAccessLost modifies outputDuplicationSource collection. Simply return and next frame will pick refresh up correctly. + } + else if (e.ResultCode.Code != SharpDX.DXGI.ResultCode.WaitTimeout.Result.Code) + { + Console.WriteLine("CaptureScreen.Capture: screen capturing failed = " + e.Message); + } + } + catch (Exception ex) + { + Console.WriteLine("CaptureScreen.Capture: screen capturing failed = " + ex.Message); + if (dub.outputDuplication == null + || dub.outputDuplication.NativePointer == IntPtr.Zero + || dub.outputDuplication.IsDisposed) + { + OnDeviceAccessLost(); + Console.WriteLine("CaptureScreen.Capture: lost outputDuplication"); + + return; // OnDeviceAccessLost modifies outputDuplicationSource collection. Simply return and next frame will pick refresh up correctly. + } + } + } + + if (captureRetry == MAX_CAPTURE_RETRY_COUNT) + { + // It turns out that depending on what is in the focus, TryAcquireNextFrame + // can timeout getting the next frame, indefinitely. Notably, if SimHub or other WPF window is in the focus, + // it times out until something changes on the screen, for example, mouse cursor moves. That means, that we won't process + // toggle requests, indefinitely. So as a workaround, return here if we exceeded + // the retry threashold. + // + // Display all old overlays using old textures, until the next successful refresh. +#if DEBUG + Console.WriteLine("CaptureScreen.Capture: Capture retry count exceeded."); +#endif + foreach (var w in currentBatch) + { + // Pretend we fully succeeded, outherwise VROverlayWindow.Draw will hide the overlay. + w.shouldDraw = true; + } + } + } + + return; + } + + public void Dispose() + { + if (outputDuplications != null) + { + foreach (var dub in outputDuplications) + { + try + { + dub.Dispose(); + } + catch (Exception ex) + { + // This still crashes, wtf? + // Utilities.ReportException(ex, "Direct3D11CaptureSource.Dispose crashed.", needReport: false); + } + } + } + outputDuplications = null; + + //copiedScreenTexture.Dispose(); + //copiedScreenTexture = null; + } + + internal class OutputDuplicationSource : IDisposable + { + public OutputDuplication outputDuplication { get; private set; } + public System.Drawing.Rectangle rectangle; + public string deviceName; + public int width; + public int height; + Output output; + + public OutputDuplicationSource(OutputDuplication outputSource, Output output) + : base() + { + this.output = output; + var rectangle = output.Description.DesktopBounds; + var deviceName = output.Description.DeviceName; + outputDuplication = outputSource; + + this.rectangle = System.Drawing.Rectangle.FromLTRB(rectangle.Left, rectangle.Top, rectangle.Right, rectangle.Bottom); + this.deviceName = deviceName; + Console.WriteLine($" {deviceName}: X = {rectangle.Left} " + + $" Y = {rectangle.Top} " + + $" Right = {this.rectangle.Right} " + + $" Bottom = {this.rectangle.Bottom} " + + $"Width = {this.rectangle.Width} " + + $"Height = {this.rectangle.Height} "); + width = Math.Abs(rectangle.Right - rectangle.Left); + height = Math.Abs(rectangle.Bottom - rectangle.Top); + } + + public bool Contains(RECT rect) + { + return rectangle.Contains(System.Drawing.Rectangle.FromLTRB(rect.Left, rect.Top, rect.Right, rect.Bottom)); + } + + public void Dispose() + { + if (outputDuplication != null + && outputDuplication.NativePointer != IntPtr.Zero + && !outputDuplication.IsDisposed) + { + outputDuplication.Dispose(); + //this.outputDuplication = null; + } + output?.Dispose(); + output = null; + } + + public static OutputDuplicationSource FromOutput(Device device, Output output) + { + using (var output1 = output.QueryInterface()) + { + return new OutputDuplicationSource(output1.DuplicateOutput(device), output); ; + } + } + } + + public class OverlayDecorator : IDisposable + { + public static IntPtr cursorIcon = Win32Stuff.LoadCursor(IntPtr.Zero, (int)Win32Stuff.IDC_STANDARD_CURSORS.IDC_ARROW); + public DeviceManager Devices { get; set; } + public VROverlayWindow Overlay { get; set; } + public Size2 Size { get; private set; } + public System.Drawing.Color HighlightColor { get; set; } = System.Drawing.Color.Yellow; + + List _disposables = new List(); + Format BitmapFormat = Format.B8G8R8A8_UNorm; + + internal OverlayDecorator(Direct3D11CaptureSource source, VROverlayWindow overlay, OutputDuplicationSource duplication) + : this(source, overlay, overlay.isDisplay + ? new Size2(duplication.width, duplication.height) + : new Size2(overlay.rectAbs.Width, overlay.rectAbs.Height)) + { + BitmapFormat = duplication.outputDuplication.Description.ModeDescription.Format; + } + + public OverlayDecorator(Direct3D11CaptureSource source, VROverlayWindow overlay, Size2 size) + : this(source.deviceManager, overlay, size) + { + + } + + public OverlayDecorator(DeviceManager deviceManager, VROverlayWindow overlay, Size2 size) + { + Devices = deviceManager; + Overlay = overlay; + Size = size; + } + + public Texture2D NewTexture(ResourceOptionFlags flags = ResourceOptionFlags.None, Format format = Format.B8G8R8A8_UNorm, string debugName = "") + { + var texture = new Texture2D(Devices.device, new Texture2DDescription + { + CpuAccessFlags = CpuAccessFlags.None, + BindFlags = BindFlags.RenderTarget, + Format = Format.B8G8R8A8_UNorm, + Width = Size.Width, + Height = Size.Height, + OptionFlags = flags, + MipLevels = 1, + ArraySize = 1, + SampleDescription = { Count = 1, Quality = 0 }, + Usage = ResourceUsage.Default + }) + { + DebugName = debugName + }; + _disposables.Add(texture); + return texture; + } + + /// + /// + /// + /// + public void Draw(Texture2D screenTexture) + { + // simple case, nothing to draw, just copy the texture + if (!Overlay.Chromakey && !Overlay.IsSelected) + { + CopyScreen(screenTexture, Overlay.copiedScreenTexture); + return; + } + } + + internal void CopyScreen(Texture2D screen, Texture2D destination) + { + if (Overlay.isDisplay) + { + Devices.device.ImmediateContext.CopyResource(screen, destination); + } + else + { + var region = new ResourceRegion(Overlay.rectAbs.X, Overlay.rectAbs.Y, 0, Overlay.rectAbs.Right, Overlay.rectAbs.Bottom, 1); + Devices.device.ImmediateContext.CopySubresourceRegion(screen, 0, region, destination, 0); + } + } + + public void Dispose() + { + foreach (var d in _disposables) + { + d.Dispose(); + } + _disposables.Clear(); + } + } + } +} diff --git a/VRGameOverlay/VROverlayWindow/ChromaKey.cs b/VRGameOverlay/VROverlayWindow/ChromaKey.cs new file mode 100644 index 0000000..f512461 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/ChromaKey.cs @@ -0,0 +1,85 @@ +using D2D = SharpDX.Direct2D1; +namespace VRGameOverlay.VROverlayWindow +{ + /// + /// C# implementation of https://docs.microsoft.com/en-us/windows/win32/direct2d/chromakey-effect + /// + public class ChromaKey : D2D.Effect + { + public ChromaKey(D2D.DeviceContext context) + : base(context, ChromaKey) + { + } + + public enum Properties + { + COLOR = 0, + TOLERANCE = 1, + INVERT_ALPHA = 2, + FEATHER = 3, + } + + /// + /// The D2D1_CHROMAKEY_PROP_INVERT_ALPHA property is a boolean value indicating whether the alpha values should be inverted. The default value if False. + /// + public bool InvertAlpha + { + get + { + return GetBoolValue((int)Properties.INVERT_ALPHA); + } + set + { + SetValue((int)Properties.INVERT_ALPHA, value); + } + } + + /// + /// The D2D1_CHROMAKEY_PROP_FEATHER property is a boolean value whether the edges of the output should be softened in the alpha channel. + /// When set to False, the alpha output by the effect is 1-bit: either fully opaque or fully transparent.Setting to True results in a softening of edges in the alpha channel of the Chroma Key output. + /// The default value is False. + /// + public bool Feather + { + get + { + return GetBoolValue((int)Properties.FEATHER); + } + set + { + SetValue((int)Properties.FEATHER, value); + } + } + + /// + /// The D2D1_CHROMAKEY_PROP_TOLERANCE property is a float value indicating the tolerance for matching the color specified in the D2D1_CHROMAKEY_PROP_COLOR property. + /// The allowed range is 0.0 to 1.0. The default value is 0.1. + /// + public float Tolerance + { + get + { + return GetFloatValue((int)Properties.TOLERANCE); + } + set + { + SetValue((int)Properties.TOLERANCE, value); + } + } + + /// + /// The D2D1_CHROMAKEY_PROP_COLOR property is a value indicating the color that should be converted to alpha. The default color is black. + /// + public SharpDX.Mathematics.Interop.RawColor3 Color + { + get + { + return GetColor3Value((int)Properties.COLOR); + } + set + { + SetValue((int)Properties.COLOR, value); + } + } + } +} diff --git a/VRGameOverlay/VROverlayWindow/CursorInteraction.cs b/VRGameOverlay/VROverlayWindow/CursorInteraction.cs new file mode 100644 index 0000000..2c043d3 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/CursorInteraction.cs @@ -0,0 +1,1210 @@ +//using System; +using System.ComponentModel; +using System.Drawing; +using System.Runtime.InteropServices; +//using System.Windows.Forms; + + +namespace VRGameOverlay.VROverlayWindow +{ + public class CursorInteraction + { + [DllImport("user32.dll")] + static extern bool ClientToScreen(IntPtr hWnd, ref Point lpPoint); + + [DllImport("user32.dll")] + static extern bool ScreenToClient(IntPtr hWnd, ref Point lpPoint); + + [DllImport("user32.dll")] + internal static extern uint SendInput(uint nInputs, [MarshalAs(UnmanagedType.LPArray), In] INPUT[] pInputs, int cbSize); + + [DllImport("user32.dll", CharSet = CharSet.Auto)] + static extern IntPtr SendMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam); + + [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)] + static extern bool SendNotifyMessage(IntPtr hWnd, uint Msg, UIntPtr wParam, IntPtr lParam); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)] + static extern bool PostMessage(IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam); + + public class MouseCursor + { + internal Win32Stuff.CURSORINFO Info = new Win32Stuff.CURSORINFO(); + public bool GotInfo = false; + public Point RelativePosition { get; set; } + + public bool InBounds(SharpDX.Rectangle rectAbs) + { + return RelativePosition.X >= 0 && RelativePosition.X <= rectAbs.Width + && RelativePosition.Y >= 0 && RelativePosition.Y <= rectAbs.Height + && GotInfo + && Info.flags == Win32Stuff.CURSOR_SHOWING; + } + + public static MouseCursor Capture(SharpDX.Rectangle rectScreen) + { + var result = new MouseCursor(); + result.Info.cbSize = Marshal.SizeOf(result.Info); + result.GotInfo = Win32Stuff.GetCursorInfo(out result.Info); + //result.RelativePosition = GetCursorPosRelativeWindow(rectScreen); + return result; + } + } + +#pragma warning disable 649 + #region SendInput Structs + [StructLayout(LayoutKind.Sequential)] + public struct INPUT + { + internal InputType type; + internal InputUnion U; + internal static int Size + { + get { return Marshal.SizeOf(typeof(INPUT)); } + } + } + + [StructLayout(LayoutKind.Explicit)] + internal struct InputUnion + { + [FieldOffset(0)] + internal MOUSEINPUT mi; + [FieldOffset(0)] + internal KEYBDINPUT ki; + [FieldOffset(0)] + internal HARDWAREINPUT hi; + } + + [StructLayout(LayoutKind.Explicit)] + internal struct MOUSEKEYBDHARDWAREINPUT + { + [FieldOffset(0)] + public MOUSEINPUT Mouse; + } + [StructLayout(LayoutKind.Sequential)] + internal struct MOUSEINPUT + { + internal int dx; + internal int dy; + internal int mouseData; + internal MOUSEEVENTF dwFlags; + internal uint time; + internal UIntPtr dwExtraInfo; + } + [StructLayout(LayoutKind.Sequential)] + internal struct KEYBDINPUT + { + internal VirtualKeyShort wVk; + internal ScanCodeShort wScan; + internal KEYEVENTF dwFlags; + internal int time; + internal UIntPtr dwExtraInfo; + } + [StructLayout(LayoutKind.Sequential)] + internal struct HARDWAREINPUT + { + internal int uMsg; + internal short wParamL; + internal short wParamH; + } + #endregion + #region Enums + internal enum InputType : uint + { + MOUSE = 0, + KEYBOARD = 1, + HARDWARE = 2 + } + [Flags] + internal enum MOUSEEVENTF : uint + { + ABSOLUTE = 0x8000, + HWHEEL = 0x01000, + MOVE = 0x0001, + MOVE_NOCOALESCE = 0x2000, + LEFTDOWN = 0x0002, + LEFTUP = 0x0004, + RIGHTDOWN = 0x0008, + RIGHTUP = 0x0010, + MIDDLEDOWN = 0x0020, + MIDDLEUP = 0x0040, + VIRTUALDESK = 0x4000, + WHEEL = 0x0800, + XDOWN = 0x0080, + XUP = 0x0100 + } + [Flags] + internal enum KEYEVENTF : uint + { + EXTENDEDKEY = 0x0001, + KEYUP = 0x0002, + SCANCODE = 0x0008, + UNICODE = 0x0004 + } + + internal enum VirtualKeyShort : short + { + /// + ///Left mouse button + /// + LBUTTON = 0x01, + /// + ///Right mouse button + /// + RBUTTON = 0x02, + /// + ///Control-break processing + /// + CANCEL = 0x03, + /// + ///Middle mouse button (three-button mouse) + /// + MBUTTON = 0x04, + /// + ///Windows 2000/XP: X1 mouse button + /// + XBUTTON1 = 0x05, + /// + ///Windows 2000/XP: X2 mouse button + /// + XBUTTON2 = 0x06, + /// + ///BACKSPACE key + /// + BACK = 0x08, + /// + ///TAB key + /// + TAB = 0x09, + /// + ///CLEAR key + /// + CLEAR = 0x0C, + /// + ///ENTER key + /// + RETURN = 0x0D, + /// + ///SHIFT key + /// + SHIFT = 0x10, + /// + ///CTRL key + /// + CONTROL = 0x11, + /// + ///ALT key + /// + MENU = 0x12, + /// + ///PAUSE key + /// + PAUSE = 0x13, + /// + ///CAPS LOCK key + /// + CAPITAL = 0x14, + /// + ///Input Method Editor (IME) Kana mode + /// + KANA = 0x15, + /// + ///IME Hangul mode + /// + HANGUL = 0x15, + /// + ///IME Junja mode + /// + JUNJA = 0x17, + /// + ///IME final mode + /// + FINAL = 0x18, + /// + ///IME Hanja mode + /// + HANJA = 0x19, + /// + ///IME Kanji mode + /// + KANJI = 0x19, + /// + ///ESC key + /// + ESCAPE = 0x1B, + /// + ///IME convert + /// + CONVERT = 0x1C, + /// + ///IME nonconvert + /// + NONCONVERT = 0x1D, + /// + ///IME accept + /// + ACCEPT = 0x1E, + /// + ///IME mode change request + /// + MODECHANGE = 0x1F, + /// + ///SPACEBAR + /// + SPACE = 0x20, + /// + ///PAGE UP key + /// + PRIOR = 0x21, + /// + ///PAGE DOWN key + /// + NEXT = 0x22, + /// + ///END key + /// + END = 0x23, + /// + ///HOME key + /// + HOME = 0x24, + /// + ///LEFT ARROW key + /// + LEFT = 0x25, + /// + ///UP ARROW key + /// + UP = 0x26, + /// + ///RIGHT ARROW key + /// + RIGHT = 0x27, + /// + ///DOWN ARROW key + /// + DOWN = 0x28, + /// + ///SELECT key + /// + SELECT = 0x29, + /// + ///PRINT key + /// + PRINT = 0x2A, + /// + ///EXECUTE key + /// + EXECUTE = 0x2B, + /// + ///PRINT SCREEN key + /// + SNAPSHOT = 0x2C, + /// + ///INS key + /// + INSERT = 0x2D, + /// + ///DEL key + /// + DELETE = 0x2E, + /// + ///HELP key + /// + HELP = 0x2F, + /// + ///0 key + /// + KEY_0 = 0x30, + /// + ///1 key + /// + KEY_1 = 0x31, + /// + ///2 key + /// + KEY_2 = 0x32, + /// + ///3 key + /// + KEY_3 = 0x33, + /// + ///4 key + /// + KEY_4 = 0x34, + /// + ///5 key + /// + KEY_5 = 0x35, + /// + ///6 key + /// + KEY_6 = 0x36, + /// + ///7 key + /// + KEY_7 = 0x37, + /// + ///8 key + /// + KEY_8 = 0x38, + /// + ///9 key + /// + KEY_9 = 0x39, + /// + ///A key + /// + KEY_A = 0x41, + /// + ///B key + /// + KEY_B = 0x42, + /// + ///C key + /// + KEY_C = 0x43, + /// + ///D key + /// + KEY_D = 0x44, + /// + ///E key + /// + KEY_E = 0x45, + /// + ///F key + /// + KEY_F = 0x46, + /// + ///G key + /// + KEY_G = 0x47, + /// + ///H key + /// + KEY_H = 0x48, + /// + ///I key + /// + KEY_I = 0x49, + /// + ///J key + /// + KEY_J = 0x4A, + /// + ///K key + /// + KEY_K = 0x4B, + /// + ///L key + /// + KEY_L = 0x4C, + /// + ///M key + /// + KEY_M = 0x4D, + /// + ///N key + /// + KEY_N = 0x4E, + /// + ///O key + /// + KEY_O = 0x4F, + /// + ///P key + /// + KEY_P = 0x50, + /// + ///Q key + /// + KEY_Q = 0x51, + /// + ///R key + /// + KEY_R = 0x52, + /// + ///S key + /// + KEY_S = 0x53, + /// + ///T key + /// + KEY_T = 0x54, + /// + ///U key + /// + KEY_U = 0x55, + /// + ///V key + /// + KEY_V = 0x56, + /// + ///W key + /// + KEY_W = 0x57, + /// + ///X key + /// + KEY_X = 0x58, + /// + ///Y key + /// + KEY_Y = 0x59, + /// + ///Z key + /// + KEY_Z = 0x5A, + /// + ///Left Windows key (Microsoft Natural keyboard) + /// + LWIN = 0x5B, + /// + ///Right Windows key (Natural keyboard) + /// + RWIN = 0x5C, + /// + ///Applications key (Natural keyboard) + /// + APPS = 0x5D, + /// + ///Computer Sleep key + /// + SLEEP = 0x5F, + /// + ///Numeric keypad 0 key + /// + NUMPAD0 = 0x60, + /// + ///Numeric keypad 1 key + /// + NUMPAD1 = 0x61, + /// + ///Numeric keypad 2 key + /// + NUMPAD2 = 0x62, + /// + ///Numeric keypad 3 key + /// + NUMPAD3 = 0x63, + /// + ///Numeric keypad 4 key + /// + NUMPAD4 = 0x64, + /// + ///Numeric keypad 5 key + /// + NUMPAD5 = 0x65, + /// + ///Numeric keypad 6 key + /// + NUMPAD6 = 0x66, + /// + ///Numeric keypad 7 key + /// + NUMPAD7 = 0x67, + /// + ///Numeric keypad 8 key + /// + NUMPAD8 = 0x68, + /// + ///Numeric keypad 9 key + /// + NUMPAD9 = 0x69, + /// + ///Multiply key + /// + MULTIPLY = 0x6A, + /// + ///Add key + /// + ADD = 0x6B, + /// + ///Separator key + /// + SEPARATOR = 0x6C, + /// + ///Subtract key + /// + SUBTRACT = 0x6D, + /// + ///Decimal key + /// + DECIMAL = 0x6E, + /// + ///Divide key + /// + DIVIDE = 0x6F, + /// + ///F1 key + /// + F1 = 0x70, + /// + ///F2 key + /// + F2 = 0x71, + /// + ///F3 key + /// + F3 = 0x72, + /// + ///F4 key + /// + F4 = 0x73, + /// + ///F5 key + /// + F5 = 0x74, + /// + ///F6 key + /// + F6 = 0x75, + /// + ///F7 key + /// + F7 = 0x76, + /// + ///F8 key + /// + F8 = 0x77, + /// + ///F9 key + /// + F9 = 0x78, + /// + ///F10 key + /// + F10 = 0x79, + /// + ///F11 key + /// + F11 = 0x7A, + /// + ///F12 key + /// + F12 = 0x7B, + /// + ///F13 key + /// + F13 = 0x7C, + /// + ///F14 key + /// + F14 = 0x7D, + /// + ///F15 key + /// + F15 = 0x7E, + /// + ///F16 key + /// + F16 = 0x7F, + /// + ///F17 key + /// + F17 = 0x80, + /// + ///F18 key + /// + F18 = 0x81, + /// + ///F19 key + /// + F19 = 0x82, + /// + ///F20 key + /// + F20 = 0x83, + /// + ///F21 key + /// + F21 = 0x84, + /// + ///F22 key, (PPC only) Key used to lock device. + /// + F22 = 0x85, + /// + ///F23 key + /// + F23 = 0x86, + /// + ///F24 key + /// + F24 = 0x87, + /// + ///NUM LOCK key + /// + NUMLOCK = 0x90, + /// + ///SCROLL LOCK key + /// + SCROLL = 0x91, + /// + ///Left SHIFT key + /// + LSHIFT = 0xA0, + /// + ///Right SHIFT key + /// + RSHIFT = 0xA1, + /// + ///Left CONTROL key + /// + LCONTROL = 0xA2, + /// + ///Right CONTROL key + /// + RCONTROL = 0xA3, + /// + ///Left MENU key + /// + LMENU = 0xA4, + /// + ///Right MENU key + /// + RMENU = 0xA5, + /// + ///Windows 2000/XP: Browser Back key + /// + BROWSER_BACK = 0xA6, + /// + ///Windows 2000/XP: Browser Forward key + /// + BROWSER_FORWARD = 0xA7, + /// + ///Windows 2000/XP: Browser Refresh key + /// + BROWSER_REFRESH = 0xA8, + /// + ///Windows 2000/XP: Browser Stop key + /// + BROWSER_STOP = 0xA9, + /// + ///Windows 2000/XP: Browser Search key + /// + BROWSER_SEARCH = 0xAA, + /// + ///Windows 2000/XP: Browser Favorites key + /// + BROWSER_FAVORITES = 0xAB, + /// + ///Windows 2000/XP: Browser Start and Home key + /// + BROWSER_HOME = 0xAC, + /// + ///Windows 2000/XP: Volume Mute key + /// + VOLUME_MUTE = 0xAD, + /// + ///Windows 2000/XP: Volume Down key + /// + VOLUME_DOWN = 0xAE, + /// + ///Windows 2000/XP: Volume Up key + /// + VOLUME_UP = 0xAF, + /// + ///Windows 2000/XP: Next Track key + /// + MEDIA_NEXT_TRACK = 0xB0, + /// + ///Windows 2000/XP: Previous Track key + /// + MEDIA_PREV_TRACK = 0xB1, + /// + ///Windows 2000/XP: Stop Media key + /// + MEDIA_STOP = 0xB2, + /// + ///Windows 2000/XP: Play/Pause Media key + /// + MEDIA_PLAY_PAUSE = 0xB3, + /// + ///Windows 2000/XP: Start Mail key + /// + LAUNCH_MAIL = 0xB4, + /// + ///Windows 2000/XP: Select Media key + /// + LAUNCH_MEDIA_SELECT = 0xB5, + /// + ///Windows 2000/XP: Start Application 1 key + /// + LAUNCH_APP1 = 0xB6, + /// + ///Windows 2000/XP: Start Application 2 key + /// + LAUNCH_APP2 = 0xB7, + /// + ///Used for miscellaneous characters; it can vary by keyboard. + /// + OEM_1 = 0xBA, + /// + ///Windows 2000/XP: For any country/region, the '+' key + /// + OEM_PLUS = 0xBB, + /// + ///Windows 2000/XP: For any country/region, the ',' key + /// + OEM_COMMA = 0xBC, + /// + ///Windows 2000/XP: For any country/region, the '-' key + /// + OEM_MINUS = 0xBD, + /// + ///Windows 2000/XP: For any country/region, the '.' key + /// + OEM_PERIOD = 0xBE, + /// + ///Used for miscellaneous characters; it can vary by keyboard. + /// + OEM_2 = 0xBF, + /// + ///Used for miscellaneous characters; it can vary by keyboard. + /// + OEM_3 = 0xC0, + /// + ///Used for miscellaneous characters; it can vary by keyboard. + /// + OEM_4 = 0xDB, + /// + ///Used for miscellaneous characters; it can vary by keyboard. + /// + OEM_5 = 0xDC, + /// + ///Used for miscellaneous characters; it can vary by keyboard. + /// + OEM_6 = 0xDD, + /// + ///Used for miscellaneous characters; it can vary by keyboard. + /// + OEM_7 = 0xDE, + /// + ///Used for miscellaneous characters; it can vary by keyboard. + /// + OEM_8 = 0xDF, + /// + ///Windows 2000/XP: Either the angle bracket key or the backslash key on the RT 102-key keyboard + /// + OEM_102 = 0xE2, + /// + ///Windows 95/98/Me, Windows NT 4.0, Windows 2000/XP: IME PROCESS key + /// + PROCESSKEY = 0xE5, + /// + ///Windows 2000/XP: Used to pass Unicode characters as if they were keystrokes. + ///The VK_PACKET key is the low word of a 32-bit Virtual Key value used for non-keyboard input methods. For more information, + ///see Remark in KEYBDINPUT, SendInput, WM_KEYDOWN, and WM_KEYUP + /// + PACKET = 0xE7, + /// + ///Attn key + /// + ATTN = 0xF6, + /// + ///CrSel key + /// + CRSEL = 0xF7, + /// + ///ExSel key + /// + EXSEL = 0xF8, + /// + ///Erase EOF key + /// + EREOF = 0xF9, + /// + ///Play key + /// + PLAY = 0xFA, + /// + ///Zoom key + /// + ZOOM = 0xFB, + /// + ///Reserved + /// + NONAME = 0xFC, + /// + ///PA1 key + /// + PA1 = 0xFD, + /// + ///Clear key + /// + OEM_CLEAR = 0xFE + } + internal enum ScanCodeShort : short + { + LBUTTON = 0, + RBUTTON = 0, + CANCEL = 70, + MBUTTON = 0, + XBUTTON1 = 0, + XBUTTON2 = 0, + BACK = 14, + TAB = 15, + CLEAR = 76, + RETURN = 28, + SHIFT = 42, + CONTROL = 29, + MENU = 56, + PAUSE = 0, + CAPITAL = 58, + KANA = 0, + HANGUL = 0, + JUNJA = 0, + FINAL = 0, + HANJA = 0, + KANJI = 0, + ESCAPE = 1, + CONVERT = 0, + NONCONVERT = 0, + ACCEPT = 0, + MODECHANGE = 0, + SPACE = 57, + PRIOR = 73, + NEXT = 81, + END = 79, + HOME = 71, + LEFT = 75, + UP = 72, + RIGHT = 77, + DOWN = 80, + SELECT = 0, + PRINT = 0, + EXECUTE = 0, + SNAPSHOT = 84, + INSERT = 82, + DELETE = 83, + HELP = 99, + KEY_0 = 11, + KEY_1 = 2, + KEY_2 = 3, + KEY_3 = 4, + KEY_4 = 5, + KEY_5 = 6, + KEY_6 = 7, + KEY_7 = 8, + KEY_8 = 9, + KEY_9 = 10, + KEY_A = 30, + KEY_B = 48, + KEY_C = 46, + KEY_D = 32, + KEY_E = 18, + KEY_F = 33, + KEY_G = 34, + KEY_H = 35, + KEY_I = 23, + KEY_J = 36, + KEY_K = 37, + KEY_L = 38, + KEY_M = 50, + KEY_N = 49, + KEY_O = 24, + KEY_P = 25, + KEY_Q = 16, + KEY_R = 19, + KEY_S = 31, + KEY_T = 20, + KEY_U = 22, + KEY_V = 47, + KEY_W = 17, + KEY_X = 45, + KEY_Y = 21, + KEY_Z = 44, + LWIN = 91, + RWIN = 92, + APPS = 93, + SLEEP = 95, + NUMPAD0 = 82, + NUMPAD1 = 79, + NUMPAD2 = 80, + NUMPAD3 = 81, + NUMPAD4 = 75, + NUMPAD5 = 76, + NUMPAD6 = 77, + NUMPAD7 = 71, + NUMPAD8 = 72, + NUMPAD9 = 73, + MULTIPLY = 55, + ADD = 78, + SEPARATOR = 0, + SUBTRACT = 74, + DECIMAL = 83, + DIVIDE = 53, + F1 = 59, + F2 = 60, + F3 = 61, + F4 = 62, + F5 = 63, + F6 = 64, + F7 = 65, + F8 = 66, + F9 = 67, + F10 = 68, + F11 = 87, + F12 = 88, + F13 = 100, + F14 = 101, + F15 = 102, + F16 = 103, + F17 = 104, + F18 = 105, + F19 = 106, + F20 = 107, + F21 = 108, + F22 = 109, + F23 = 110, + F24 = 118, + NUMLOCK = 69, + SCROLL = 70, + LSHIFT = 42, + RSHIFT = 54, + LCONTROL = 29, + RCONTROL = 29, + LMENU = 56, + RMENU = 56, + BROWSER_BACK = 106, + BROWSER_FORWARD = 105, + BROWSER_REFRESH = 103, + BROWSER_STOP = 104, + BROWSER_SEARCH = 101, + BROWSER_FAVORITES = 102, + BROWSER_HOME = 50, + VOLUME_MUTE = 32, + VOLUME_DOWN = 46, + VOLUME_UP = 48, + MEDIA_NEXT_TRACK = 25, + MEDIA_PREV_TRACK = 16, + MEDIA_STOP = 36, + MEDIA_PLAY_PAUSE = 34, + LAUNCH_MAIL = 108, + LAUNCH_MEDIA_SELECT = 109, + LAUNCH_APP1 = 107, + LAUNCH_APP2 = 33, + OEM_1 = 39, + OEM_PLUS = 13, + OEM_COMMA = 51, + OEM_MINUS = 12, + OEM_PERIOD = 52, + OEM_2 = 53, + OEM_3 = 41, + OEM_4 = 26, + OEM_5 = 43, + OEM_6 = 27, + OEM_7 = 40, + OEM_8 = 0, + OEM_102 = 86, + PROCESSKEY = 0, + PACKET = 0, + ATTN = 0, + CRSEL = 0, + EXSEL = 0, + EREOF = 93, + PLAY = 0, + ZOOM = 98, + NONAME = 0, + PA1 = 0, + OEM_CLEAR = 0, + } + #endregion +#pragma warning restore 649 + + public static void PostMessageSafe(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam) + { + bool returnValue = PostMessage(hWnd, msg, wParam, lParam); + if (!returnValue) + { + // An error occured + throw new Win32Exception(Marshal.GetLastWin32Error()); + } + } + + private static void SendInput(SimulationMode mode, int delta, Point p) + { + INPUT[] pInputs; + // Click Mouse + switch (mode) + { + case SimulationMode.RightClick: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.RIGHTDOWN,}}}, new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.RIGHTUP,}}} + }; + break; + case SimulationMode.LeftClick: + case SimulationMode.DoubleClick: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.LEFTDOWN,}}}, new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.LEFTUP,}}} + }; + break; + case SimulationMode.LeftDownAbs: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.LEFTDOWN | MOUSEEVENTF.ABSOLUTE, dx = p.X, dy = p.Y}}} + }; + break; + case SimulationMode.LeftDown: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.LEFTDOWN,}}} + }; + break; + case SimulationMode.LeftMove: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.LEFTDOWN | MOUSEEVENTF.MOVE, dx = p.X, dy = p.Y}}} + }; + break; + case SimulationMode.LeftUp: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.LEFTUP,}}} + }; + break; + case SimulationMode.MiddleClick: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.MIDDLEDOWN,}}}, new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.MIDDLEUP,}}} + }; + break; + case SimulationMode.ScrollH: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.HWHEEL, mouseData = delta * 60}}} + }; + break; + case SimulationMode.ScrollV: + pInputs = new[] + { + new INPUT() {type = InputType.MOUSE, U = new InputUnion() {mi = new MOUSEINPUT() {dwFlags = MOUSEEVENTF.WHEEL, mouseData = delta * 60}}} + }; + break; + default: + throw new ArgumentOutOfRangeException("mode", mode, null); + } + if (pInputs.Length > 0) + SendInput((uint)pInputs.Length, pInputs, INPUT.Size); + } + + private static void SendMessage(IntPtr wndHandle, SimulationMode mode, IntPtr lParam, int delta) + { + switch (mode) + { + case SimulationMode.LeftClick: + SendMessage(wndHandle, (uint)MouseEvents.WM_LBUTTONDOWN, (IntPtr)1, lParam); + SendMessage(wndHandle, (uint)MouseEvents.WM_LBUTTONUP, IntPtr.Zero, lParam); + break; + case SimulationMode.RightClick: + SendMessage(wndHandle, (uint)MouseEvents.WM_RBUTTONDOWN, (IntPtr)2, lParam); + SendMessage(wndHandle, (uint)MouseEvents.WM_RBUTTONUP, IntPtr.Zero, lParam); + break; + case SimulationMode.DoubleClick: + SendMessage(wndHandle, (uint)MouseEvents.WM_LBUTTONDBLCLK, (IntPtr)1, lParam); + SendMessage(wndHandle, (uint)MouseEvents.WM_LBUTTONUP, IntPtr.Zero, lParam); + break; + case SimulationMode.MiddleClick: + SendMessage(wndHandle, (uint)MouseEvents.WM_MBUTTONDOWN, (IntPtr)10, lParam); + SendMessage(wndHandle, (uint)MouseEvents.WM_MBUTTONUP, IntPtr.Zero, lParam); + break; + case SimulationMode.ScrollH: + SendMessage(wndHandle, (uint)MouseEvents.WM_MOUSEHWHEEL, (IntPtr)(delta * 60 << 16), lParam); + break; + case SimulationMode.ScrollV: + SendMessage(wndHandle, (uint)MouseEvents.WM_MOUSEWHEEL, (IntPtr)(delta * 60 << 16), lParam); + break; + case SimulationMode.LeftDownAbs: + break; + case SimulationMode.LeftDown: + break; + case SimulationMode.LeftMove: + break; + case SimulationMode.LeftUp: + break; + default: + throw new ArgumentOutOfRangeException("mode", mode, null); + } + } + + private static void SendNotifyMessage(IntPtr wndHandle, SimulationMode mode, IntPtr lParam, int delta) + { + switch (mode) + { + case SimulationMode.LeftClick: + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_LBUTTONDOWN, (UIntPtr)1, lParam); + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_LBUTTONUP, UIntPtr.Zero, lParam); + break; + case SimulationMode.RightClick: + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_RBUTTONDOWN, (UIntPtr)2, lParam); + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_RBUTTONUP, UIntPtr.Zero, lParam); + break; + case SimulationMode.DoubleClick: + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_LBUTTONDBLCLK, (UIntPtr)1, lParam); + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_LBUTTONUP, UIntPtr.Zero, lParam); + break; + case SimulationMode.MiddleClick: + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_MBUTTONDOWN, (UIntPtr)10, lParam); + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_MBUTTONUP, UIntPtr.Zero, lParam); + break; + case SimulationMode.ScrollH: + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_MOUSEHWHEEL, (UIntPtr)(delta * 60 << 16), lParam); + break; + case SimulationMode.ScrollV: + SendNotifyMessage(wndHandle, (uint)MouseEvents.WM_MOUSEWHEEL, (UIntPtr)(delta * 60 << 16), lParam); + break; + case SimulationMode.LeftDownAbs: + break; + case SimulationMode.LeftDown: + break; + case SimulationMode.LeftMove: + break; + case SimulationMode.LeftUp: + break; + default: + throw new ArgumentOutOfRangeException("mode", mode, null); + } + } + + private static IntPtr lastHandle; + private static Point lastPoint; + // Move the cursor to a given point over a window + + public enum SimulationMode + { + LeftClick, + RightClick, + DoubleClick, + MiddleClick, + ScrollH, + ScrollV, + LeftDownAbs, + LeftDown, + LeftMove, + LeftUp, + } + + private enum MouseEvents + { + WM_MOUSEMOVE = 0x200, + WM_LBUTTONDOWN = 0x201, + WM_LBUTTONUP = 0x202, + WM_LBUTTONDBLCLK = 0x203, + WM_RBUTTONDOWN = 0x204, + WM_RBUTTONUP = 0x205, + WM_RBUTTONDBLCLK = 0x206, + WM_MBUTTONDOWN = 0x207, + WM_MBUTTONUP = 0x208, + WM_MBUTTONDBLCLK = 0x209, + WM_MOUSEWHEEL = 0x20A, + WM_XBUTTONDOWN = 0x20B, + WM_XBUTTONUP = 0x20C, + WM_XBUTTONDBLCLK = 0x20D, + WM_MOUSEHWHEEL = 0x20E, + } + } +} diff --git a/VRGameOverlay/VROverlayWindow/DeviceManager.cs b/VRGameOverlay/VROverlayWindow/DeviceManager.cs new file mode 100644 index 0000000..7a3d20e --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/DeviceManager.cs @@ -0,0 +1,210 @@ +using SharpDX; +using SharpDX.Direct3D11; +using SharpDX.DXGI; +//using System; +//using System.Windows.Forms; +using Device = SharpDX.Direct3D11.Device; + +namespace VRGameOverlay.VROverlayWindow +{ + public enum GraphicsDeviceStatus + { + /// + /// The device is running fine. + /// + Normal, + + /// + /// The video card has been physically removed from the system, or a driver upgrade for the video card has occurred. The application should destroy and recreate the device. + /// + Removed, + + /// + /// The application's device failed due to badly formed commands sent by the application. This is an design-time issue that should be investigated and fixed. + /// + Hung, + + /// + /// The device failed due to a badly formed command. This is a run-time issue; The application should destroy and recreate the device. + /// + Reset, + + /// + /// The driver encountered a problem and was put into the device removed state. + /// + InternalError, + + /// + /// The application provided invalid parameter data; this must be debugged and fixed before the application is released. + /// + InvalidCall, + } + + public class DeviceManager : IDisposable + { + protected bool disposedValue = false; // To detect redundant calls + protected Device _device; + protected SwapChain _swapChain; + + public Device device { get { return _device; } } + public DeviceContext1 context { get; private set; } + //public Factory4 factory { get; private set; } + public RenderTargetView backBufferView { get; private set; } + public SwapChain swapChain { get { return _swapChain; } } + + + public SharpDX.Direct2D1.Device Device2D { get; private set; } + public SharpDX.Direct2D1.DeviceContext DeviceContext2D { get; private set; } + public SharpDX.DXGI.Device DXGIDevice { get; private set; } + + public DeviceManager(CVRSystem vrSystem /*, Form form = null */) + { + try + { + int adapterIndex = 0; + if (vrSystem != null) + { + vrSystem.GetDXGIOutputInfo(ref adapterIndex); + } + + using (var factory = new Factory4()) + using (var adapter = factory.GetAdapter(adapterIndex)) + { + /* + if (form != null) + { + var swapChainDescription = new SwapChainDescription + { + BufferCount = 1, + Flags = SwapChainFlags.None, + IsWindowed = true, + ModeDescription = + { + Format = Format.B8G8R8A8_UNorm, + Width = form.ClientSize.Width, + Height = form.ClientSize.Height, + RefreshRate = { Numerator = 144, Denominator = 1 } + }, + OutputHandle = form.Handle, + SampleDescription = { Count = 1, Quality = 0 }, + SwapEffect = SwapEffect.Discard, + Usage = Usage.RenderTargetOutput + }; + + // Retrieve the Direct3D 11.1 device and device context + Device.CreateWithSwapChain(adapter, DeviceCreationFlags.BgraSupport, swapChainDescription, out _device, out _swapChain); + + using (var backBuffer = swapChain.GetBackBuffer(0)) + backBufferView = new RenderTargetView(device, backBuffer); + + factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.None); + } + else + { + var creationFlags = DeviceCreationFlags.BgraSupport; +#if DEBUG + // Enable D3D device debug layer + creationFlags |= DeviceCreationFlags.Debug; +#endif + _device = new Device(adapter, creationFlags); + } + */ + + + var creationFlags = DeviceCreationFlags.BgraSupport; + _device = new Device(adapter, creationFlags); + + DXGIDevice = device.QueryInterface(); + Device2D = new SharpDX.Direct2D1.Device(DXGIDevice); + DeviceContext2D = new SharpDX.Direct2D1.DeviceContext(Device2D, SharpDX.Direct2D1.DeviceContextOptions.None); + + context = _device.ImmediateContext.QueryInterface(); + } + } + catch (SharpDXException e) + { + Console.WriteLine(e.Message); + } + } + + internal bool testDevice() + { + return true; + } + + internal void refreshDevice() + { + device.Dispose(); + //device = new Device(SharpDX.Direct3D.DriverType.Hardware); + } + + public GraphicsDeviceStatus GraphicsDeviceStatus + { + get + { + var result = device.DeviceRemovedReason; + if (result == SharpDX.DXGI.ResultCode.DeviceRemoved) + { + return GraphicsDeviceStatus.Removed; + } + + if (result == SharpDX.DXGI.ResultCode.DeviceReset) + { + return GraphicsDeviceStatus.Reset; + } + + if (result == SharpDX.DXGI.ResultCode.DeviceHung) + { + return GraphicsDeviceStatus.Hung; + } + + if (result == SharpDX.DXGI.ResultCode.DriverInternalError) + { + return GraphicsDeviceStatus.InternalError; + } + + if (result == SharpDX.DXGI.ResultCode.InvalidCall) + { + return GraphicsDeviceStatus.InvalidCall; + } + + if (result.Code < 0) + { + return GraphicsDeviceStatus.Reset; + } + + return GraphicsDeviceStatus.Normal; + } + } + protected virtual void Dispose(bool disposing) + { + + } + + ~DeviceManager() + { + Dispose(false); + } + + public void Dispose() + { + if (!disposedValue) + { + DeviceContext2D?.Dispose(); + Device2D?.Dispose(); + DXGIDevice?.Dispose(); + context?.Dispose(); + device?.Dispose(); + _swapChain?.Dispose(); + DeviceContext2D = null; + Device2D = null; + DXGIDevice = null; + _device = null; + _swapChain = null; + disposedValue = true; + context = null; + } + GC.SuppressFinalize(this); + } + } +} diff --git a/VRGameOverlay/VROverlayWindow/DeviceState.cs b/VRGameOverlay/VROverlayWindow/DeviceState.cs new file mode 100644 index 0000000..f78c552 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/DeviceState.cs @@ -0,0 +1,12 @@ +// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp) +// Distributed under the MIT license. See the LICENSE.md file in the project root for more information. + +namespace VRGameOverlay.VROverlayWindow +{ + public enum DeviceState + { + Invalid, + OutOfRange, + Valid, + } +} diff --git a/VRGameOverlay/VROverlayWindow/Extentions.cs b/VRGameOverlay/VROverlayWindow/Extentions.cs new file mode 100644 index 0000000..5d4ae74 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/Extentions.cs @@ -0,0 +1,168 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +using SharpDX; + +namespace VRGameOverlay.VROverlayWindow +{ + public static class Extentions + { + + public static void FromHmdMatrix(ref HmdMatrix34_t source, ref Matrix destination) + { + destination.M11 = source.m0; + destination.M21 = source.m1; + destination.M31 = source.m2; + destination.M41 = source.m3; + destination.M12 = source.m4; + destination.M22 = source.m5; + destination.M32 = source.m6; + destination.M42 = source.m7; + destination.M13 = source.m8; + destination.M23 = source.m9; + destination.M33 = source.m10; + destination.M43 = source.m11; + //destination.M14 = 0.0f; + //destination.M24 = 0.0f; + //destination.M34 = 0.0f; + //destination.M44 = 1.0f; + } + + public static Matrix FromHmdMatrix(HmdMatrix34_t source) + { + var destination = new Matrix(); + + destination.M11 = source.m0; + destination.M21 = source.m1; + destination.M31 = source.m2; + destination.M41 = source.m3; + destination.M12 = source.m4; + destination.M22 = source.m5; + destination.M32 = source.m6; + destination.M42 = source.m7; + destination.M13 = source.m8; + destination.M23 = source.m9; + destination.M33 = source.m10; + destination.M43 = source.m11; + destination.M14 = 0.0f; + destination.M24 = 0.0f; + destination.M34 = 0.0f; + destination.M44 = 1.0f; + + return destination; + } + public static Matrix FromHmdMatrix(this Matrix destination, HmdMatrix34_t source) + { + destination.M11 = source.m0; + destination.M21 = source.m1; + destination.M31 = source.m2; + destination.M41 = source.m3; + destination.M12 = source.m4; + destination.M22 = source.m5; + destination.M32 = source.m6; + destination.M42 = source.m7; + destination.M13 = source.m8; + destination.M23 = source.m9; + destination.M33 = source.m10; + destination.M43 = source.m11; + //destination.M14 = 0.0f; + //destination.M24 = 0.0f; + //destination.M34 = 0.0f; + //destination.M44 = 1.0f; + + return destination; + } + public static Matrix FromHmdMatrix(HmdMatrix44_t source) + { + var destination = new Matrix(); + + destination.M11 = source.m0; + destination.M21 = source.m1; + destination.M31 = source.m2; + destination.M41 = source.m3; + destination.M12 = source.m4; + destination.M22 = source.m5; + destination.M32 = source.m6; + destination.M42 = source.m7; + destination.M13 = source.m8; + destination.M23 = source.m9; + destination.M33 = source.m10; + destination.M43 = source.m11; + destination.M14 = source.m12; + destination.M24 = source.m13; + destination.M34 = source.m14; + destination.M44 = source.m15; + + return destination; + } + public static Matrix FromHmdMatrix(this Matrix destination, HmdMatrix44_t source) + { + destination.M11 = source.m0; + destination.M21 = source.m1; + destination.M31 = source.m2; + destination.M41 = source.m3; + destination.M12 = source.m4; + destination.M22 = source.m5; + destination.M32 = source.m6; + destination.M42 = source.m7; + destination.M13 = source.m8; + destination.M23 = source.m9; + destination.M33 = source.m10; + destination.M43 = source.m11; + destination.M14 = source.m12; + destination.M24 = source.m13; + destination.M34 = source.m14; + destination.M44 = source.m15; + + return destination; + } + + public static HmdMatrix34_t ToHmdMatrix34(this Matrix m) + { + //var m = Matrix.Scaling(new Vector3(1.0f, 1.0f, 1.0f)) * Matrix.Translation(pos) * Matrix.RotationQuaternion(rot); + + var pose = new HmdMatrix34_t + { + m0 = m[0, 0], + m1 = m[0, 1], + m2 = m[0, 2], + m3 = m[0, 3], + + m4 = m[1, 0], + m5 = m[1, 1], + m6 = m[1, 2], + m7 = m[1, 3], + + m8 = m[2, 0], + m9 = m[2, 1], + m10 = m[2, 2], + m11 = m[2, 3] + + }; + return pose; + } + public static float sqrMagnitude(this Vector3 v) + { + return v.X * v.X + v.Y * v.Y + v.Z * v.Z; + } + + // Returns the angle in degrees between /from/ and /to/. This is always the smallest + public static float Angle(this Vector3 from, Vector3 to) + { + var normalFrom = Vector3.Normalize(from); + var normalTo = Vector3.Normalize(to); + // sqrt(a) * sqrt(b) = sqrt(a * b) -- valid for real numbers + float denominator = (float)Math.Sqrt(normalFrom.sqrMagnitude() * normalTo.sqrMagnitude()); + if (denominator < MathUtil.kEpsilonNormalSqrt) + return 0F; + + + float dot = MathUtil.Clamp(Vector3.Dot(normalFrom, normalTo) / denominator, -1F, 1F); + return (float)Math.Acos(dot) * MathUtil.Rad2Deg; + } + } + +} diff --git a/VRGameOverlay/VROverlayWindow/GDIStuff.cs b/VRGameOverlay/VROverlayWindow/GDIStuff.cs new file mode 100644 index 0000000..a955400 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/GDIStuff.cs @@ -0,0 +1,40 @@ +using System; +using System.Runtime.InteropServices; + +namespace VRGameOverlay.VROverlayWindow +{ + class GDIStuff + { + #region Class Variables + public const int SRCCOPY = 13369376; + #endregion + + + #region Class Functions + [DllImport("gdi32.dll", EntryPoint = "CreateDC")] + public static extern IntPtr CreateDC(IntPtr lpszDriver, string lpszDevice, IntPtr lpszOutput, IntPtr lpInitData); + + [DllImport("gdi32.dll", EntryPoint = "DeleteDC")] + public static extern IntPtr DeleteDC(IntPtr hDc); + + [DllImport("gdi32.dll", EntryPoint = "DeleteObject")] + public static extern IntPtr DeleteObject(IntPtr hDc); + + [DllImport("gdi32.dll", EntryPoint = "BitBlt")] + public static extern bool BitBlt(IntPtr hdcDest, int xDest, + int yDest, int wDest, + int hDest, IntPtr hdcSource, + int xSrc, int ySrc, int RasterOp); + + [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleBitmap")] + public static extern IntPtr CreateCompatibleBitmap + (IntPtr hdc, int nWidth, int nHeight); + + [DllImport("gdi32.dll", EntryPoint = "CreateCompatibleDC")] + public static extern IntPtr CreateCompatibleDC(IntPtr hdc); + + [DllImport("gdi32.dll", EntryPoint = "SelectObject")] + public static extern IntPtr SelectObject(IntPtr hdc, IntPtr bmp); + #endregion + } +} diff --git a/VRGameOverlay/VROverlayWindow/MathUtil.cs b/VRGameOverlay/VROverlayWindow/MathUtil.cs new file mode 100644 index 0000000..6f69f89 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/MathUtil.cs @@ -0,0 +1,721 @@ +// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp) +// Distributed under the MIT license. See the LICENSE.md file in the project root for more information. +// +// ----------------------------------------------------------------------------- +// Original code from SlimMath project. http://code.google.com/p/slimmath/ +// Greetings to SlimDX Group. Original code published with the following license: +// ----------------------------------------------------------------------------- +/* +* Copyright (c) 2007-2011 SlimDX Group +* +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: +* +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. +* +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +* THE SOFTWARE. +*/ + +using System; +using System.Runtime.CompilerServices; +using SharpDX; + +namespace VRGameOverlay.VROverlayWindow +{ + /// + /// Common utility methods for math operations. + /// + public static class MathUtil + { + /// + /// The value for which all absolute numbers smaller than are considered equal to zero. + /// + public const float ZeroTolerance = 1e-6f; // Value a 8x higher than 1.19209290E-07F + + /// + /// The value for which all absolute numbers smaller than are considered equal to zero. + /// + public const double ZeroToleranceDouble = double.Epsilon * 8; + + /// + /// A value specifying the approximation of π which is 180 degrees. + /// + public const float Pi = (float)Math.PI; + + /// + /// A value specifying the approximation of 2π which is 360 degrees. + /// + public const float TwoPi = (float)(2 * Math.PI); + + /// + /// A value specifying the approximation of π/2 which is 90 degrees. + /// + public const float PiOverTwo = (float)(Math.PI / 2); + + /// + /// A value specifying the approximation of π/4 which is 45 degrees. + /// + public const float PiOverFour = (float)(Math.PI / 4); + // + // Summary: + // /// + // Radians-to-degrees conversion constant (Read Only). + // /// + public const float Rad2Deg = 57.29578F; + + // + // Summary: + // /// + // Degrees-to-radians conversion constant (Read Only). + // /// + public const float Deg2Rad = 0.0174532924F; + + public const float kEpsilonNormalSqrt = 1e-15F; + /// + /// Checks if a and b are almost equals, taking into account the magnitude of floating point numbers (unlike method). See Remarks. + /// See remarks. + /// + /// The left value to compare. + /// The right value to compare. + /// true if a almost equal to b, false otherwise + /// + /// The code is using the technique described by Bruce Dawson in + /// Comparing Floating point numbers 2012 edition. + /// + /* + public static bool NearEqual(float a, float b) + { + // Check if the numbers are really close -- needed + // when comparing numbers near zero. + if (IsZero(a - b)) + return true; + + // Original from Bruce Dawson: http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ + int aInt = *(int*)&a; + int bInt = *(int*)&b; + + // Different signs means they do not match. + if (aInt < 0 != bInt < 0) + return false; + + // Find the difference in ULPs. + int ulp = Math.Abs(aInt - bInt); + + // Choose of maxUlp = 4 + // according to http://code.google.com/p/googletest/source/browse/trunk/include/gtest/internal/gtest-internal.h + const int maxUlp = 4; + return ulp <= maxUlp; + } + */ + + /// + /// Determines whether the specified value is close to zero (0.0f). + /// + /// The floating value. + /// true if the specified value is close to zero (0.0f); otherwise, false. + public static bool IsZero(float a) + { + return Math.Abs(a) < ZeroTolerance; + } + + /// + /// Determines whether the specified value is close to zero (0.0f). + /// + /// The floating value. + /// true if the specified value is close to zero (0.0f); otherwise, false. + public static bool IsZero(double a) + { + return Math.Abs(a) < ZeroToleranceDouble; + } + + /// + /// Determines whether the specified value is close to one (1.0f). + /// + /// The floating value. + /// true if the specified value is close to one (1.0f); otherwise, false. + public static bool IsOne(float a) + { + return IsZero(a - 1.0f); + } + + /// + /// Checks if a - b are almost equals within a float epsilon. + /// + /// The left value to compare. + /// The right value to compare. + /// Epsilon value + /// true if a almost equal to b within a float epsilon, false otherwise + public static bool WithinEpsilon(float a, float b, float epsilon) + { + float num = a - b; + return -epsilon <= num && num <= epsilon; + } + + /// + /// Creates a one-dimensional array of the specified and filled with the specified . + /// + /// The Type of the array to create. + /// The value to fill the array with. + /// The size of the array to create. + /// A new one-dimensional array of the specified type with the specified length and filled with the specified value. + public static T[] Array(T value, int length) + { + var result = new T[length]; + for (var i = 0; i < length; i++) + result[i] = value; + + return result; + } + + /// + /// Converts revolutions to degrees. + /// + /// The value to convert. + /// The converted value. + public static float RevolutionsToDegrees(float revolution) + { + return revolution * 360.0f; + } + + /// + /// Converts revolutions to radians. + /// + /// The value to convert. + /// The converted value. + public static float RevolutionsToRadians(float revolution) + { + return revolution * TwoPi; + } + + /// + /// Converts revolutions to gradians. + /// + /// The value to convert. + /// The converted value. + public static float RevolutionsToGradians(float revolution) + { + return revolution * 400.0f; + } + + /// + /// Converts degrees to revolutions. + /// + /// The value to convert. + /// The converted value. + public static float DegreesToRevolutions(float degree) + { + return degree / 360.0f; + } + + /// + /// Converts degrees to radians. + /// + /// The value to convert. + /// The converted value. + public static float DegreesToRadians(float degree) + { + return degree * (Pi / 180.0f); + } + + /// + /// Converts radians to revolutions. + /// + /// The value to convert. + /// The converted value. + public static float RadiansToRevolutions(float radian) + { + return radian / TwoPi; + } + + /// + /// Converts radians to gradians. + /// + /// The value to convert. + /// The converted value. + public static float RadiansToGradians(float radian) + { + return radian * (200.0f / Pi); + } + + /// + /// Converts gradians to revolutions. + /// + /// The value to convert. + /// The converted value. + public static float GradiansToRevolutions(float gradian) + { + return gradian / 400.0f; + } + + /// + /// Converts gradians to degrees. + /// + /// The value to convert. + /// The converted value. + public static float GradiansToDegrees(float gradian) + { + return gradian * (9.0f / 10.0f); + } + + /// + /// Converts gradians to radians. + /// + /// The value to convert. + /// The converted value. + public static float GradiansToRadians(float gradian) + { + return gradian * (Pi / 200.0f); + } + + /// + /// Converts radians to degrees. + /// + /// The value to convert. + /// The converted value. + public static float RadiansToDegrees(float radian) + { + return radian * (180.0f / Pi); + } + + /// + /// Clamps the specified value. + /// + /// The value. + /// The min. + /// The max. + /// The result of clamping a value between min and max + public static float Clamp(float value, float min, float max) + { + return value < min ? min : value > max ? max : value; + } + + /// + /// Clamps the specified value. + /// + /// The value. + /// The min. + /// The max. + /// The result of clamping a value between min and max + public static double Clamp(double value, double min, double max) + { + return value < min ? min : value > max ? max : value; + } + + /// + /// Clamps the specified value. + /// + /// The value. + /// The min. + /// The max. + /// The result of clamping a value between min and max + public static int Clamp(int value, int min, int max) + { + return value < min ? min : value > max ? max : value; + } + + /// + /// Inverse-interpolates a value linearly. + /// + /// Minimum value that takes place in inverse-interpolation. + /// Maximum value that takes place in inverse-interpolation. + /// Value to get inverse interpolation. + /// Returns an inverse-linearly interpolated coeficient. + public static float InverseLerp(float min, float max, float value) + { + if (IsZero(Math.Abs(max - min))) + return float.NaN; + return (value - min) / (max - min); + } + + /// + /// Inverse-interpolates a value linearly. + /// + /// Minimum value that takes place in inverse-interpolation. + /// Maximum value that takes place in inverse-interpolation. + /// Value to get inverse interpolation. + /// Returns an inverse-linearly interpolated coeficient. + public static double InverseLerp(double min, double max, double value) + { + if (IsZero(Math.Abs(max - min))) + return double.NaN; + return (value - min) / (max - min); + } + + /// + /// Interpolates between two values using a linear function by a given amount. + /// + /// + /// See http://www.encyclopediaofmath.org/index.php/Linear_interpolation and + /// http://fgiesen.wordpress.com/2012/08/15/linear-interpolation-past-present-and-future/ + /// + /// Value to interpolate from. + /// Value to interpolate to. + /// Interpolation amount. + /// The result of linear interpolation of values based on the amount. + public static double Lerp(double from, double to, double amount) + { + return (1 - amount) * from + amount * to; + } + + /// + /// Interpolates between two values using a linear function by a given amount. + /// + /// + /// See http://www.encyclopediaofmath.org/index.php/Linear_interpolation and + /// http://fgiesen.wordpress.com/2012/08/15/linear-interpolation-past-present-and-future/ + /// + /// Value to interpolate from. + /// Value to interpolate to. + /// Interpolation amount. + /// The result of linear interpolation of values based on the amount. + public static float Lerp(float from, float to, float amount) + { + return (1 - amount) * from + amount * to; + } + + /// + /// Interpolates between two values using a linear function by a given amount. + /// + /// + /// See http://www.encyclopediaofmath.org/index.php/Linear_interpolation and + /// http://fgiesen.wordpress.com/2012/08/15/linear-interpolation-past-present-and-future/ + /// + /// Value to interpolate from. + /// Value to interpolate to. + /// Interpolation amount. + /// The result of linear interpolation of values based on the amount. + public static byte Lerp(byte from, byte to, float amount) + { + return (byte)Lerp(from, (float)to, amount); + } + + /// + /// Performs smooth (cubic Hermite) interpolation between 0 and 1. + /// + /// + /// See https://en.wikipedia.org/wiki/Smoothstep + /// + /// Value between 0 and 1 indicating interpolation amount. + public static float SmoothStep(float amount) + { + return amount <= 0 ? 0 + : amount >= 1 ? 1 + : amount * amount * (3 - 2 * amount); + } + + /// + /// Performs a smooth(er) interpolation between 0 and 1 with 1st and 2nd order derivatives of zero at endpoints. + /// + /// + /// See https://en.wikipedia.org/wiki/Smoothstep + /// + /// Value between 0 and 1 indicating interpolation amount. + public static float SmootherStep(float amount) + { + return amount <= 0 ? 0 + : amount >= 1 ? 1 + : amount * amount * amount * (amount * (amount * 6 - 15) + 10); + } + + /// + /// Determines whether the value is inside the given range (inclusively). + /// + /// The value. + /// The minimum value of the range. + /// The maximum value of the range. + /// true if value is inside the specified range; otherwise, false. + public static bool IsInRange(float value, float min, float max) + { + return min <= value && value <= max; + } + + /// + /// Determines whether the value is inside the given range (inclusively). + /// + /// The value. + /// The minimum value of the range. + /// The maximum value of the range. + /// true if value is inside the specified range; otherwise, false. + public static bool IsInRange(int value, int min, int max) + { + return min <= value && value <= max; + } + + /// + /// Determines whether the specified x is pow2. + /// + /// The x. + /// true if the specified x is pow2; otherwise, false. + public static bool IsPow2(int x) + { + return x != 0 && (x & x - 1) == 0; + } + + /// + /// Converts a float value from sRGB to linear. + /// + /// The sRGB value. + /// A linear value. + public static float SRgbToLinear(float sRgbValue) + { + if (sRgbValue < 0.04045f) return sRgbValue / 12.92f; + return (float)Math.Pow((sRgbValue + 0.055) / 1.055, 2.4); + } + + /// + /// Converts a float value from linear to sRGB. + /// + /// The linear value. + /// The encoded sRGB value. + public static float LinearToSRgb(float linearValue) + { + if (linearValue < 0.0031308f) return linearValue * 12.92f; + return (float)(1.055 * Math.Pow(linearValue, 1 / 2.4) - 0.055); + } + + /// + /// Calculate the logarithm 2 of a floating point. + /// + /// The input float + /// Log2(x) + public static float Log2(float x) + { + return (float)Math.Log(x) / 0.6931471805599453f; + } + + /// + /// Calculate the logarithm 2 of an integer. + /// + /// The input integer + /// the log2(i) rounded to lower integer + public static int Log2(int i) + { + var r = 0; + + while ((i >>= 1) != 0) + ++r; + + return r; + } + + /// + /// Get the next power of two of an integer. + /// + /// The size. + /// System.Int32. + /// https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2 + public static int NextPowerOfTwo(int x) + { + if (x < 0) + return 0; + + x--; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + return x + 1; + } + + /// + /// Get the next power of two for a size. + /// + /// The size. + /// System.Int32. + public static float NextPowerOfTwo(float size) + { + return (float)Math.Pow(2, Math.Ceiling(Math.Log(size, 2))); + } + + /// + /// Get the previous power of two of the provided integer. + /// + /// The value + public static int PreviousPowerOfTwo(int size) + { + return 1 << (int)Math.Floor(Math.Log(size, 2)); + } + + /// + /// Get the previous power of two of the provided float. + /// + /// The value + public static float PreviousPowerOfTwo(float size) + { + return (float)Math.Pow(2, Math.Floor(Math.Log(size, 2))); + } + + /// + /// Alignes value up to match desire alignment. + /// + /// The value. + /// The alignment. + /// Aligned value (multiple of alignment). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int AlignUp(int value, int alignment) + { + int mask = alignment - 1; + return value + mask & ~mask; + } + + /// + /// Alignes value down to match desire alignment. + /// + /// The value. + /// The alignment. + /// Aligned value (multiple of alignment). + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static int AlignDown(int value, int alignment) + { + int mask = alignment - 1; + return value & ~mask; + } + + /// + /// Determines whether the specified value is aligned. + /// + /// The value. + /// The alignment. + /// true if the specified value is aligned; otherwise, false. + [MethodImpl(MethodImplOptions.AggressiveInlining)] + public static bool IsAligned(int value, int alignment) + { + return (value & alignment - 1) == 0; + } + + /// + /// Snaps a value to the nearest interval. + /// + /// The value to snap. + /// The interval gap. + /// The nearest interval to the provided value. + public static float Snap(float value, float gap) + { + if (gap == 0) + return value; + return (float)Math.Round(value / gap, MidpointRounding.AwayFromZero) * gap; + } + + /// + /// Snaps a value to the nearest interval. + /// + /// The value to snap. + /// The interval gap. + /// The nearest interval to the provided value. + public static double Snap(double value, double gap) + { + if (gap == 0) + return value; + return Math.Round(value / gap, MidpointRounding.AwayFromZero) * gap; + } + + /// + /// Snaps all vector components to the nearest interval. + /// + /// The vector to snap. + /// The interval gap. + /// A vector which components are snapped to the nearest interval. + public static Vector2 Snap(Vector2 value, float gap) + { + if (gap == 0) + return value; + return new Vector2( + (float)Math.Round(value.X / gap, MidpointRounding.AwayFromZero) * gap, + (float)Math.Round(value.Y / gap, MidpointRounding.AwayFromZero) * gap); + } + + /// + /// Snaps all vector components to the nearest interval. + /// + /// The vector to snap. + /// The interval gap. + /// A vector which components are snapped to the nearest interval. + public static Vector3 Snap(Vector3 value, float gap) + { + if (gap == 0) + return value; + return new Vector3( + (float)Math.Round(value.X / gap, MidpointRounding.AwayFromZero) * gap, + (float)Math.Round(value.Y / gap, MidpointRounding.AwayFromZero) * gap, + (float)Math.Round(value.Z / gap, MidpointRounding.AwayFromZero) * gap); + } + + /// + /// Snaps all vector components to the nearest interval. + /// + /// The vector to snap. + /// The interval gap. + /// A vector which components are snapped to the nearest interval. + public static Vector4 Snap(Vector4 value, float gap) + { + if (gap == 0) + return value; + return new Vector4( + (float)Math.Round(value.X / gap, MidpointRounding.AwayFromZero) * gap, + (float)Math.Round(value.Y / gap, MidpointRounding.AwayFromZero) * gap, + (float)Math.Round(value.Z / gap, MidpointRounding.AwayFromZero) * gap, + (float)Math.Round(value.W / gap, MidpointRounding.AwayFromZero) * gap); + } + + /// + /// Computes standard mathematical modulo (as opposed to remainder). + /// + /// The value. + /// The divisor. + /// A value between 0 and divisor. The result will have the same sign as divisor. + public static float Mod(float value, float divisor) + { + return (value % divisor + divisor) % divisor; + } + + public static float PixelsToMeters(float value) + { + return value * (2.54f / 96f) * 0.1f; + } + /// + /// Returns largest of two or more values. + /// + /// + /// + /// + public static float Max(params float[] values) + { + int length = values.Length; + if (length == 0) + return 0.0f; + float num = values[0]; + for (int index = 1; index < length; ++index) + { + if (values[index] > (double)num) + num = values[index]; + } + return num; + } + public static float normalize(float value, float min, float max) + { + var normalized = (value - min) / (max - min); + return normalized; + } + public static float denormalize(float normalized, float min, float max) + { + var denormalized = normalized * (max - min) + min; + return denormalized; + } + public static float mapToPercentage(float level, float minimumIn, float maximumIn, float minimumOut, float maximumOut) + { + return (level - minimumIn) * (maximumOut - minimumOut) / (maximumIn - minimumIn) + minimumOut; + } + } +} diff --git a/VRGameOverlay/VROverlayWindow/RECT.cs b/VRGameOverlay/VROverlayWindow/RECT.cs new file mode 100644 index 0000000..9a8a6fb --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/RECT.cs @@ -0,0 +1,97 @@ +using System.Runtime.InteropServices; + +[StructLayout(LayoutKind.Sequential)] +public struct RECT +{ + public int Left, Top, Right, Bottom; + + public RECT(int left, int top, int right, int bottom) + { + Left = left; + Top = top; + Right = right; + Bottom = bottom; + } + + public RECT(System.Drawing.Rectangle r) : this(r.Left, r.Top, r.Right, r.Bottom) { } + + public int X + { + get { return Left; } + set { Right -= (Left - value); Left = value; } + } + + public int Y + { + get { return Top; } + set { Bottom -= (Top - value); Top = value; } + } + + public int Height + { + get { return Bottom - Top; } + set { Bottom = value + Top; } + } + + public int Width + { + get { return Right - Left; } + set { Right = value + Left; } + } + + public System.Drawing.Point Location + { + get { return new System.Drawing.Point(Left, Top); } + set { X = value.X; Y = value.Y; } + } + + public System.Drawing.Size Size + { + get { return new System.Drawing.Size(Width, Height); } + set { Width = value.Width; Height = value.Height; } + } + + public static implicit operator System.Drawing.Rectangle(RECT r) + { + return new System.Drawing.Rectangle(r.Left, r.Top, r.Width, r.Height); + } + + public static implicit operator RECT(System.Drawing.Rectangle r) + { + return new RECT(r); + } + + public static bool operator ==(RECT r1, RECT r2) + { + return r1.Equals(r2); + } + + public static bool operator !=(RECT r1, RECT r2) + { + return !r1.Equals(r2); + } + + public bool Equals(RECT r) + { + return r.Left == Left && r.Top == Top && r.Right == Right && r.Bottom == Bottom; + } + + + public override bool Equals(object obj) + { + if (obj is RECT rECT) + return Equals(rECT); + else if (obj is System.Drawing.Rectangle) + return Equals(new RECT((System.Drawing.Rectangle)obj)); + return false; + } + public override int GetHashCode() + { + return ((System.Drawing.Rectangle)this).GetHashCode(); + } + + public override string ToString() + { + return string.Format(System.Globalization.CultureInfo.CurrentCulture, "{{Left={0},Top={1},Right={2},Bottom={3}}}", Left, Top, Right, Bottom); + } +} \ No newline at end of file diff --git a/VRGameOverlay/VROverlayWindow/SteamVR.cs b/VRGameOverlay/VROverlayWindow/SteamVR.cs new file mode 100644 index 0000000..8cd786c --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/SteamVR.cs @@ -0,0 +1,259 @@ +//========= Copyright 2014, Valve Corporation, All rights reserved. =========== +// +// Purpose: Access to SteamVR system (hmd) and compositor (distort) interfaces. +// +//============================================================================= + +using System; +using SharpDX; +using MathUtil = VRGameOverlay.VROverlayWindow.MathUtil; +using VRGameOverlay.VROverlayWindow; + +public class SteamVR : System.IDisposable +{ + // Set this to false to keep from auto-initializing when calling SteamVR.instance. + private static bool _enabled = true; + + private static SteamVR _instance; + + private SteamVR() + { + hmd = OpenVR.System; + Console.WriteLine("Connected to " + hmd_TrackingSystemName + ":" + hmd_SerialNumber); + + compositor = OpenVR.Compositor; + overlay = OpenVR.Overlay; + + // Setup render values + uint w = 0, h = 0; + hmd.GetRecommendedRenderTargetSize(ref w, ref h); + sceneWidth = (float)w; + sceneHeight = (float)h; + float l_left = 0.0f, l_right = 0.0f, l_top = 0.0f, l_bottom = 0.0f; + hmd.GetProjectionRaw(EVREye.Eye_Left, ref l_left, ref l_right, ref l_top, ref l_bottom); + + float r_left = 0.0f, r_right = 0.0f, r_top = 0.0f, r_bottom = 0.0f; + hmd.GetProjectionRaw(EVREye.Eye_Right, ref r_left, ref r_right, ref r_top, ref r_bottom); + + tanHalfFov = new Vector2( + MathUtil.Max(-l_left, l_right, -r_left, r_right), + MathUtil.Max(-l_top, l_bottom, -r_top, r_bottom)); + + textureBounds = new VRTextureBounds_t[2]; + + textureBounds[0].uMin = 0.5f + 0.5f * l_left / tanHalfFov.X; + textureBounds[0].uMax = 0.5f + 0.5f * l_right / tanHalfFov.X; + textureBounds[0].vMin = 0.5f - 0.5f * l_bottom / tanHalfFov.Y; + textureBounds[0].vMax = 0.5f - 0.5f * l_top / tanHalfFov.Y; + + textureBounds[1].uMin = 0.5f + 0.5f * r_left / tanHalfFov.X; + textureBounds[1].uMax = 0.5f + 0.5f * r_right / tanHalfFov.X; + textureBounds[1].vMin = 0.5f - 0.5f * r_bottom / tanHalfFov.Y; + textureBounds[1].vMax = 0.5f - 0.5f * r_top / tanHalfFov.Y; + + // Grow the recommended size to account for the overlapping fov + sceneWidth = sceneWidth / Math.Max(textureBounds[0].uMax - textureBounds[0].uMin, textureBounds[1].uMax - textureBounds[1].uMin); + sceneHeight = sceneHeight / Math.Max(textureBounds[0].vMax - textureBounds[0].vMin, textureBounds[1].vMax - textureBounds[1].vMin); + + aspect = tanHalfFov.X / tanHalfFov.Y; + fieldOfView = 2.0f * (float)Math.Atan(tanHalfFov.Y) * MathUtil.Rad2Deg; + + graphicsAPI = ETextureType.DirectX; + } + + ~SteamVR() + { + Dispose(false); + } + + // Use this to check if SteamVR is currently active without attempting + // to activate it in the process. + public static bool active { get { return _instance != null; } } + public static bool enabled + { + get { return _enabled; } + set + { + _enabled = value; + if (!_enabled) + SafeDispose(); + } + } + public static SteamVR instance + { + get + { + if (!enabled) + return null; + + if (_instance == null) + { + _instance = CreateInstance(); + + // If init failed, then auto-disable so scripts don't continue trying to re-initialize things. + if (_instance == null) + _enabled = false; + } + + return _instance; + } + } + + // Use this interface to avoid accidentally creating the instance in the process of attempting to dispose of it. + public static void SafeDispose() + { + if (_instance != null) + { + _instance.Dispose(); + _instance = null; + } + + } + + public void Dispose() + { + Dispose(true); + System.GC.SuppressFinalize(this); + } + + public string GetTrackedDeviceString(uint deviceId) + { + var error = ETrackedPropertyError.TrackedProp_Success; + var capacity = hmd.GetStringTrackedDeviceProperty(deviceId, ETrackedDeviceProperty.Prop_AttachedDeviceId_String, null, 0, ref error); + if (capacity > 1) + { + var result = new System.Text.StringBuilder((int)capacity); + hmd.GetStringTrackedDeviceProperty(deviceId, ETrackedDeviceProperty.Prop_AttachedDeviceId_String, result, capacity, ref error); + return result.ToString(); + } + return null; + } + + private static SteamVR CreateInstance() + { + try + { + var error = EVRInitError.None; + + OpenVR.Init(ref error, EVRApplicationType.VRApplication_Overlay); + if (error != EVRInitError.None) + { + ReportError(error); + ShutdownSystems(); + return null; + } + + // Verify common interfaces are valid. + + OpenVR.GetGenericInterface(OpenVR.IVRCompositor_Version, ref error); + if (error != EVRInitError.None) + { + ReportError(error); + ShutdownSystems(); + return null; + } + + OpenVR.GetGenericInterface(OpenVR.IVROverlay_Version, ref error); + if (error != EVRInitError.None) + { + ReportError(error); + ShutdownSystems(); + return null; + } + } + catch (System.Exception e) + { + Console.WriteLine(e.Message); + } + + return new SteamVR(); + } + + private static void ReportError(EVRInitError error) + { + switch (error) + { + case EVRInitError.None: + break; + + case EVRInitError.VendorSpecific_UnableToConnectToOculusRuntime: + Console.WriteLine("SteamVR Initialization Failed! Make sure device is on, Oculus runtime is installed, and OVRService_*.exe is running."); + break; + case EVRInitError.Init_VRClientDLLNotFound: + Console.WriteLine("SteamVR drivers not found! They can be installed via Steam under Library > Tools. Visit http://steampowered.com to install Steam."); + break; + case EVRInitError.Driver_RuntimeOutOfDate: + Console.WriteLine("SteamVR Initialization Failed! Make sure device's runtime is up to date."); + break; + default: + Console.WriteLine(OpenVR.GetStringForHmdError(error)); + break; + } + } + + #region native interfaces + + internal CVRCompositor compositor { get; private set; } + internal CVRSystem hmd { get; private set; } + internal CVROverlay overlay { get; private set; } + + #endregion native interfaces + + #region tracking status + + static public bool[] connected = new bool[OpenVR.k_unMaxTrackedDeviceCount]; + static public bool calibrating { get; private set; } + static public bool initializing { get; private set; } + static public bool outOfRange { get; private set; } + #endregion tracking status + + #region render values + + internal ETextureType graphicsAPI; + public float aspect { get; private set; } + public float fieldOfView { get; private set; } + public float sceneHeight { get; private set; } + public float sceneWidth { get; private set; } + public Vector2 tanHalfFov { get; private set; } + public VRTextureBounds_t[] textureBounds { get; private set; } + + #endregion render values + + #region hmd properties + + public float hmd_DisplayFrequency { get { return GetFloatProperty(ETrackedDeviceProperty.Prop_DisplayFrequency_Float); } } + public string hmd_ModelNumber { get { return GetStringProperty(ETrackedDeviceProperty.Prop_ModelNumber_String); } } + public float hmd_SecondsFromVsyncToPhotons { get { return GetFloatProperty(ETrackedDeviceProperty.Prop_SecondsFromVsyncToPhotons_Float); } } + public string hmd_SerialNumber { get { return GetStringProperty(ETrackedDeviceProperty.Prop_SerialNumber_String); } } + public string hmd_TrackingSystemName { get { return GetStringProperty(ETrackedDeviceProperty.Prop_TrackingSystemName_String); } } + #endregion hmd properties + private static void ShutdownSystems() + { + OpenVR.Shutdown(); + } + + private void Dispose(bool disposing) + { + ShutdownSystems(); + _instance = null; + } + + private float GetFloatProperty(ETrackedDeviceProperty prop) + { + var error = ETrackedPropertyError.TrackedProp_Success; + return hmd.GetFloatTrackedDeviceProperty(OpenVR.k_unTrackedDeviceIndex_Hmd, prop, ref error); + } + + private string GetStringProperty(ETrackedDeviceProperty prop) + { + var error = ETrackedPropertyError.TrackedProp_Success; + var capactiy = hmd.GetStringTrackedDeviceProperty(OpenVR.k_unTrackedDeviceIndex_Hmd, prop, null, 0, ref error); + if (capactiy > 1) + { + var result = new System.Text.StringBuilder((int)capactiy); + hmd.GetStringTrackedDeviceProperty(OpenVR.k_unTrackedDeviceIndex_Hmd, prop, result, capactiy, ref error); + return result.ToString(); + } + return (error != ETrackedPropertyError.TrackedProp_Success) ? error.ToString() : ""; + } +} \ No newline at end of file diff --git a/VRGameOverlay/VROverlayWindow/TouchController.cs b/VRGameOverlay/VROverlayWindow/TouchController.cs new file mode 100644 index 0000000..ad6f9ad --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/TouchController.cs @@ -0,0 +1,87 @@ +// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp) +// Distributed under the MIT license. See the LICENSE.md file in the project root for more information. +using SharpDX; +using System; + + +namespace VRGameOverlay.VROverlayWindow +{ + public abstract class TouchController : IDisposable + { + public abstract Vector3 Position { get; } + + public abstract Quaternion Rotation { get; } + + public abstract Vector3 LinearVelocity { get; } + + public abstract Vector3 AngularVelocity { get; } + + public abstract DeviceState State { get; } + + public virtual void Update() + { + } + + public abstract float Trigger { get; } + + public abstract float Grip { get; } + + public abstract bool IndexPointing { get; } + + public abstract bool IndexResting { get; } + + public abstract bool ThumbUp { get; } + + public abstract bool ThumbResting { get; } + + public abstract Vector2 ThumbAxis { get; } + + public abstract Vector2 ThumbstickAxis { get; } + + /// + /// Returns true if in this frame the button switched to pressed state + /// + /// + /// + public abstract bool IsPressedDown(TouchControllerButton button); + + /// + /// Returns true if button switched is in the pressed state + /// + /// + /// + public abstract bool IsPressed(TouchControllerButton button); + + /// + /// Returns true if in this frame the button was released + /// + /// + /// + public abstract bool IsPressReleased(TouchControllerButton button); + + /// + /// Returns true if in this frame the button switched to pressed state + /// + /// + /// + public abstract bool IsTouchedDown(TouchControllerButton button); + + /// + /// Returns true if button switched is in the pressed state + /// + /// + /// + public abstract bool IsTouched(TouchControllerButton button); + + /// + /// Returns true if in this frame the button was released + /// + /// + /// + public abstract bool IsTouchReleased(TouchControllerButton button); + + public virtual void Dispose() + { + } + } +} diff --git a/VRGameOverlay/VROverlayWindow/TouchControllerButton.cs b/VRGameOverlay/VROverlayWindow/TouchControllerButton.cs new file mode 100644 index 0000000..0f875e3 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/TouchControllerButton.cs @@ -0,0 +1,68 @@ +// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp) +// Distributed under the MIT license. See the LICENSE.md file in the project root for more information. + +// modified for CrewChiefV4 + +namespace VRGameOverlay.VROverlayWindow +{ + public enum TouchControllerButton + { + /// + /// Oculus: Thumbstick + /// Vive: Thumb trackpad + /// Windows Mixed Reality: Thumbstick + /// + Thumbstick, + + /// + /// Oculus: Thumbstick + /// Vive: Thumb trackpad + /// Windows Mixed Reality: Touchpad + /// + Touchpad, + /// + /// Oculus: A + /// Windows Mixed Reality: Right half of right touchpad + /// + A, + + /// + /// Oculus: B + /// Windows Mixed Reality: Left half of right touchpad + /// + B, + + /// + /// Oculus: X + /// Windows Mixed Reality: Left half of left touchpad + /// + X, + + /// + /// Oculus: Y + /// Windows Mixed Reality: Right half of left touchpad + /// + Y, + + /// + /// Oculus: Trigger + /// Vive : Trigger + /// Windows Mixed Reality: Trigger + /// + Trigger, + + /// + /// Oculus: Grip + /// Vive: Grip + /// Windows Mixed Reality: Grip + /// + Grip, + + /// + /// Oculus: Left controller menu button + /// Vive: Both controllers menu button + /// Windows Mixed Reality: Both controllers menu button + /// + Menu, + } +} diff --git a/VRGameOverlay/VROverlayWindow/TouchControllerHand.cs b/VRGameOverlay/VROverlayWindow/TouchControllerHand.cs new file mode 100644 index 0000000..57eca92 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/TouchControllerHand.cs @@ -0,0 +1,11 @@ +// Copyright (c) Xenko contributors (https://xenko.com) and Silicon Studio Corp. (https://www.siliconstudio.co.jp) +// Distributed under the MIT license. See the LICENSE.md file in the project root for more information. + +namespace VRGameOverlay.VROverlayWindow +{ + public enum TouchControllerHand + { + Left, + Right, + } +} diff --git a/VRGameOverlay/VROverlayWindow/TrackedDevices.cs b/VRGameOverlay/VROverlayWindow/TrackedDevices.cs new file mode 100644 index 0000000..ca77e9c --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/TrackedDevices.cs @@ -0,0 +1,315 @@ +using SharpDX; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace VRGameOverlay.VROverlayWindow +{ + // Xenko game engine... + public class TrackedDevices + { + public class Controller + { + private static readonly uint sizeVRControllerState_t = (uint)Utilities.SizeOf(); + // This helper can be used in a variety of ways. Beware that indices may change + // as new devices are dynamically added or removed, controllers are physically + // swapped between hands, arms crossed, etc. + public enum Hand + { + Left, + Right, + } + + public static int GetDeviceIndex(Hand hand) + { + var currentIndex = 0; + for (uint index = 0; index < DevicePoses.Length; index++) + { + if (OpenVR.System.GetTrackedDeviceClass(index) == ETrackedDeviceClass.Controller) + { + if (hand == Hand.Left && OpenVR.System.GetControllerRoleForTrackedDeviceIndex(index) == ETrackedControllerRole.LeftHand) + { + return currentIndex; + } + + if (hand == Hand.Right && OpenVR.System.GetControllerRoleForTrackedDeviceIndex(index) == ETrackedControllerRole.RightHand) + { + return currentIndex; + } + + currentIndex++; + } + } + + return -1; + } + + public class ButtonMask + { + public const ulong System = 1ul << (int)EVRButtonId.k_EButton_System; // reserved + public const ulong ApplicationMenu = 1ul << (int)EVRButtonId.k_EButton_ApplicationMenu; + public const ulong Grip = 1ul << (int)EVRButtonId.k_EButton_Grip; + public const ulong Axis0 = 1ul << (int)EVRButtonId.k_EButton_Axis0; + public const ulong Axis1 = 1ul << (int)EVRButtonId.k_EButton_Axis1; + public const ulong Axis2 = 1ul << (int)EVRButtonId.k_EButton_Axis2; + public const ulong Axis3 = 1ul << (int)EVRButtonId.k_EButton_Axis3; + public const ulong Axis4 = 1ul << (int)EVRButtonId.k_EButton_Axis4; + public const ulong Touchpad = 1ul << (int)EVRButtonId.k_EButton_SteamVR_Touchpad; + public const ulong Trigger = 1ul << (int)EVRButtonId.k_EButton_SteamVR_Trigger; + } + + public enum ButtonId + { + ButtonSystem = 0, + ButtonApplicationMenu = 1, + ButtonGrip = 2, + ButtonDPadLeft = 3, + ButtonDPadUp = 4, + ButtonDPadRight = 5, + ButtonDPadDown = 6, + ButtonA = 7, + ButtonProximitySensor = 31, + ButtonAxis0 = 32, + ButtonAxis1 = 33, + ButtonAxis2 = 34, + ButtonAxis3 = 35, + ButtonAxis4 = 36, + ButtonSteamVrTouchpad = 32, + ButtonSteamVrTrigger = 33, + ButtonDashboardBack = 2, + ButtonMax = 64, + } + + public Controller(int controllerIndex) + { + var currentIndex = 0; + for (uint index = 0; index < DevicePoses.Length; index++) + { + if (OpenVR.System.GetTrackedDeviceClass(index) == ETrackedDeviceClass.Controller) + { + if (currentIndex == controllerIndex) + { + ControllerIndex = index; + break; + } + currentIndex++; + } + } + } + + internal uint ControllerIndex; + internal VRControllerState_t State; + internal VRControllerState_t PreviousState; + + public bool GetPress(ulong buttonMask) { return (State.ulButtonPressed & buttonMask) != 0; } + + public bool GetPressDown(ulong buttonMask) { return (State.ulButtonPressed & buttonMask) != 0 && (PreviousState.ulButtonPressed & buttonMask) == 0; } + + public bool GetPressUp(ulong buttonMask) { return (State.ulButtonPressed & buttonMask) == 0 && (PreviousState.ulButtonPressed & buttonMask) != 0; } + + public bool GetPress(ButtonId buttonId) { return GetPress(1ul << (int)buttonId); } + + public bool GetPressDown(ButtonId buttonId) { return GetPressDown(1ul << (int)buttonId); } + + public bool GetPressUp(ButtonId buttonId) { return GetPressUp(1ul << (int)buttonId); } + + public bool GetTouch(ulong buttonMask) { return (State.ulButtonTouched & buttonMask) != 0; } + + public bool GetTouchDown(ulong buttonMask) { return (State.ulButtonTouched & buttonMask) != 0 && (PreviousState.ulButtonTouched & buttonMask) == 0; } + + public bool GetTouchUp(ulong buttonMask) { return (State.ulButtonTouched & buttonMask) == 0 && (PreviousState.ulButtonTouched & buttonMask) != 0; } + + public bool GetTouch(ButtonId buttonId) { return GetTouch(1ul << (int)buttonId); } + + public bool GetTouchDown(ButtonId buttonId) { return GetTouchDown(1ul << (int)buttonId); } + + public bool GetTouchUp(ButtonId buttonId) { return GetTouchUp(1ul << (int)buttonId); } + + public Vector2 GetAxis(ButtonId buttonId = ButtonId.ButtonSteamVrTouchpad) + { + var axisId = (uint)buttonId - (uint)EVRButtonId.k_EButton_Axis0; + switch (axisId) + { + case 0: return new Vector2(State.rAxis0.x, State.rAxis0.y); + case 1: return new Vector2(State.rAxis1.x, State.rAxis1.y); + case 2: return new Vector2(State.rAxis2.x, State.rAxis2.y); + case 3: return new Vector2(State.rAxis3.x, State.rAxis3.y); + case 4: return new Vector2(State.rAxis4.x, State.rAxis4.y); + } + return Vector2.Zero; + } + + public void Update() + { + PreviousState = State; + OpenVR.System.GetControllerState(ControllerIndex, ref State, sizeVRControllerState_t); + } + } + + public class TrackedDevice + { + public TrackedDevice(int trackerIndex) + { + TrackerIndex = trackerIndex; + } + + const int StringBuilderSize = 64; + StringBuilder serialNumberStringBuilder = new StringBuilder(StringBuilderSize); + internal string SerialNumber + { + get + { + var error = ETrackedPropertyError.TrackedProp_Success; + serialNumberStringBuilder.Clear(); + OpenVR.System.GetStringTrackedDeviceProperty((uint)TrackerIndex, ETrackedDeviceProperty.Prop_SerialNumber_String, serialNumberStringBuilder, StringBuilderSize, ref error); + if (error == ETrackedPropertyError.TrackedProp_Success) + return serialNumberStringBuilder.ToString(); + else + return ""; + } + } + + internal float BatteryPercentage + { + get + { + var error = ETrackedPropertyError.TrackedProp_Success; + var value = OpenVR.System.GetFloatTrackedDeviceProperty((uint)TrackerIndex, ETrackedDeviceProperty.Prop_DeviceBatteryPercentage_Float, ref error); + if (error == ETrackedPropertyError.TrackedProp_Success) + return value; + else + return 0; + } + } + + internal int TrackerIndex; + internal ETrackedDeviceClass DeviceClass => OpenVR.System.GetTrackedDeviceClass((uint)TrackerIndex); + } + + private static readonly TrackedDevicePose_t[] DevicePoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; + private static readonly TrackedDevicePose_t[] GamePoses = new TrackedDevicePose_t[OpenVR.k_unMaxTrackedDeviceCount]; + + public static void UpdatePoses() + { + //OpenVR.Compositor.PostPresentHandoff(); + var result = OpenVR.Compositor.GetLastPoses(DevicePoses, GamePoses); + if (result != EVRCompositorError.None) + { + Console.WriteLine(result); + } + } + + public static void Recenter(ETrackingUniverseOrigin eTrackingUniverse) + { + OpenVR.Chaperone.ResetZeroPose(eTrackingUniverse); + } + + public static void GetEyeToHead(int eyeIndex, out Matrix pose) + { + pose = Matrix.Identity; + var eye = eyeIndex == 0 ? EVREye.Eye_Left : EVREye.Eye_Right; + var eyeToHead = OpenVR.System.GetEyeToHeadTransform(eye); + pose = pose.FromHmdMatrix(eyeToHead); + } + public static DeviceState GetControllerPose(int controllerIndex, out Matrix pose, out Vector3 velocity, out Vector3 angVelocity) + { + var currentIndex = 0; + + pose = Matrix.Identity; + velocity = Vector3.Zero; + angVelocity = Vector3.Zero; + + for (uint index = 0; index < DevicePoses.Length; index++) + { + if (OpenVR.System.GetTrackedDeviceClass(index) == ETrackedDeviceClass.Controller) + { + if (currentIndex == controllerIndex) + { + pose = pose.FromHmdMatrix(DevicePoses[index].mDeviceToAbsoluteTracking); + velocity = new Vector3(DevicePoses[index].vVelocity.v0, DevicePoses[index].vVelocity.v1, DevicePoses[index].vVelocity.v2); + angVelocity = new Vector3(DevicePoses[index].vAngularVelocity.v0, DevicePoses[index].vAngularVelocity.v1, DevicePoses[index].vAngularVelocity.v2); + var state = DeviceState.Invalid; + if (DevicePoses[index].bDeviceIsConnected && DevicePoses[index].bPoseIsValid) + { + state = DeviceState.Valid; + } + else if (DevicePoses[index].bDeviceIsConnected && !DevicePoses[index].bPoseIsValid && DevicePoses[index].eTrackingResult == ETrackingResult.Running_OutOfRange) + { + state = DeviceState.OutOfRange; + } + + return state; + } + currentIndex++; + } + } + + return DeviceState.Invalid; + } + + public static DeviceState GetTrackerPose(int trackerIndex, out Matrix pose, out Vector3 velocity, out Vector3 angVelocity) + { + pose = Matrix.Identity; + velocity = Vector3.Zero; + angVelocity = Vector3.Zero; + var index = trackerIndex; + + pose = pose.FromHmdMatrix(DevicePoses[index].mDeviceToAbsoluteTracking); + velocity = new Vector3(DevicePoses[index].vVelocity.v0, DevicePoses[index].vVelocity.v1, DevicePoses[index].vVelocity.v2); + angVelocity = new Vector3(DevicePoses[index].vAngularVelocity.v0, DevicePoses[index].vAngularVelocity.v1, DevicePoses[index].vAngularVelocity.v2); + + var state = DeviceState.Invalid; + if (DevicePoses[index].bDeviceIsConnected && DevicePoses[index].bPoseIsValid) + { + state = DeviceState.Valid; + } + else if (DevicePoses[index].bDeviceIsConnected && !DevicePoses[index].bPoseIsValid && DevicePoses[index].eTrackingResult == ETrackingResult.Running_OutOfRange) + { + state = DeviceState.OutOfRange; + } + + return state; + } + + public static DeviceState GetHeadPose(out Matrix pose, out Vector3 linearVelocity, out Vector3 angularVelocity) + { + pose = Matrix.Identity; + linearVelocity = Vector3.Zero; + angularVelocity = Vector3.Zero; + for (uint index = 0; index < DevicePoses.Length; index++) + { + if (OpenVR.System.GetTrackedDeviceClass(index) == ETrackedDeviceClass.HMD) + { + pose = pose.FromHmdMatrix(DevicePoses[index].mDeviceToAbsoluteTracking); + linearVelocity = new Vector3(DevicePoses[index].vVelocity.v0, DevicePoses[index].vVelocity.v1, DevicePoses[index].vVelocity.v2); + angularVelocity = new Vector3(DevicePoses[index].vAngularVelocity.v0, DevicePoses[index].vAngularVelocity.v1, DevicePoses[index].vAngularVelocity.v2); + + var state = DeviceState.Invalid; + if (DevicePoses[index].bDeviceIsConnected && DevicePoses[index].bPoseIsValid) + { + state = DeviceState.Valid; + } + else if (DevicePoses[index].bDeviceIsConnected && !DevicePoses[index].bPoseIsValid && DevicePoses[index].eTrackingResult == ETrackingResult.Running_OutOfRange) + { + state = DeviceState.OutOfRange; + } + + return state; + } + } + + return DeviceState.Invalid; + } + + public static void GetProjection(int eyeIndex, float near, float far, out Matrix projection) + { + projection = Matrix.Identity; + var eye = eyeIndex == 0 ? EVREye.Eye_Left : EVREye.Eye_Right; + var proj = OpenVR.System.GetProjectionMatrix(eye, near, far); + projection = projection.FromHmdMatrix(proj); + } + } + +} diff --git a/VRGameOverlay/VROverlayWindow/VROverlayConfiguration.cs b/VRGameOverlay/VROverlayWindow/VROverlayConfiguration.cs new file mode 100644 index 0000000..8fdb435 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/VROverlayConfiguration.cs @@ -0,0 +1,70 @@ +using Newtonsoft.Json; +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Runtime.CompilerServices; + +namespace VRGameOverlay.VROverlayWindow +{ + /// + /// Configuration for the VR Settings Form + /// + public class VROverlayConfiguration + { + public string HighlightColor { get; set; } = "#FFFF00"; //yellow + + //public List HotKeys { get; set; } = new List(); + public List Windows { get; set; } = new List(); + + /// + /// File location where this instance was loaded + /// + [JsonIgnore] + public FileInfo FileInfo { get; set; } + + static readonly DirectoryInfo MyDocuments; + static readonly FileInfo OldSettingsFile; + static readonly FileInfo DefaultFile; + + static VROverlayConfiguration() + { + MyDocuments = new DirectoryInfo(Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "CrewChiefV4")); + OldSettingsFile = new FileInfo(Path.Combine(MyDocuments.FullName, "vr_overlay_windows.json")); + DefaultFile = new FileInfo(Path.Combine(MyDocuments.FullName, "CrewChiefV4.vrconfig.json")); + } + + private void Save(FileInfo file) + { + + } + + /// + /// Save the settings file to the Default Location + /// + public void Save() + { + Save(FileInfo); + } + + /// + /// Load the settings file from the default location + /// + /// + public static VROverlayConfiguration FromFile() + { + return FromFile(DefaultFile); + } + + + /// + /// Helper function to handle migration from old file type + /// + /// + /// + public static VROverlayConfiguration FromFile(FileInfo fileInfo) + { + return null; + } + } +} diff --git a/VRGameOverlay/VROverlayWindow/VROverlayWindow.cs b/VRGameOverlay/VROverlayWindow/VROverlayWindow.cs new file mode 100644 index 0000000..3f9922c --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/VROverlayWindow.cs @@ -0,0 +1,469 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.IO; +using System.Runtime.InteropServices; +//using System.Windows.Forms; +//using CrewChiefV4.commands; +using Newtonsoft.Json; +using SharpDX; +using SharpDX.Direct3D11; +using SharpDX.Mathematics.Interop; +/// +/// This class stores settings for each Target Application +/// +/// +namespace VRGameOverlay.VROverlayWindow +{ + public enum ClickAPI + { + None = 0, + SendInput = 1, + SendMessage = 2, + SendNotifyMessage = 3, + } + public enum CaptureMode + { + GdiDirect = 0, + GdiIndirect = 1, + ReplicationApi = 2, + } + + public enum MouseInteractionMode + { + DirectInteraction = 0, // Keep Window on top, Move Cursor + WindowTop = 1, // Keep Window on top only, Send Mouse Clicks Only (No Move) + SendClicksOnly = 2, // Only Send Mouse Clicks + Disabled = 3 + } + public enum TrackingSpace + { + Seated = 0, + Standing, + FollowHead + } + + [Serializable] + public class VROverlayWindow + { + public string Name { get; set; } + public string Text { get; set; } + [JsonIgnore] + public IntPtr hWnd { get; set; } + public bool enabled { get; set; } + public bool wasEnabled { get; set; } + public float positionX { get; set; } + public float positionY { get; set; } + public float positionZ { get; set; } + public float rotationX { get; set; } + public float rotationY { get; set; } + public float rotationZ { get; set; } + public float scale { get; set; } + public float gazeScale { get; set; } + public float transparency { get; set; } + public float gazeTransparency { get; set; } + public float curvature { get; set; } + public bool gazeEnabled { get; set; } + public bool forceTopMost { get; set; } + [DefaultValue(TrackingSpace.Seated)] + [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)] + public TrackingSpace trackingSpace { get; set; } + public bool isDisplay { get; set; } + [DefaultValue(-1)] + [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)] + public int toggleVKeyCode { get; set; } + [DefaultValue(-1)] + [JsonProperty(DefaultValueHandling = DefaultValueHandling.Populate)] + public int modifierVKeyCode { get; set; } + [JsonIgnore] + public Texture2D copiedScreenTexture { get; set; } + [JsonIgnore] + public Rectangle rectAbs; + [JsonIgnore] + public Rectangle rectScreen; + [JsonIgnore] + public ulong vrOverlayHandle; + [JsonIgnore] + public bool shouldDraw { get; set; } + [JsonIgnore] + public float aspect { get; set; } + [JsonIgnore] + public Matrix hmdMatrix { get; set; } + + + [JsonIgnore] + public bool IsSelected { get; set; } + + public bool Chromakey { get; set; } + public string ChromakeyColor { get; set; } = "#000000"; + public float ChromakeyTolerance { get; set; } + + private bool wasGazing = false; + private long lastKeyHandleTickCount = 0; + + public VROverlayWindow() + { + positionZ = -1; + } + + //[JsonConstructor] + public VROverlayWindow(string Text, IntPtr hWnd, string Name = "", bool enabled = false, bool wasEnabled = false, float positionX = 0, float positionY = 0, float positionZ = -1, + float rotationX = 0, float rotationY = 0, float rotationZ = 0, float scale = 1, float transparency = 1, float curvature = 0, TrackingSpace trackingUniverse = TrackingSpace.Seated, bool isDisplay = false, int toggleVKeyCode = -1, int modifierVKeyCode = -1, bool gazeEnabled = false, float gazeScale = 1f, float gazeTransparency = 1f, bool forceTopMost = false) + { + this.Text = Text; + if (string.IsNullOrWhiteSpace(Name)) + this.Name = Text; + else + this.Name = Name; + this.enabled = enabled; + this.hWnd = hWnd; + this.positionX = positionX; + this.positionY = positionY; + this.positionZ = positionZ; // place initial overlay 1 meter infront of the user + this.rotationX = rotationX; + this.rotationY = rotationY; + this.rotationY = rotationZ; + this.scale = scale; + this.gazeScale = gazeScale; + this.transparency = transparency; + this.gazeTransparency = gazeTransparency; + trackingSpace = trackingUniverse; + this.curvature = curvature; + this.isDisplay = isDisplay; + this.toggleVKeyCode = toggleVKeyCode; + this.modifierVKeyCode = modifierVKeyCode; + this.gazeEnabled = gazeEnabled; + this.wasEnabled = wasEnabled; + rectAbs = new Rectangle(); + rectScreen = new Rectangle(); + this.forceTopMost = forceTopMost; + shouldDraw = false; + if (enabled) + { + CreateOverlay(); + SetOverlayCurvature(); + SetOverlayTransparency(); + SetOverlayEnabled(true); + } + } + + /// + /// Update the dimensions of the window + /// If the dimiensions have changed then the current texture will be dispsed and a new Texture will be created + /// + /// + /// factory method to create a texture + /// + internal bool TryUpdateSize(Rectangle rect, Func getTexture) + { + bool result = true; + if ((rect.Width != rectAbs.Width || rect.Height != rectAbs.Height) && rect.Width > 0 && rect.Height > 0) + { + rectAbs = rect; + try + { + copiedScreenTexture?.Dispose(); + copiedScreenTexture = null; + copiedScreenTexture = getTexture(); + } + catch (SharpDXException e) + { + Console.WriteLine("CaptureScreen.Capture: Screen capturing failed = " + e.Message); + result = false; + } + } + rectAbs = rect; + aspect = Math.Abs(rectAbs.Height / (float)rectAbs.Width); + return result; + } + + public VROverlayWindow(IntPtr hWnd, VROverlayWindow other, ulong vrOverlayCursorHandle = 0) + { + Text = other.Text; + Name = other.Name; + enabled = other.enabled; + this.hWnd = hWnd; + positionX = other.positionX; + positionY = other.positionY; + positionZ = other.positionZ; // place initial overlay 1 meter infront of the user + rotationX = other.rotationX; + rotationY = other.rotationY; + rotationZ = other.rotationZ; + scale = other.scale; + gazeScale = other.gazeScale; + transparency = other.transparency; + gazeTransparency = other.gazeTransparency; + trackingSpace = other.trackingSpace; + curvature = other.curvature; + isDisplay = other.isDisplay; + toggleVKeyCode = other.toggleVKeyCode; + modifierVKeyCode = other.modifierVKeyCode; + gazeEnabled = other.gazeEnabled; + wasEnabled = other.wasEnabled; + rectAbs = new Rectangle(); + rectScreen = new Rectangle(); + forceTopMost = other.forceTopMost; + lastKeyHandleTickCount = other.lastKeyHandleTickCount; + Chromakey = other.Chromakey; + ChromakeyColor = other.ChromakeyColor; + ChromakeyTolerance = other.ChromakeyTolerance; + shouldDraw = false; + if (enabled) + { + CreateOverlay(); + SetOverlayCurvature(); + SetOverlayTransparency(); + SetOverlayEnabled(true); + } + } + + public void Copy(VROverlayWindow currWnd) + { + enabled = currWnd.enabled; + wasEnabled = currWnd.wasEnabled; + positionX = currWnd.positionX; + positionY = currWnd.positionY; + positionZ = currWnd.positionZ; + rotationX = currWnd.rotationX; + rotationY = currWnd.rotationY; + rotationZ = currWnd.rotationZ; + scale = currWnd.scale; + gazeScale = currWnd.gazeScale; + transparency = currWnd.transparency; + gazeTransparency = currWnd.gazeTransparency; + trackingSpace = currWnd.trackingSpace; + curvature = currWnd.curvature; + gazeEnabled = currWnd.gazeEnabled; + forceTopMost = currWnd.forceTopMost; + isDisplay = currWnd.isDisplay; + toggleVKeyCode = currWnd.toggleVKeyCode; + modifierVKeyCode = currWnd.modifierVKeyCode; + Chromakey = currWnd.Chromakey; + ChromakeyColor = currWnd.ChromakeyColor; + ChromakeyTolerance = currWnd.ChromakeyTolerance; + } + + public void CreateOverlay(bool setFlags = true) + { + if (string.IsNullOrWhiteSpace(Name)) + Name = Guid.NewGuid().ToString(); + vrOverlayHandle = 0; + + var error = SteamVR.instance.overlay.CreateOverlay(Name, Name, ref vrOverlayHandle); + if (error == EVROverlayError.None) + { + if (setFlags) + { + SteamVR.instance.overlay.SetOverlayFlag(vrOverlayHandle, VROverlayFlags.SortWithNonSceneOverlays, true); + // disable mouse input for not as it ned a propper handler + //SteamVR.instance.overlay.SetOverlayFlag(vrOverlayHandle, VROverlayFlags.MakeOverlaysInteractiveIfVisible, true); + //SteamVR.instance.overlay.SetOverlayFlag(vrOverlayHandle, VROverlayFlags.HideLaserIntersection, true); + + //SteamVR.instance.overlay.SetOverlayInputMethod(vrOverlayHandle, VROverlayInputMethod.Mouse); + + + } + Console.WriteLine($"Created SVR overlay handle for: {Name} : 0x{vrOverlayHandle:X8}"); + } + else + { + Console.WriteLine($"Failed to create SVR overlay handle for: {Name} error: {error}"); + } + } + + public bool SubmitOverlay() + { + var tex = new Texture_t + { + eType = ETextureType.DirectX, + eColorSpace = EColorSpace.Auto, + handle = copiedScreenTexture.NativePointer, + }; + var vecMouseScale = new HmdVector2_t + { + v0 = 1f, + v1 = aspect + }; + SteamVR.instance.overlay.SetOverlayMouseScale(vrOverlayHandle, ref vecMouseScale); + return SteamVR.instance.overlay.SetOverlayTexture(vrOverlayHandle, ref tex) == EVROverlayError.None; + } + + public void SetOverlayCursors(ulong cursorHandle) + { + SteamVR.instance.overlay.SetOverlayCursor(vrOverlayHandle, cursorHandle); + } + + public void SetOverlayEnabled(bool enabled) + { + if (enabled) + SteamVR.instance.overlay.ShowOverlay(vrOverlayHandle); + else + SteamVR.instance.overlay.HideOverlay(vrOverlayHandle); + } + + public void SetOverlayCurvature() + { + SteamVR.instance.overlay.SetOverlayCurvature(vrOverlayHandle, curvature); + } + + public void SetOverlayTransparency() + { + SteamVR.instance.overlay.SetOverlayAlpha(vrOverlayHandle, transparency); + } + + public void SetOverlayParams(float scale = 1.0f) + { + SteamVR.instance.overlay.SetOverlayWidthInMeters(vrOverlayHandle, scale); + + Matrix rotCenter = Matrix.Translation(0, 0, 0); + rotCenter *= Matrix.RotationX(rotationX); + rotCenter *= Matrix.RotationY(rotationY); + rotCenter *= Matrix.RotationZ(rotationZ); + var transform = Matrix.Scaling(wasGazing && trackingSpace != TrackingSpace.FollowHead ? gazeScale : this.scale) * rotCenter * Matrix.Translation(positionX, positionY, positionZ); + transform.Transpose(); + + if (gazeEnabled && trackingSpace != TrackingSpace.FollowHead) + { + if (SetOverlayGazeing(transform)) + { + transform = Matrix.Scaling(gazeScale) * rotCenter * Matrix.Translation(positionX, positionY, positionZ); + transform.Transpose(); + SteamVR.instance.overlay.SetOverlayAlpha(vrOverlayHandle, gazeTransparency); + wasGazing = true; + } + else + { + SteamVR.instance.overlay.SetOverlayAlpha(vrOverlayHandle, transparency); + wasGazing = false; + } + } + + if (trackingSpace == TrackingSpace.FollowHead) + { + HmdMatrix34_t pose = transform.ToHmdMatrix34(); + SteamVR.instance.overlay.SetOverlayTransformTrackedDeviceRelative(vrOverlayHandle, 0, ref pose); + } + else + { + HmdMatrix34_t pose = transform.ToHmdMatrix34(); + SteamVR.instance.overlay.SetOverlayTransformAbsolute(vrOverlayHandle, (ETrackingUniverseOrigin)trackingSpace, ref pose); + } + shouldDraw = false; + } + + private bool SetOverlayGazeing(Matrix transform) + { + float angle = Matrix.Invert(hmdMatrix).Forward.Angle(transform.Forward); + if (angle <= 90) + { + IntersectionResults results = new IntersectionResults(); + if (ComputeIntersection(hmdMatrix.TranslationVector, hmdMatrix.Forward, ref results)) + { + return true; + } + } + return false; + } + + public void Draw() + { + SetOverlayEnabled(shouldDraw && enabled); + if (shouldDraw) + { + SubmitOverlay(); + SetOverlayParams(); + } + } + + public struct IntersectionResults + { + public Vector3 point; + public Vector3 normal; + public Vector2 UVs; + public float distance; + } + + public bool ComputeIntersection(Vector3 source, Vector3 direction, ref IntersectionResults results) + { + var overlay = SteamVR.instance.overlay; + if (overlay == null) + return false; + + var input = new VROverlayIntersectionParams_t(); + input.eOrigin = OpenVR.Compositor.GetTrackingSpace(); + input.vSource.v0 = source.X; + input.vSource.v1 = source.Y; + input.vSource.v2 = source.Z; + input.vDirection.v0 = direction.X; + input.vDirection.v1 = direction.Y; + input.vDirection.v2 = direction.Z; + + var output = new VROverlayIntersectionResults_t(); + if (!overlay.ComputeOverlayIntersection(vrOverlayHandle, ref input, ref output)) + return false; + + results.point = new Vector3(output.vPoint.v0, output.vPoint.v1, output.vPoint.v2); + results.normal = new Vector3(output.vNormal.v0, output.vNormal.v1, output.vNormal.v2); + results.UVs = new Vector2(output.vUVs.v0, output.vUVs.v1); + results.distance = output.fDistance; + return true; + } + + public override string ToString() + { + return Text; + } + + public bool MakeTopmost() + { + return Win32Stuff.SetWindowPos(hWnd, (IntPtr)Win32Stuff.SpecialWindowHandles.HWND_TOPMOST, 0, 0, 0, 0, Win32Stuff.SetWindowPosFlags.SWP_NOMOVE | Win32Stuff.SetWindowPosFlags.SWP_NOSIZE); + } + + public bool BringToFront() + { + bool ret = Win32Stuff.ShowWindow(hWnd, 1); + return ret && Win32Stuff.SetForegroundWindow(hWnd) != IntPtr.Zero; + } + + #region IDisposable Support + private bool disposedValue = false; // To detect redundant calls + + protected virtual void Dispose(bool disposing) + { + if (!disposedValue) + { + if (disposing) + { + // TODO: dispose managed state (managed objects). + copiedScreenTexture?.Dispose(); + if (OpenVR.Overlay != null) + OpenVR.Overlay.DestroyOverlay(vrOverlayHandle); + } + // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below. + // TODO: set large fields to null. + disposedValue = true; + } + } + + // TODO: override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources. + // ~VROverlayWindow() { + // // Do not change this code. Put cleanup code in Dispose(bool disposing) above. + // Dispose(false); + // } + + // This code added to correctly implement the disposable pattern. + public void Dispose() + { + // Do not change this code. Put cleanup code in Dispose(bool disposing) above. + Dispose(true); + // TODO: uncomment the following line if the finalizer is overridden above. + // GC.SuppressFinalize(this); + } + + + + + #endregion + } +} diff --git a/VRGameOverlay/VROverlayWindow/Win32Stuff.cs b/VRGameOverlay/VROverlayWindow/Win32Stuff.cs new file mode 100644 index 0000000..e6894c7 --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/Win32Stuff.cs @@ -0,0 +1,361 @@ +using System; +using System.Collections.Generic; +using System.Text; +using System.Runtime.InteropServices; +using System.Diagnostics; + +namespace VRGameOverlay.VROverlayWindow +{ + class Win32Stuff + { + + #region Class Variables + // Window Styles + [Flags] + internal enum WindowStyle : uint + { + Overlapped = 0x00000000, + Tiled = 0x00000000, + MaximizeBox = 00010000, + Tabstop = 0x00010000, + Group = 0x00020000, + MinimizeBox = 0x00020000, + Sizebox = 0x00040000, + ThickFrame = 0x00040000, + SysMenu = 0x00080000, + HScroll = 0x00100000, + VScroll = 0x00200000, + DlgFrame = 0x00400000, + Border = 0x00800000, + Caption = DlgFrame | Border, + OverlappedWindow = Overlapped | Caption | SysMenu | ThickFrame | MinimizeBox | MaximizeBox, + TiledWindow = Overlapped | Caption | SysMenu | ThickFrame | MinimizeBox | MaximizeBox, + Maximize = 0x01000000, + ClipChildren = 0x02000000, + ClipSiblings = 0x04000000, + Disabled = 0x08000000, + Visible = 0x10000000, + Iconic = 0x20000000, + Minimize = 0x20000000, + Child = 0x40000000, + ChildWindow = 0x40000000, + Popup = 0x80000000, + PopupWindow = Popup | Border | SysMenu + } + public const int CURSOR_SHOWING = 0x00000001; + [StructLayout(LayoutKind.Sequential)] + public struct POINT + { + public int x; + public int y; + } + + [StructLayout(LayoutKind.Sequential)] + public struct CURSORINFO + { + public int cbSize; // Specifies the size, in bytes, of the structure. + public int flags; // Specifies the cursor state. This parameter can be one of the following values: + public IntPtr hCursor; // Handle to the cursor. + public POINT ptScreenPos; // A POINT structure that receives the screen coordinates of the cursor. + } + + [StructLayout(LayoutKind.Sequential)] + public struct WINDOWINFO + { + public uint cbSize; + public RECT rcWindow; + public RECT rcClient; + public WindowStyle dwStyle; + public uint dwExStyle; + public uint dwWindowStatus; + public uint cxWindowBorders; + public uint cyWindowBorders; + public ushort atomWindowType; + public ushort wCreatorVersion; + + public WINDOWINFO(bool? filler) : this() // Allows automatic initialization of "cbSize" with "new WINDOWINFO(null/true/false)". + { + cbSize = (uint)Marshal.SizeOf(typeof(WINDOWINFO)); + } + + } + public enum IDC_STANDARD_CURSORS + { + IDC_ARROW = 32512, + IDC_IBEAM = 32513, + IDC_WAIT = 32514, + IDC_CROSS = 32515, + IDC_UPARROW = 32516, + IDC_SIZE = 32640, + IDC_ICON = 32641, + IDC_SIZENWSE = 32642, + IDC_SIZENESW = 32643, + IDC_SIZEWE = 32644, + IDC_SIZENS = 32645, + IDC_SIZEALL = 32646, + IDC_NO = 32648, + IDC_HAND = 32649, + IDC_APPSTARTING = 32650, + IDC_HELP = 32651 + } + #endregion + + + #region Class Functions + [DllImport("user32.dll")] + public static extern IntPtr LoadCursor(IntPtr hInstance, int lpCursorName); + + [DllImport("user32.dll", EntryPoint = "GetCursorInfo")] + public static extern bool GetCursorInfo(out CURSORINFO pci); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("user32.dll", EntryPoint = "DrawIconEx")] + public static extern bool DrawIconEx(IntPtr hdc, int xLeft, int yTop, IntPtr hIcon, + int cxWidth, int cyHeight, int istepIfAniCur, IntPtr hbrFlickerFreeDraw, int diFlags); + + [DllImport("user32.dll", EntryPoint = "GetDesktopWindow")] + public static extern IntPtr GetDesktopWindow(); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("user32.dll", SetLastError = true)] + public static extern bool GetWindowInfo(IntPtr hwnd, ref WINDOWINFO pwi); + + [return: MarshalAs(UnmanagedType.Bool)] + [DllImport("user32.dll", SetLastError = true)] + public static extern bool GetWindowRect(IntPtr hwnd, ref RECT lpRect); + + + [DllImport("user32.dll", CharSet = CharSet.Unicode)] + private static extern int GetWindowText(IntPtr hWnd, StringBuilder strText, int maxCount); + + [DllImport("user32.dll", CharSet = CharSet.Unicode)] + private static extern int GetWindowTextLength(IntPtr hWnd); + + + [DllImport("user32.dll")] + private static extern bool EnumWindows(EnumWindowsProc enumProc, IntPtr lParam); + + [DllImport("user32.dll", SetLastError = true)] + static extern IntPtr FindWindow(string lpClassName, string lpWindowName); + + public static IntPtr FindWindow(string caption) + { + return FindWindow(string.Empty, caption); + } + /// + /// Determines the visibility state of the specified window. + /// + /// Go to https://msdn.microsoft.com/en-us/library/windows/desktop/ms633530%28v=vs.85%29.aspx for more + /// information. For WS_VISIBLE information go to + /// https://msdn.microsoft.com/en-us/library/windows/desktop/ms632600%28v=vs.85%29.aspx + /// + /// + /// C++ ( hWnd [in]. Type: HWND )
A handle to the window to be tested. + /// + /// true or the return value is nonzero if the specified window, its parent window, its parent's parent + /// window, and so forth, have the WS_VISIBLE style; otherwise, false or the return value is zero. + /// + /// + /// The visibility state of a window is indicated by the WS_VISIBLE[0x10000000L] style bit. When + /// WS_VISIBLE[0x10000000L] is set, the window is displayed and subsequent drawing into it is displayed as long as the + /// window has the WS_VISIBLE[0x10000000L] style. Any drawing to a window with the WS_VISIBLE[0x10000000L] style will + /// not be displayed if the window is obscured by other windows or is clipped by its parent window. + /// + [DllImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool IsWindowVisible(IntPtr hWnd); + + [DllImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool IsIconic(IntPtr hWnd); + + [DllImport("user32.dll")] + public static extern bool IsZoomed(IntPtr hWnd); + + // Delegate to filter which windows to include + public delegate bool EnumWindowsProc(IntPtr hWnd, IntPtr lParam); + + /// Get the text for the window pointed to by hWnd + public static string GetWindowText(IntPtr hWnd) + { + int size = GetWindowTextLength(hWnd); + if (size > 0) + { + var builder = new StringBuilder(size + 1); + GetWindowText(hWnd, builder, builder.Capacity); + return builder.ToString(); + } + + return string.Empty; + } + + /// Find all windows that match the given filter + /// A delegate that returns true for windows + /// that should be returned and false for windows that should + /// not be returned + public static List FindWindows(EnumWindowsProc filter) + { + List windows = new List(); + + EnumWindows(delegate (IntPtr wnd, IntPtr param) + { + if (filter(wnd, param)) + { + // only add the windows that pass the filter + windows.Add(wnd); + } + + // but return true here so that we iterate all windows + return true; + }, IntPtr.Zero); + + return windows; + } + + /// Find all windows that contain the given title text + /// The text that the window title must contain. + public static List FindWindowsWithText(string titleText) + { + return FindWindows(delegate (IntPtr wnd, IntPtr param) + { + return GetWindowText(wnd).Contains(titleText); + }); + } + + /// Find all windows that contain the given title text + /// The text that the window title must contain. + public static IEnumerable FindWindowsWithSize() + { + return FindWindows(delegate (IntPtr wnd, IntPtr param) + { + return IsWindowVisible(wnd); + }); + } + // find windows that are visible and have a title + public static List FindWindows() + { + return FindWindows(delegate (IntPtr wnd, IntPtr param) + { + return IsWindowVisible(wnd) && !string.IsNullOrWhiteSpace(GetWindowText(wnd)); + }); + } + + /// + /// Special window handles + /// + public enum SpecialWindowHandles + { + // ReSharper disable InconsistentNaming + /// + /// Places the window at the top of the Z order. + /// + HWND_TOP = 0, + /// + /// Places the window at the bottom of the Z order. If the hWnd parameter identifies a topmost window, the window loses its topmost status and is placed at the bottom of all other windows. + /// + HWND_BOTTOM = 1, + /// + /// Places the window above all non-topmost windows. The window maintains its topmost position even when it is deactivated. + /// + HWND_TOPMOST = -1, + /// + /// Places the window above all non-topmost windows (that is, behind all topmost windows). This flag has no effect if the window is already a non-topmost window. + /// + HWND_NOTOPMOST = -2 + // ReSharper restore InconsistentNaming + } + + [Flags] + public enum SetWindowPosFlags : uint + { + // ReSharper disable InconsistentNaming + + /// + /// If the calling thread and the thread that owns the window are attached to different input queues, the system posts the request to the thread that owns the window. This prevents the calling thread from blocking its execution while other threads process the request. + /// + SWP_ASYNCWINDOWPOS = 0x4000, + + /// + /// Prevents generation of the WM_SYNCPAINT message. + /// + SWP_DEFERERASE = 0x2000, + + /// + /// Draws a frame (defined in the window's class description) around the window. + /// + SWP_DRAWFRAME = 0x0020, + + /// + /// Applies new frame styles set using the SetWindowLong function. Sends a WM_NCCALCSIZE message to the window, even if the window's size is not being changed. If this flag is not specified, WM_NCCALCSIZE is sent only when the window's size is being changed. + /// + SWP_FRAMECHANGED = 0x0020, + + /// + /// Hides the window. + /// + SWP_HIDEWINDOW = 0x0080, + + /// + /// Does not activate the window. If this flag is not set, the window is activated and moved to the top of either the topmost or non-topmost group (depending on the setting of the hWndInsertAfter parameter). + /// + SWP_NOACTIVATE = 0x0010, + + /// + /// Discards the entire contents of the client area. If this flag is not specified, the valid contents of the client area are saved and copied back into the client area after the window is sized or repositioned. + /// + SWP_NOCOPYBITS = 0x0100, + + /// + /// Retains the current position (ignores X and Y parameters). + /// + SWP_NOMOVE = 0x0002, + + /// + /// Does not change the owner window's position in the Z order. + /// + SWP_NOOWNERZORDER = 0x0200, + + /// + /// Does not redraw changes. If this flag is set, no repainting of any kind occurs. This applies to the client area, the nonclient area (including the title bar and scroll bars), and any part of the parent window uncovered as a result of the window being moved. When this flag is set, the application must explicitly invalidate or redraw any parts of the window and parent window that need redrawing. + /// + SWP_NOREDRAW = 0x0008, + + /// + /// Same as the SWP_NOOWNERZORDER flag. + /// + SWP_NOREPOSITION = 0x0200, + + /// + /// Prevents the window from receiving the WM_WINDOWPOSCHANGING message. + /// + SWP_NOSENDCHANGING = 0x0400, + + /// + /// Retains the current size (ignores the cx and cy parameters). + /// + SWP_NOSIZE = 0x0001, + + /// + /// Retains the current Z order (ignores the hWndInsertAfter parameter). + /// + SWP_NOZORDER = 0x0004, + + /// + /// Displays the window. + /// + SWP_SHOWWINDOW = 0x0040, + + // ReSharper restore InconsistentNaming + } + [DllImport("user32.dll", SetLastError = true)] + public static extern bool SetWindowPos(IntPtr hWnd, IntPtr hWndInsertAfter, int X, int Y, int cx, int cy, SetWindowPosFlags uFlags); + + [DllImport("user32.dll")] + internal static extern IntPtr SetForegroundWindow(IntPtr hWnd); + + [DllImport("user32.dll")] + internal static extern bool ShowWindow(IntPtr hWnd, int nCmdShow); + #endregion + } + +} \ No newline at end of file diff --git a/VRGameOverlay/VROverlayWindow/openvr_api.cs b/VRGameOverlay/VROverlayWindow/openvr_api.cs new file mode 100644 index 0000000..6e00c8a --- /dev/null +++ b/VRGameOverlay/VROverlayWindow/openvr_api.cs @@ -0,0 +1,8322 @@ +//======= Copyright (c) Valve Corporation, All rights reserved. =============== +// +// Purpose: This file contains C#/managed code bindings for the OpenVR interfaces +// This file is auto-generated, do not edit it. +// +//============================================================================= +#if !OPENVR_XR_API + +using System; +using System.Runtime.InteropServices; + +#if UNITY_5_3_OR_NEWER +using UnityEngine; +#endif + +namespace VRGameOverlay.VROverlayWindow +{ + + [StructLayout(LayoutKind.Sequential)] + public struct IVRSystem + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetRecommendedRenderTargetSize(ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRecommendedRenderTargetSize GetRecommendedRenderTargetSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix44_t _GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetProjectionMatrix GetProjectionMatrix; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetProjectionRaw(EVREye eEye, ref float pfLeft, ref float pfRight, ref float pfTop, ref float pfBottom); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetProjectionRaw GetProjectionRaw; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ComputeDistortion(EVREye eEye, float fU, float fV, ref DistortionCoordinates_t pDistortionCoordinates); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ComputeDistortion ComputeDistortion; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetEyeToHeadTransform(EVREye eEye); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEyeToHeadTransform GetEyeToHeadTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync, ref ulong pulFrameCounter); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTimeSinceLastVsync GetTimeSinceLastVsync; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetD3D9AdapterIndex(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetD3D9AdapterIndex GetD3D9AdapterIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDXGIOutputInfo GetDXGIOutputInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetOutputDevice(ref ulong pnDevice, ETextureType textureType, IntPtr pInstance); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOutputDevice GetOutputDevice; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsDisplayOnDesktop(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsDisplayOnDesktop IsDisplayOnDesktop; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _SetDisplayVisibility(bool bIsVisibleOnDesktop); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDisplayVisibility SetDisplayVisibility; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, [In, Out] TrackedDevicePose_t[] pTrackedDevicePoseArray, uint unTrackedDevicePoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDeviceToAbsoluteTrackingPose GetDeviceToAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSeatedZeroPoseToStandingAbsoluteTrackingPose GetSeatedZeroPoseToStandingAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetRawZeroPoseToStandingAbsoluteTrackingPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRawZeroPoseToStandingAbsoluteTrackingPose GetRawZeroPoseToStandingAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, [In, Out] uint[] punTrackedDeviceIndexArray, uint unTrackedDeviceIndexArrayCount, uint unRelativeToTrackedDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSortedTrackedDeviceIndicesOfClass GetSortedTrackedDeviceIndicesOfClass; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EDeviceActivityLevel _GetTrackedDeviceActivityLevel(uint unDeviceId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceActivityLevel GetTrackedDeviceActivityLevel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ApplyTransform(ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pTrackedDevicePose, ref HmdMatrix34_t pTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ApplyTransform ApplyTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceIndexForControllerRole GetTrackedDeviceIndexForControllerRole; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedControllerRole _GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerRoleForTrackedDeviceIndex GetControllerRoleForTrackedDeviceIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedDeviceClass _GetTrackedDeviceClass(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceClass GetTrackedDeviceClass; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsTrackedDeviceConnected(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsTrackedDeviceConnected IsTrackedDeviceConnected; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetBoolTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoolTrackedDeviceProperty GetBoolTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFloatTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFloatTrackedDeviceProperty GetFloatTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetInt32TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInt32TrackedDeviceProperty GetInt32TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetUint64TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetUint64TrackedDeviceProperty GetUint64TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetMatrix34TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMatrix34TrackedDeviceProperty GetMatrix34TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetArrayTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, uint propType, IntPtr pBuffer, uint unBufferSize, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetArrayTrackedDeviceProperty GetArrayTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetStringTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, System.Text.StringBuilder pchValue, uint unBufferSize, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetStringTrackedDeviceProperty GetStringTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetPropErrorNameFromEnum(ETrackedPropertyError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPropErrorNameFromEnum GetPropErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEvent(ref VREvent_t pEvent, uint uncbVREvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextEvent PollNextEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, ref VREvent_t pEvent, uint uncbVREvent, ref TrackedDevicePose_t pTrackedDevicePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextEventWithPose PollNextEventWithPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetEventTypeNameFromEnum(EVREventType eType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEventTypeNameFromEnum GetEventTypeNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HiddenAreaMesh_t _GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHiddenAreaMesh GetHiddenAreaMesh; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerState(uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerState GetControllerState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerStateWithPose GetControllerStateWithPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _TriggerHapticPulse(uint unControllerDeviceIndex, uint unAxisId, ushort usDurationMicroSec); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TriggerHapticPulse TriggerHapticPulse; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetButtonIdNameFromEnum(EVRButtonId eButtonId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetButtonIdNameFromEnum GetButtonIdNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerAxisTypeNameFromEnum GetControllerAxisTypeNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsInputAvailable(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsInputAvailable IsInputAvailable; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsSteamVRDrawingControllers(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsSteamVRDrawingControllers IsSteamVRDrawingControllers; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldApplicationPause(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldApplicationPause ShouldApplicationPause; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldApplicationReduceRenderingWork(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldApplicationReduceRenderingWork ShouldApplicationReduceRenderingWork; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRFirmwareError _PerformFirmwareUpdate(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PerformFirmwareUpdate PerformFirmwareUpdate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _AcknowledgeQuit_Exiting(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcknowledgeQuit_Exiting AcknowledgeQuit_Exiting; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetAppContainerFilePaths(System.Text.StringBuilder pchBuffer, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetAppContainerFilePaths GetAppContainerFilePaths; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetRuntimeVersion(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRuntimeVersion GetRuntimeVersion; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRExtendedDisplay + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetWindowBounds(ref int pnX, ref int pnY, ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWindowBounds GetWindowBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetEyeOutputViewport(EVREye eEye, ref uint pnX, ref uint pnY, ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEyeOutputViewport GetEyeOutputViewport; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex, ref int pnAdapterOutputIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDXGIOutputInfo GetDXGIOutputInfo; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRTrackedCamera + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetCameraErrorNameFromEnum(EVRTrackedCameraError eCameraError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraErrorNameFromEnum GetCameraErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _HasCamera(uint nDeviceIndex, ref bool pHasCamera); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HasCamera HasCamera; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetCameraFrameSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref uint pnWidth, ref uint pnHeight, ref uint pnFrameBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraFrameSize GetCameraFrameSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetCameraIntrinsics(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, ref HmdVector2_t pFocalLength, ref HmdVector2_t pCenter); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraIntrinsics GetCameraIntrinsics; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetCameraProjection(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, ref HmdMatrix44_t pProjection); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraProjection GetCameraProjection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _AcquireVideoStreamingService(uint nDeviceIndex, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcquireVideoStreamingService AcquireVideoStreamingService; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _ReleaseVideoStreamingService(ulong hTrackedCamera); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseVideoStreamingService ReleaseVideoStreamingService; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetVideoStreamFrameBuffer(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pFrameBuffer, uint nFrameBufferSize, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVideoStreamFrameBuffer GetVideoStreamFrameBuffer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetVideoStreamTextureSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref VRTextureBounds_t pTextureBounds, ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVideoStreamTextureSize GetVideoStreamTextureSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetVideoStreamTextureD3D11(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVideoStreamTextureD3D11 GetVideoStreamTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _GetVideoStreamTextureGL(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, ref uint pglTextureId, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVideoStreamTextureGL GetVideoStreamTextureGL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRTrackedCameraError _ReleaseVideoStreamTextureGL(ulong hTrackedCamera, uint glTextureId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseVideoStreamTextureGL ReleaseVideoStreamTextureGL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetCameraTrackingSpace(ETrackingUniverseOrigin eUniverse); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetCameraTrackingSpace SetCameraTrackingSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackingUniverseOrigin _GetCameraTrackingSpace(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCameraTrackingSpace GetCameraTrackingSpace; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRApplications + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _AddApplicationManifest(IntPtr pchApplicationManifestFullPath, bool bTemporary); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AddApplicationManifest AddApplicationManifest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _RemoveApplicationManifest(IntPtr pchApplicationManifestFullPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveApplicationManifest RemoveApplicationManifest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsApplicationInstalled(IntPtr pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsApplicationInstalled IsApplicationInstalled; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationCount GetApplicationCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetApplicationKeyByIndex(uint unApplicationIndex, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationKeyByIndex GetApplicationKeyByIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetApplicationKeyByProcessId(uint unProcessId, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationKeyByProcessId GetApplicationKeyByProcessId; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchApplication(IntPtr pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchApplication LaunchApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchTemplateApplication(IntPtr pchTemplateAppKey, IntPtr pchNewAppKey, [In, Out] AppOverrideKeys_t[] pKeys, uint unKeys); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchTemplateApplication LaunchTemplateApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchApplicationFromMimeType(IntPtr pchMimeType, IntPtr pchArgs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchApplicationFromMimeType LaunchApplicationFromMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchDashboardOverlay(IntPtr pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchDashboardOverlay LaunchDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CancelApplicationLaunch(IntPtr pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CancelApplicationLaunch CancelApplicationLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _IdentifyApplication(uint unProcessId, IntPtr pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IdentifyApplication IdentifyApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationProcessId(IntPtr pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationProcessId GetApplicationProcessId; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetApplicationsErrorNameFromEnum(EVRApplicationError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsErrorNameFromEnum GetApplicationsErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationPropertyString(IntPtr pchAppKey, EVRApplicationProperty eProperty, System.Text.StringBuilder pchPropertyValueBuffer, uint unPropertyValueBufferLen, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyString GetApplicationPropertyString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationPropertyBool(IntPtr pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyBool GetApplicationPropertyBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetApplicationPropertyUint64(IntPtr pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyUint64 GetApplicationPropertyUint64; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _SetApplicationAutoLaunch(IntPtr pchAppKey, bool bAutoLaunch); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetApplicationAutoLaunch SetApplicationAutoLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationAutoLaunch(IntPtr pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationAutoLaunch GetApplicationAutoLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _SetDefaultApplicationForMimeType(IntPtr pchAppKey, IntPtr pchMimeType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDefaultApplicationForMimeType SetDefaultApplicationForMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetDefaultApplicationForMimeType(IntPtr pchMimeType, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDefaultApplicationForMimeType GetDefaultApplicationForMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationSupportedMimeTypes(IntPtr pchAppKey, System.Text.StringBuilder pchMimeTypesBuffer, uint unMimeTypesBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationSupportedMimeTypes GetApplicationSupportedMimeTypes; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationsThatSupportMimeType(IntPtr pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsThatSupportMimeType GetApplicationsThatSupportMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationLaunchArguments(uint unHandle, System.Text.StringBuilder pchArgs, uint unArgs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationLaunchArguments GetApplicationLaunchArguments; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetStartingApplication GetStartingApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSceneApplicationState _GetSceneApplicationState(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSceneApplicationState GetSceneApplicationState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _PerformApplicationPrelaunchCheck(IntPtr pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PerformApplicationPrelaunchCheck PerformApplicationPrelaunchCheck; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetSceneApplicationStateNameFromEnum(EVRSceneApplicationState state); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSceneApplicationStateNameFromEnum GetSceneApplicationStateNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchInternalProcess(IntPtr pchBinaryPath, IntPtr pchArguments, IntPtr pchWorkingDirectory); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchInternalProcess LaunchInternalProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetCurrentSceneProcessId(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentSceneProcessId GetCurrentSceneProcessId; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRChaperone + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ChaperoneCalibrationState _GetCalibrationState(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCalibrationState GetCalibrationState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetPlayAreaSize(ref float pSizeX, ref float pSizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPlayAreaSize GetPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetPlayAreaRect(ref HmdQuad_t rect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPlayAreaRect GetPlayAreaRect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReloadInfo(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReloadInfo ReloadInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetSceneColor(HmdColor_t color); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetSceneColor SetSceneColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetBoundsColor(ref HmdColor_t pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, ref HmdColor_t pOutputCameraColor); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoundsColor GetBoundsColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _AreBoundsVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AreBoundsVisible AreBoundsVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceBoundsVisible(bool bForce); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceBoundsVisible ForceBoundsVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ResetZeroPose(ETrackingUniverseOrigin eTrackingUniverseOrigin); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ResetZeroPose ResetZeroPose; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRChaperoneSetup + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CommitWorkingCopy(EChaperoneConfigFile configFile); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CommitWorkingCopy CommitWorkingCopy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RevertWorkingCopy(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RevertWorkingCopy RevertWorkingCopy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingPlayAreaSize(ref float pSizeX, ref float pSizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingPlayAreaSize GetWorkingPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingPlayAreaRect(ref HmdQuad_t rect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingPlayAreaRect GetWorkingPlayAreaRect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingCollisionBoundsInfo GetWorkingCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetLiveCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLiveCollisionBoundsInfo GetLiveCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingSeatedZeroPoseToRawTrackingPose GetWorkingSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingStandingZeroPoseToRawTrackingPose GetWorkingStandingZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingPlayAreaSize(float sizeX, float sizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingPlayAreaSize SetWorkingPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, uint unQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingCollisionBoundsInfo SetWorkingCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingPerimeter([In, Out] HmdVector2_t[] pPointBuffer, uint unPointCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingPerimeter SetWorkingPerimeter; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingSeatedZeroPoseToRawTrackingPose SetWorkingSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingStandingZeroPoseToRawTrackingPose SetWorkingStandingZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReloadFromDisk(EChaperoneConfigFile configFile); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReloadFromDisk ReloadFromDisk; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLiveSeatedZeroPoseToRawTrackingPose GetLiveSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ExportLiveToBuffer(System.Text.StringBuilder pBuffer, ref uint pnBufferLength); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ExportLiveToBuffer ExportLiveToBuffer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ImportFromBufferToWorking(IntPtr pBuffer, uint nImportFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ImportFromBufferToWorking ImportFromBufferToWorking; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowWorkingSetPreview(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowWorkingSetPreview ShowWorkingSetPreview; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideWorkingSetPreview(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideWorkingSetPreview HideWorkingSetPreview; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RoomSetupStarting(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RoomSetupStarting RoomSetupStarting; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRCompositor + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetTrackingSpace(ETrackingUniverseOrigin eOrigin); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetTrackingSpace SetTrackingSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackingUniverseOrigin _GetTrackingSpace(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackingSpace GetTrackingSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _WaitGetPoses([In, Out] TrackedDevicePose_t[] pRenderPoseArray, uint unRenderPoseArrayCount, [In, Out] TrackedDevicePose_t[] pGamePoseArray, uint unGamePoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _WaitGetPoses WaitGetPoses; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetLastPoses([In, Out] TrackedDevicePose_t[] pRenderPoseArray, uint unRenderPoseArrayCount, [In, Out] TrackedDevicePose_t[] pGamePoseArray, uint unGamePoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastPoses GetLastPoses; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetLastPoseForTrackedDeviceIndex(uint unDeviceIndex, ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pOutputGamePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastPoseForTrackedDeviceIndex GetLastPoseForTrackedDeviceIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _Submit(EVREye eEye, ref Texture_t pTexture, ref VRTextureBounds_t pBounds, EVRSubmitFlags nSubmitFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Submit Submit; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ClearLastSubmittedFrame(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearLastSubmittedFrame ClearLastSubmittedFrame; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _PostPresentHandoff(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PostPresentHandoff PostPresentHandoff; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetFrameTiming(ref Compositor_FrameTiming pTiming, uint unFramesAgo); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFrameTiming GetFrameTiming; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetFrameTimings([In, Out] Compositor_FrameTiming[] pTiming, uint nFrames); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFrameTimings GetFrameTimings; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFrameTimeRemaining(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFrameTimeRemaining GetFrameTimeRemaining; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetCumulativeStats(ref Compositor_CumulativeStats pStats, uint nStatsSizeInBytes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCumulativeStats GetCumulativeStats; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FadeToColor FadeToColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdColor_t _GetCurrentFadeColor(bool bBackground); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentFadeColor GetCurrentFadeColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FadeGrid(float fSeconds, bool bFadeGridIn); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FadeGrid FadeGrid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetCurrentGridAlpha(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentGridAlpha GetCurrentGridAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SetSkyboxOverride([In, Out] Texture_t[] pTextures, uint unTextureCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetSkyboxOverride SetSkyboxOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ClearSkyboxOverride(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearSkyboxOverride ClearSkyboxOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorBringToFront(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorBringToFront CompositorBringToFront; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorGoToBack(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorGoToBack CompositorGoToBack; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorQuit(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorQuit CompositorQuit; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsFullscreen(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsFullscreen IsFullscreen; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetCurrentSceneFocusProcess(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentSceneFocusProcess GetCurrentSceneFocusProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetLastFrameRenderer(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastFrameRenderer GetLastFrameRenderer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CanRenderScene(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CanRenderScene CanRenderScene; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowMirrorWindow(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMirrorWindow ShowMirrorWindow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideMirrorWindow(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideMirrorWindow HideMirrorWindow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMirrorWindowVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMirrorWindowVisible IsMirrorWindowVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorDumpImages(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorDumpImages CompositorDumpImages; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldAppRenderWithLowResources(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldAppRenderWithLowResources ShouldAppRenderWithLowResources; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceInterleavedReprojectionOn(bool bOverride); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceInterleavedReprojectionOn ForceInterleavedReprojectionOn; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceReconnectProcess(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceReconnectProcess ForceReconnectProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SuspendRendering(bool bSuspend); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SuspendRendering SuspendRendering; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetMirrorTextureD3D11(EVREye eEye, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMirrorTextureD3D11 GetMirrorTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseMirrorTextureD3D11 ReleaseMirrorTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetMirrorTextureGL(EVREye eEye, ref uint pglTextureId, IntPtr pglSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMirrorTextureGL GetMirrorTextureGL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ReleaseSharedGLTexture(uint glTextureId, IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseSharedGLTexture ReleaseSharedGLTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LockGLSharedTextureForAccess LockGLSharedTextureForAccess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UnlockGLSharedTextureForAccess UnlockGLSharedTextureForAccess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanInstanceExtensionsRequired GetVulkanInstanceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanDeviceExtensionsRequired GetVulkanDeviceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetExplicitTimingMode SetExplicitTimingMode; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SubmitExplicitTimingData(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SubmitExplicitTimingData SubmitExplicitTimingData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMotionSmoothingEnabled(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMotionSmoothingEnabled IsMotionSmoothingEnabled; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMotionSmoothingSupported(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMotionSmoothingSupported IsMotionSmoothingSupported; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsCurrentSceneFocusAppLoading(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsCurrentSceneFocusAppLoading IsCurrentSceneFocusAppLoading; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SetStageOverride_Async(IntPtr pchRenderModelPath, ref HmdMatrix34_t pTransform, ref Compositor_StageRenderSettings pRenderSettings, uint nSizeOfRenderSettings); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetStageOverride_Async SetStageOverride_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ClearStageOverride(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearStageOverride ClearStageOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetCompositorBenchmarkResults(ref Compositor_BenchmarkResults pBenchmarkResults, uint nSizeOfBenchmarkResults); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCompositorBenchmarkResults GetCompositorBenchmarkResults; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetLastPosePredictionIDs(ref uint pRenderPosePredictionID, ref uint pGamePosePredictionID); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastPosePredictionIDs GetLastPosePredictionIDs; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetPosesForFrame(uint unPosePredictionID, [In, Out] TrackedDevicePose_t[] pPoseArray, uint unPoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPosesForFrame GetPosesForFrame; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVROverlay + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _FindOverlay(IntPtr pchOverlayKey, ref ulong pOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FindOverlay FindOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _CreateOverlay(IntPtr pchOverlayKey, IntPtr pchOverlayName, ref ulong pOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateOverlay CreateOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _DestroyOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DestroyOverlay DestroyOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayKey(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayKey GetOverlayKey; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayName(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayName GetOverlayName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayName(ulong ulOverlayHandle, IntPtr pchName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayName SetOverlayName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayImageData(ulong ulOverlayHandle, IntPtr pvBuffer, uint unBufferSize, ref uint punWidth, ref uint punHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayImageData GetOverlayImageData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetOverlayErrorNameFromEnum(EVROverlayError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayErrorNameFromEnum GetOverlayErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRenderingPid(ulong ulOverlayHandle, uint unPID); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRenderingPid SetOverlayRenderingPid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayRenderingPid(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayRenderingPid GetOverlayRenderingPid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayFlag SetOverlayFlag; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, ref bool pbEnabled); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlag GetOverlayFlag; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlags(ulong ulOverlayHandle, ref uint pFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlags GetOverlayFlags; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayColor(ulong ulOverlayHandle, float fRed, float fGreen, float fBlue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayColor SetOverlayColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayColor(ulong ulOverlayHandle, ref float pfRed, ref float pfGreen, ref float pfBlue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayColor GetOverlayColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayAlpha(ulong ulOverlayHandle, float fAlpha); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayAlpha SetOverlayAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayAlpha(ulong ulOverlayHandle, ref float pfAlpha); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayAlpha GetOverlayAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTexelAspect(ulong ulOverlayHandle, float fTexelAspect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTexelAspect SetOverlayTexelAspect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTexelAspect(ulong ulOverlayHandle, ref float pfTexelAspect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTexelAspect GetOverlayTexelAspect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlaySortOrder(ulong ulOverlayHandle, uint unSortOrder); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlaySortOrder SetOverlaySortOrder; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlaySortOrder(ulong ulOverlayHandle, ref uint punSortOrder); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlaySortOrder GetOverlaySortOrder; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayWidthInMeters(ulong ulOverlayHandle, float fWidthInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayWidthInMeters SetOverlayWidthInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayWidthInMeters(ulong ulOverlayHandle, ref float pfWidthInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayWidthInMeters GetOverlayWidthInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayCurvature(ulong ulOverlayHandle, float fCurvature); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayCurvature SetOverlayCurvature; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayCurvature(ulong ulOverlayHandle, ref float pfCurvature); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayCurvature GetOverlayCurvature; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTextureColorSpace(ulong ulOverlayHandle, EColorSpace eTextureColorSpace); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTextureColorSpace SetOverlayTextureColorSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureColorSpace(ulong ulOverlayHandle, ref EColorSpace peTextureColorSpace); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureColorSpace GetOverlayTextureColorSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTextureBounds SetOverlayTextureBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureBounds GetOverlayTextureBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformType(ulong ulOverlayHandle, ref VROverlayTransformType peTransformType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformType GetOverlayTransformType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformAbsolute(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformAbsolute SetOverlayTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformAbsolute GetOverlayTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, uint unTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformTrackedDeviceRelative SetOverlayTransformTrackedDeviceRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, ref uint punTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformTrackedDeviceRelative GetOverlayTransformTrackedDeviceRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, IntPtr pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformTrackedDeviceComponent SetOverlayTransformTrackedDeviceComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, ref uint punDeviceIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformTrackedDeviceComponent GetOverlayTransformTrackedDeviceComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ref ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformOverlayRelative GetOverlayTransformOverlayRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformOverlayRelative SetOverlayTransformOverlayRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformCursor(ulong ulCursorOverlayHandle, ref HmdVector2_t pvHotspot); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformCursor SetOverlayTransformCursor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformCursor(ulong ulOverlayHandle, ref HmdVector2_t pvHotspot); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformCursor GetOverlayTransformCursor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformProjection(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform, ref VROverlayProjection_t pProjection, EVREye eEye); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformProjection SetOverlayTransformProjection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowOverlay ShowOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _HideOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideOverlay HideOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsOverlayVisible(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsOverlayVisible IsOverlayVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTransformForOverlayCoordinates GetTransformForOverlayCoordinates; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pEvent, uint uncbVREvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextOverlayEvent PollNextOverlayEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayInputMethod(ulong ulOverlayHandle, ref VROverlayInputMethod peInputMethod); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayInputMethod GetOverlayInputMethod; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayInputMethod(ulong ulOverlayHandle, VROverlayInputMethod eInputMethod); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayInputMethod SetOverlayInputMethod; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayMouseScale GetOverlayMouseScale; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayMouseScale SetOverlayMouseScale; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ComputeOverlayIntersection(ulong ulOverlayHandle, ref VROverlayIntersectionParams_t pParams, ref VROverlayIntersectionResults_t pResults); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ComputeOverlayIntersection ComputeOverlayIntersection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsHoverTargetOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsHoverTargetOverlay IsHoverTargetOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayIntersectionMask(ulong ulOverlayHandle, ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives, uint unNumMaskPrimitives, uint unPrimitiveSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayIntersectionMask SetOverlayIntersectionMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _TriggerLaserMouseHapticVibration(ulong ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TriggerLaserMouseHapticVibration TriggerLaserMouseHapticVibration; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayCursor(ulong ulOverlayHandle, ulong ulCursorHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayCursor SetOverlayCursor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayCursorPositionOverride(ulong ulOverlayHandle, ref HmdVector2_t pvCursor); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayCursorPositionOverride SetOverlayCursorPositionOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ClearOverlayCursorPositionOverride(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearOverlayCursorPositionOverride ClearOverlayCursorPositionOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTexture(ulong ulOverlayHandle, ref Texture_t pTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTexture SetOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ClearOverlayTexture(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearOverlayTexture ClearOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRaw(ulong ulOverlayHandle, IntPtr pvBuffer, uint unWidth, uint unHeight, uint unBytesPerPixel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRaw SetOverlayRaw; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayFromFile(ulong ulOverlayHandle, IntPtr pchFilePath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayFromFile SetOverlayFromFile; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref ETextureType pAPIType, ref EColorSpace pColorSpace, ref VRTextureBounds_t pTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTexture GetOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ReleaseNativeOverlayHandle(ulong ulOverlayHandle, IntPtr pNativeTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseNativeOverlayHandle ReleaseNativeOverlayHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureSize(ulong ulOverlayHandle, ref uint pWidth, ref uint pHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureSize GetOverlayTextureSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _CreateDashboardOverlay(IntPtr pchOverlayKey, IntPtr pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateDashboardOverlay CreateDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsDashboardVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsDashboardVisible IsDashboardVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsActiveDashboardOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsActiveDashboardOverlay IsActiveDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetDashboardOverlaySceneProcess(ulong ulOverlayHandle, uint unProcessId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDashboardOverlaySceneProcess SetDashboardOverlaySceneProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetDashboardOverlaySceneProcess(ulong ulOverlayHandle, ref uint punProcessId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDashboardOverlaySceneProcess GetDashboardOverlaySceneProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowDashboard(IntPtr pchOverlayToShow); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowDashboard ShowDashboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetPrimaryDashboardDevice(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPrimaryDashboardDevice GetPrimaryDashboardDevice; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowKeyboard(int eInputMode, int eLineInputMode, uint unFlags, IntPtr pchDescription, uint unCharMax, IntPtr pchExistingText, ulong uUserValue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowKeyboard ShowKeyboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowKeyboardForOverlay(ulong ulOverlayHandle, int eInputMode, int eLineInputMode, uint unFlags, IntPtr pchDescription, uint unCharMax, IntPtr pchExistingText, ulong uUserValue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowKeyboardForOverlay ShowKeyboardForOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetKeyboardText(System.Text.StringBuilder pchText, uint cchText); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetKeyboardText GetKeyboardText; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideKeyboard(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideKeyboard HideKeyboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetKeyboardTransformAbsolute SetKeyboardTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetKeyboardPositionForOverlay(ulong ulOverlayHandle, HmdRect2_t avoidRect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetKeyboardPositionForOverlay SetKeyboardPositionForOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate VRMessageOverlayResponse _ShowMessageOverlay(IntPtr pchText, IntPtr pchCaption, IntPtr pchButton0Text, IntPtr pchButton1Text, IntPtr pchButton2Text, IntPtr pchButton3Text); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMessageOverlay ShowMessageOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CloseMessageOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CloseMessageOverlay CloseMessageOverlay; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVROverlayView + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _AcquireOverlayView(ulong ulOverlayHandle, ref VRNativeDevice_t pNativeDevice, ref VROverlayView_t pOverlayView, uint unOverlayViewSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcquireOverlayView AcquireOverlayView; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ReleaseOverlayView(ref VROverlayView_t pOverlayView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseOverlayView ReleaseOverlayView; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _PostOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pvrEvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PostOverlayEvent PostOverlayEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsViewingPermitted(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsViewingPermitted IsViewingPermitted; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRHeadsetView + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetHeadsetViewSize(uint nWidth, uint nHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetHeadsetViewSize SetHeadsetViewSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetHeadsetViewSize(ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHeadsetViewSize GetHeadsetViewSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetHeadsetViewMode(uint eHeadsetViewMode); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetHeadsetViewMode SetHeadsetViewMode; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetHeadsetViewMode(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHeadsetViewMode GetHeadsetViewMode; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetHeadsetViewCropped(bool bCropped); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetHeadsetViewCropped SetHeadsetViewCropped; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetHeadsetViewCropped(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHeadsetViewCropped GetHeadsetViewCropped; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetHeadsetViewAspectRatio(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHeadsetViewAspectRatio GetHeadsetViewAspectRatio; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetHeadsetViewBlendRange(float flStartPct, float flEndPct); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetHeadsetViewBlendRange SetHeadsetViewBlendRange; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetHeadsetViewBlendRange(ref float pStartPct, ref float pEndPct); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHeadsetViewBlendRange GetHeadsetViewBlendRange; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRRenderModels + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadRenderModel_Async(IntPtr pchRenderModelName, ref IntPtr ppRenderModel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadRenderModel_Async LoadRenderModel_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeRenderModel(IntPtr pRenderModel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeRenderModel FreeRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadTexture_Async(int textureId, ref IntPtr ppTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadTexture_Async LoadTexture_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeTexture(IntPtr pTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeTexture FreeTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadTextureD3D11_Async LoadTextureD3D11_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadIntoTextureD3D11_Async LoadIntoTextureD3D11_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeTextureD3D11(IntPtr pD3D11Texture2D); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeTextureD3D11 FreeTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelName GetRenderModelName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelCount GetRenderModelCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentCount(IntPtr pchRenderModelName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentCount GetComponentCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentName(IntPtr pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentName GetComponentName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetComponentButtonMask(IntPtr pchRenderModelName, IntPtr pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentButtonMask GetComponentButtonMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentRenderModelName(IntPtr pchRenderModelName, IntPtr pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentRenderModelName GetComponentRenderModelName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentStateForDevicePath(IntPtr pchRenderModelName, IntPtr pchComponentName, ulong devicePath, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentStateForDevicePath GetComponentStateForDevicePath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentState(IntPtr pchRenderModelName, IntPtr pchComponentName, ref VRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentState GetComponentState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _RenderModelHasComponent(IntPtr pchRenderModelName, IntPtr pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RenderModelHasComponent RenderModelHasComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelThumbnailURL(IntPtr pchRenderModelName, System.Text.StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelThumbnailURL GetRenderModelThumbnailURL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelOriginalPath(IntPtr pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelOriginalPath GetRenderModelOriginalPath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetRenderModelErrorNameFromEnum(EVRRenderModelError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelErrorNameFromEnum GetRenderModelErrorNameFromEnum; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRNotifications + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRNotificationError _CreateNotification(ulong ulOverlayHandle, ulong ulUserValue, EVRNotificationType type, IntPtr pchText, EVRNotificationStyle style, ref NotificationBitmap_t pImage, ref uint pNotificationId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateNotification CreateNotification; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRNotificationError _RemoveNotification(uint notificationId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveNotification RemoveNotification; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRSettings + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetSettingsErrorNameFromEnum(EVRSettingsError eError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSettingsErrorNameFromEnum GetSettingsErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetBool(IntPtr pchSection, IntPtr pchSettingsKey, bool bValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetBool SetBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetInt32(IntPtr pchSection, IntPtr pchSettingsKey, int nValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetInt32 SetInt32; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetFloat(IntPtr pchSection, IntPtr pchSettingsKey, float flValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetFloat SetFloat; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetString(IntPtr pchSection, IntPtr pchSettingsKey, IntPtr pchValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetString SetString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetBool(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBool GetBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetInt32(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInt32 GetInt32; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFloat(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFloat GetFloat; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetString(IntPtr pchSection, IntPtr pchSettingsKey, System.Text.StringBuilder pchValue, uint unValueLen, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetString GetString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RemoveSection(IntPtr pchSection, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveSection RemoveSection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RemoveKeyInSection(IntPtr pchSection, IntPtr pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveKeyInSection RemoveKeyInSection; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRScreenshots + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, IntPtr pchPreviewFilename, IntPtr pchVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RequestScreenshot RequestScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _HookScreenshot([In, Out] EVRScreenshotType[] pSupportedTypes, int numTypes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HookScreenshot HookScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotType _GetScreenshotPropertyType(uint screenshotHandle, ref EVRScreenshotError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetScreenshotPropertyType GetScreenshotPropertyType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetScreenshotPropertyFilename(uint screenshotHandle, EVRScreenshotPropertyFilenames filenameType, System.Text.StringBuilder pchFilename, uint cchFilename, ref EVRScreenshotError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetScreenshotPropertyFilename GetScreenshotPropertyFilename; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _UpdateScreenshotProgress(uint screenshotHandle, float flProgress); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UpdateScreenshotProgress UpdateScreenshotProgress; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _TakeStereoScreenshot(ref uint pOutScreenshotHandle, IntPtr pchPreviewFilename, IntPtr pchVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TakeStereoScreenshot TakeStereoScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _SubmitScreenshot(uint screenshotHandle, EVRScreenshotType type, IntPtr pchSourcePreviewFilename, IntPtr pchSourceVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SubmitScreenshot SubmitScreenshot; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRResources + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _LoadSharedResource(IntPtr pchResourceName, string pchBuffer, uint unBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadSharedResource LoadSharedResource; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetResourceFullPath(IntPtr pchResourceName, IntPtr pchResourceTypeDirectory, System.Text.StringBuilder pchPathBuffer, uint unBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetResourceFullPath GetResourceFullPath; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRDriverManager + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetDriverCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverCount GetDriverCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetDriverName(uint nDriver, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverName GetDriverName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetDriverHandle(IntPtr pchDriverName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverHandle GetDriverHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsEnabled(uint nDriver); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsEnabled IsEnabled; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRInput + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _SetActionManifestPath(IntPtr pchActionManifestPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetActionManifestPath SetActionManifestPath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionSetHandle(IntPtr pchActionSetName, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionSetHandle GetActionSetHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionHandle(IntPtr pchActionName, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionHandle GetActionHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetInputSourceHandle(IntPtr pchInputSourcePath, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInputSourceHandle GetInputSourceHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _UpdateActionState([In, Out] VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, uint unSetCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UpdateActionState UpdateActionState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetDigitalActionData(ulong action, ref InputDigitalActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDigitalActionData GetDigitalActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetAnalogActionData(ulong action, ref InputAnalogActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetAnalogActionData GetAnalogActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetPoseActionDataRelativeToNow(ulong action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, ref InputPoseActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPoseActionDataRelativeToNow GetPoseActionDataRelativeToNow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetPoseActionDataForNextFrame(ulong action, ETrackingUniverseOrigin eOrigin, ref InputPoseActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPoseActionDataForNextFrame GetPoseActionDataForNextFrame; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalActionData(ulong action, ref InputSkeletalActionData_t pActionData, uint unActionDataSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalActionData GetSkeletalActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetDominantHand(ref ETrackedControllerRole peDominantHand); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDominantHand GetDominantHand; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _SetDominantHand(ETrackedControllerRole eDominantHand); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDominantHand SetDominantHand; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetBoneCount(ulong action, ref uint pBoneCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoneCount GetBoneCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetBoneHierarchy(ulong action, [In, Out] int[] pParentIndices, uint unIndexArayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoneHierarchy GetBoneHierarchy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetBoneName(ulong action, int nBoneIndex, System.Text.StringBuilder pchBoneName, uint unNameBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoneName GetBoneName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalReferenceTransforms(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalReferenceTransforms GetSkeletalReferenceTransforms; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalTrackingLevel(ulong action, ref EVRSkeletalTrackingLevel pSkeletalTrackingLevel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalTrackingLevel GetSkeletalTrackingLevel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalBoneData(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalBoneData GetSkeletalBoneData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalSummaryData(ulong action, EVRSummaryType eSummaryType, ref VRSkeletalSummaryData_t pSkeletalSummaryData); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalSummaryData GetSkeletalSummaryData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetSkeletalBoneDataCompressed(ulong action, EVRSkeletalMotionRange eMotionRange, IntPtr pvCompressedData, uint unCompressedSize, ref uint punRequiredCompressedSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSkeletalBoneDataCompressed GetSkeletalBoneDataCompressed; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _DecompressSkeletalBoneData(IntPtr pvCompressedBuffer, uint unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, [In, Out] VRBoneTransform_t[] pTransformArray, uint unTransformArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DecompressSkeletalBoneData DecompressSkeletalBoneData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _TriggerHapticVibrationAction(ulong action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TriggerHapticVibrationAction TriggerHapticVibrationAction; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionOrigins(ulong actionSetHandle, ulong digitalActionHandle, [In, Out] ulong[] originsOut, uint originOutCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionOrigins GetActionOrigins; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetOriginLocalizedName(ulong origin, System.Text.StringBuilder pchNameArray, uint unNameArraySize, int unStringSectionsToInclude); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOriginLocalizedName GetOriginLocalizedName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetOriginTrackedDeviceInfo(ulong origin, ref InputOriginInfo_t pOriginInfo, uint unOriginInfoSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOriginTrackedDeviceInfo GetOriginTrackedDeviceInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionBindingInfo(ulong action, ref InputBindingInfo_t pOriginInfo, uint unBindingInfoSize, uint unBindingInfoCount, ref uint punReturnedBindingInfoCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionBindingInfo GetActionBindingInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _ShowActionOrigins(ulong actionSetHandle, ulong ulActionHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowActionOrigins ShowActionOrigins; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _ShowBindingsForActionSet([In, Out] VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, uint unSetCount, ulong originToHighlight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowBindingsForActionSet ShowBindingsForActionSet; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetComponentStateForBinding(IntPtr pchRenderModelName, IntPtr pchComponentName, ref InputBindingInfo_t pOriginInfo, uint unBindingInfoSize, uint unBindingInfoCount, ref RenderModel_ComponentState_t pComponentState); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentStateForBinding GetComponentStateForBinding; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsUsingLegacyInput(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsUsingLegacyInput IsUsingLegacyInput; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _OpenBindingUI(IntPtr pchAppKey, ulong ulActionSetHandle, ulong ulDeviceHandle, bool bShowOnDesktop); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _OpenBindingUI OpenBindingUI; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetBindingVariant(ulong ulDevicePath, System.Text.StringBuilder pchVariantArray, uint unVariantArraySize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBindingVariant GetBindingVariant; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRIOBuffer + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Open(IntPtr pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Open Open; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Close(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Close Close; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Read(ulong ulBuffer, IntPtr pDst, uint unBytes, ref uint punRead); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Read Read; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Write(ulong ulBuffer, IntPtr pSrc, uint unBytes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Write Write; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _PropertyContainer(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PropertyContainer PropertyContainer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _HasReaders(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HasReaders HasReaders; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRSpatialAnchors + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromDescriptor(IntPtr pchDescriptor, ref uint pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateSpatialAnchorFromDescriptor CreateSpatialAnchorFromDescriptor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromPose(uint unDeviceIndex, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPose, ref uint pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateSpatialAnchorFromPose CreateSpatialAnchorFromPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _GetSpatialAnchorPose(uint unHandle, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPoseOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSpatialAnchorPose GetSpatialAnchorPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _GetSpatialAnchorDescriptor(uint unHandle, System.Text.StringBuilder pchDescriptorOut, ref uint punDescriptorBufferLenInOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSpatialAnchorDescriptor GetSpatialAnchorDescriptor; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRDebug + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRDebugError _EmitVrProfilerEvent(IntPtr pchMessage); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _EmitVrProfilerEvent EmitVrProfilerEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRDebugError _BeginVrProfilerEvent(ref ulong pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _BeginVrProfilerEvent BeginVrProfilerEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRDebugError _FinishVrProfilerEvent(ulong hHandle, IntPtr pchMessage); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FinishVrProfilerEvent FinishVrProfilerEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _DriverDebugRequest(uint unDeviceIndex, IntPtr pchRequest, System.Text.StringBuilder pchResponseBuffer, uint unResponseBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DriverDebugRequest DriverDebugRequest; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRProperties + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedPropertyError _ReadPropertyBatch(ulong ulContainerHandle, ref PropertyRead_t pBatch, uint unBatchEntryCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReadPropertyBatch ReadPropertyBatch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedPropertyError _WritePropertyBatch(ulong ulContainerHandle, ref PropertyWrite_t pBatch, uint unBatchEntryCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _WritePropertyBatch WritePropertyBatch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetPropErrorNameFromEnum(ETrackedPropertyError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPropErrorNameFromEnum GetPropErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _TrackedDeviceToPropertyContainer(uint nDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TrackedDeviceToPropertyContainer TrackedDeviceToPropertyContainer; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRPaths + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedPropertyError _ReadPathBatch(ulong ulRootHandle, ref PathRead_t pBatch, uint unBatchEntryCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReadPathBatch ReadPathBatch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedPropertyError _WritePathBatch(ulong ulRootHandle, ref PathWrite_t pBatch, uint unBatchEntryCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _WritePathBatch WritePathBatch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedPropertyError _StringToHandle(ref ulong pHandle, IntPtr pchPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _StringToHandle StringToHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedPropertyError _HandleToString(ulong pHandle, string pchBuffer, uint unBufferSize, ref uint punBufferSizeUsed); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HandleToString HandleToString; + + } + + [StructLayout(LayoutKind.Sequential)] + public struct IVRBlockQueue + { + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _Create(ref ulong pulQueueHandle, IntPtr pchPath, uint unBlockDataSize, uint unBlockHeaderSize, uint unBlockCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Create Create; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _Connect(ref ulong pulQueueHandle, IntPtr pchPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Connect Connect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _Destroy(ulong ulQueueHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Destroy Destroy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _AcquireWriteOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcquireWriteOnlyBlock AcquireWriteOnlyBlock; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _ReleaseWriteOnlyBlock(ulong ulQueueHandle, ulong ulBlockHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseWriteOnlyBlock ReleaseWriteOnlyBlock; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _WaitAndAcquireReadOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer, EBlockQueueReadType eReadType, uint unTimeoutMs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _WaitAndAcquireReadOnlyBlock WaitAndAcquireReadOnlyBlock; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _AcquireReadOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer, EBlockQueueReadType eReadType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcquireReadOnlyBlock AcquireReadOnlyBlock; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _ReleaseReadOnlyBlock(ulong ulQueueHandle, ulong ulBlockHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseReadOnlyBlock ReleaseReadOnlyBlock; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EBlockQueueError _QueueHasReader(ulong ulQueueHandle, ref bool pbHasReaders); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _QueueHasReader QueueHasReader; + + } + + + public class Utils + { + public static IntPtr ToUtf8(string managedString) + { + if (managedString == null) + { + return IntPtr.Zero; + } + + int size = System.Text.Encoding.UTF8.GetByteCount(managedString) + 1; + if (buffer.Length < size) buffer = new byte[size]; + int written = System.Text.Encoding.UTF8.GetBytes(managedString, 0, managedString.Length, buffer, 0); + buffer[written] = 0x00; // null terminate + IntPtr nativeUtf8 = Marshal.AllocHGlobal(written + 1); + Marshal.Copy(buffer, 0, nativeUtf8, written + 1); + return nativeUtf8; + } + private static byte[] buffer = new byte[1024]; + } + + public class CVRSystem + { + IVRSystem FnTable; + internal CVRSystem(IntPtr pInterface) + { + FnTable = (IVRSystem)Marshal.PtrToStructure(pInterface, typeof(IVRSystem)); + } + public void GetRecommendedRenderTargetSize(ref uint pnWidth, ref uint pnHeight) + { + pnWidth = 0; + pnHeight = 0; + FnTable.GetRecommendedRenderTargetSize(ref pnWidth, ref pnHeight); + } + public HmdMatrix44_t GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ) + { + HmdMatrix44_t result = FnTable.GetProjectionMatrix(eEye, fNearZ, fFarZ); + return result; + } + public void GetProjectionRaw(EVREye eEye, ref float pfLeft, ref float pfRight, ref float pfTop, ref float pfBottom) + { + pfLeft = 0; + pfRight = 0; + pfTop = 0; + pfBottom = 0; + FnTable.GetProjectionRaw(eEye, ref pfLeft, ref pfRight, ref pfTop, ref pfBottom); + } + public bool ComputeDistortion(EVREye eEye, float fU, float fV, ref DistortionCoordinates_t pDistortionCoordinates) + { + bool result = FnTable.ComputeDistortion(eEye, fU, fV, ref pDistortionCoordinates); + return result; + } + public HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) + { + HmdMatrix34_t result = FnTable.GetEyeToHeadTransform(eEye); + return result; + } + public bool GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync, ref ulong pulFrameCounter) + { + pfSecondsSinceLastVsync = 0; + pulFrameCounter = 0; + bool result = FnTable.GetTimeSinceLastVsync(ref pfSecondsSinceLastVsync, ref pulFrameCounter); + return result; + } + public int GetD3D9AdapterIndex() + { + int result = FnTable.GetD3D9AdapterIndex(); + return result; + } + public void GetDXGIOutputInfo(ref int pnAdapterIndex) + { + pnAdapterIndex = 0; + FnTable.GetDXGIOutputInfo(ref pnAdapterIndex); + } + public void GetOutputDevice(ref ulong pnDevice, ETextureType textureType, IntPtr pInstance) + { + pnDevice = 0; + FnTable.GetOutputDevice(ref pnDevice, textureType, pInstance); + } + public bool IsDisplayOnDesktop() + { + bool result = FnTable.IsDisplayOnDesktop(); + return result; + } + public bool SetDisplayVisibility(bool bIsVisibleOnDesktop) + { + bool result = FnTable.SetDisplayVisibility(bIsVisibleOnDesktop); + return result; + } + public void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, TrackedDevicePose_t[] pTrackedDevicePoseArray) + { + FnTable.GetDeviceToAbsoluteTrackingPose(eOrigin, fPredictedSecondsToPhotonsFromNow, pTrackedDevicePoseArray, (uint)pTrackedDevicePoseArray.Length); + } + public HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() + { + HmdMatrix34_t result = FnTable.GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + return result; + } + public HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() + { + HmdMatrix34_t result = FnTable.GetRawZeroPoseToStandingAbsoluteTrackingPose(); + return result; + } + public uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, uint[] punTrackedDeviceIndexArray, uint unRelativeToTrackedDeviceIndex) + { + uint result = FnTable.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass, punTrackedDeviceIndexArray, (uint)punTrackedDeviceIndexArray.Length, unRelativeToTrackedDeviceIndex); + return result; + } + public EDeviceActivityLevel GetTrackedDeviceActivityLevel(uint unDeviceId) + { + EDeviceActivityLevel result = FnTable.GetTrackedDeviceActivityLevel(unDeviceId); + return result; + } + public void ApplyTransform(ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pTrackedDevicePose, ref HmdMatrix34_t pTransform) + { + FnTable.ApplyTransform(ref pOutputPose, ref pTrackedDevicePose, ref pTransform); + } + public uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType) + { + uint result = FnTable.GetTrackedDeviceIndexForControllerRole(unDeviceType); + return result; + } + public ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex) + { + ETrackedControllerRole result = FnTable.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex); + return result; + } + public ETrackedDeviceClass GetTrackedDeviceClass(uint unDeviceIndex) + { + ETrackedDeviceClass result = FnTable.GetTrackedDeviceClass(unDeviceIndex); + return result; + } + public bool IsTrackedDeviceConnected(uint unDeviceIndex) + { + bool result = FnTable.IsTrackedDeviceConnected(unDeviceIndex); + return result; + } + public bool GetBoolTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + bool result = FnTable.GetBoolTrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public float GetFloatTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + float result = FnTable.GetFloatTrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public int GetInt32TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + int result = FnTable.GetInt32TrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public ulong GetUint64TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + ulong result = FnTable.GetUint64TrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public HmdMatrix34_t GetMatrix34TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError) + { + HmdMatrix34_t result = FnTable.GetMatrix34TrackedDeviceProperty(unDeviceIndex, prop, ref pError); + return result; + } + public uint GetArrayTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, uint propType, IntPtr pBuffer, uint unBufferSize, ref ETrackedPropertyError pError) + { + uint result = FnTable.GetArrayTrackedDeviceProperty(unDeviceIndex, prop, propType, pBuffer, unBufferSize, ref pError); + return result; + } + public uint GetStringTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, System.Text.StringBuilder pchValue, uint unBufferSize, ref ETrackedPropertyError pError) + { + uint result = FnTable.GetStringTrackedDeviceProperty(unDeviceIndex, prop, pchValue, unBufferSize, ref pError); + return result; + } + public string GetPropErrorNameFromEnum(ETrackedPropertyError error) + { + IntPtr result = FnTable.GetPropErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + // This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were + // originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEventPacked(ref VREvent_t_Packed pEvent, uint uncbVREvent); + [StructLayout(LayoutKind.Explicit)] + struct PollNextEventUnion + { + [FieldOffset(0)] + public IVRSystem._PollNextEvent pPollNextEvent; + [FieldOffset(0)] + public _PollNextEventPacked pPollNextEventPacked; + } + public bool PollNextEvent(ref VREvent_t pEvent, uint uncbVREvent) + { +#if !UNITY_METRO + if (Environment.OSVersion.Platform == PlatformID.MacOSX || + Environment.OSVersion.Platform == 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)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 (Environment.OSVersion.Platform == PlatformID.MacOSX || + Environment.OSVersion.Platform == 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)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 (Environment.OSVersion.Platform == PlatformID.MacOSX || + Environment.OSVersion.Platform == 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)Marshal.SizeOf(typeof(VRControllerState_t_Packed)), ref pTrackedDevicePose); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetControllerStateWithPose(eOrigin, unControllerDeviceIndex, ref pControllerState, unControllerStateSize, ref pTrackedDevicePose); + return result; + } + public void TriggerHapticPulse(uint unControllerDeviceIndex, uint unAxisId, ushort usDurationMicroSec) + { + FnTable.TriggerHapticPulse(unControllerDeviceIndex, unAxisId, usDurationMicroSec); + } + public string GetButtonIdNameFromEnum(EVRButtonId eButtonId) + { + IntPtr result = FnTable.GetButtonIdNameFromEnum(eButtonId); + return Marshal.PtrToStringAnsi(result); + } + public string GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType) + { + IntPtr result = FnTable.GetControllerAxisTypeNameFromEnum(eAxisType); + return Marshal.PtrToStringAnsi(result); + } + public bool IsInputAvailable() + { + bool result = FnTable.IsInputAvailable(); + return result; + } + public bool IsSteamVRDrawingControllers() + { + bool result = FnTable.IsSteamVRDrawingControllers(); + return result; + } + public bool ShouldApplicationPause() + { + bool result = FnTable.ShouldApplicationPause(); + return result; + } + public bool ShouldApplicationReduceRenderingWork() + { + bool result = FnTable.ShouldApplicationReduceRenderingWork(); + return result; + } + public EVRFirmwareError PerformFirmwareUpdate(uint unDeviceIndex) + { + EVRFirmwareError result = FnTable.PerformFirmwareUpdate(unDeviceIndex); + return result; + } + public void AcknowledgeQuit_Exiting() + { + FnTable.AcknowledgeQuit_Exiting(); + } + public uint GetAppContainerFilePaths(System.Text.StringBuilder pchBuffer, uint unBufferSize) + { + uint result = FnTable.GetAppContainerFilePaths(pchBuffer, unBufferSize); + return result; + } + public string GetRuntimeVersion() + { + IntPtr result = FnTable.GetRuntimeVersion(); + return Marshal.PtrToStringAnsi(result); + } + } + + + public class CVRExtendedDisplay + { + IVRExtendedDisplay FnTable; + internal CVRExtendedDisplay(IntPtr pInterface) + { + FnTable = (IVRExtendedDisplay)Marshal.PtrToStructure(pInterface, typeof(IVRExtendedDisplay)); + } + public void GetWindowBounds(ref int pnX, ref int pnY, ref uint pnWidth, ref uint pnHeight) + { + pnX = 0; + pnY = 0; + pnWidth = 0; + pnHeight = 0; + FnTable.GetWindowBounds(ref pnX, ref pnY, ref pnWidth, ref pnHeight); + } + public void GetEyeOutputViewport(EVREye eEye, ref uint pnX, ref uint pnY, ref uint pnWidth, ref uint pnHeight) + { + pnX = 0; + pnY = 0; + pnWidth = 0; + pnHeight = 0; + FnTable.GetEyeOutputViewport(eEye, ref pnX, ref pnY, ref pnWidth, ref pnHeight); + } + public void GetDXGIOutputInfo(ref int pnAdapterIndex, ref int pnAdapterOutputIndex) + { + pnAdapterIndex = 0; + pnAdapterOutputIndex = 0; + FnTable.GetDXGIOutputInfo(ref pnAdapterIndex, ref pnAdapterOutputIndex); + } + } + + + public class CVRTrackedCamera + { + IVRTrackedCamera FnTable; + internal CVRTrackedCamera(IntPtr pInterface) + { + FnTable = (IVRTrackedCamera)Marshal.PtrToStructure(pInterface, typeof(IVRTrackedCamera)); + } + public string GetCameraErrorNameFromEnum(EVRTrackedCameraError eCameraError) + { + IntPtr result = FnTable.GetCameraErrorNameFromEnum(eCameraError); + return Marshal.PtrToStringAnsi(result); + } + public EVRTrackedCameraError HasCamera(uint nDeviceIndex, ref bool pHasCamera) + { + pHasCamera = false; + EVRTrackedCameraError result = FnTable.HasCamera(nDeviceIndex, ref pHasCamera); + return result; + } + public EVRTrackedCameraError GetCameraFrameSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref uint pnWidth, ref uint pnHeight, ref uint pnFrameBufferSize) + { + pnWidth = 0; + pnHeight = 0; + pnFrameBufferSize = 0; + EVRTrackedCameraError result = FnTable.GetCameraFrameSize(nDeviceIndex, eFrameType, ref pnWidth, ref pnHeight, ref pnFrameBufferSize); + return result; + } + public EVRTrackedCameraError GetCameraIntrinsics(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, ref HmdVector2_t pFocalLength, ref HmdVector2_t pCenter) + { + EVRTrackedCameraError result = FnTable.GetCameraIntrinsics(nDeviceIndex, nCameraIndex, eFrameType, ref pFocalLength, ref pCenter); + return result; + } + public EVRTrackedCameraError GetCameraProjection(uint nDeviceIndex, uint nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, ref HmdMatrix44_t pProjection) + { + EVRTrackedCameraError result = FnTable.GetCameraProjection(nDeviceIndex, nCameraIndex, eFrameType, flZNear, flZFar, ref pProjection); + return result; + } + public EVRTrackedCameraError AcquireVideoStreamingService(uint nDeviceIndex, ref ulong pHandle) + { + pHandle = 0; + EVRTrackedCameraError result = FnTable.AcquireVideoStreamingService(nDeviceIndex, ref pHandle); + return result; + } + public EVRTrackedCameraError ReleaseVideoStreamingService(ulong hTrackedCamera) + { + EVRTrackedCameraError result = FnTable.ReleaseVideoStreamingService(hTrackedCamera); + return result; + } + public EVRTrackedCameraError GetVideoStreamFrameBuffer(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pFrameBuffer, uint nFrameBufferSize, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize) + { + EVRTrackedCameraError result = FnTable.GetVideoStreamFrameBuffer(hTrackedCamera, eFrameType, pFrameBuffer, nFrameBufferSize, ref pFrameHeader, nFrameHeaderSize); + return result; + } + public EVRTrackedCameraError GetVideoStreamTextureSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref VRTextureBounds_t pTextureBounds, ref uint pnWidth, ref uint pnHeight) + { + pnWidth = 0; + pnHeight = 0; + EVRTrackedCameraError result = FnTable.GetVideoStreamTextureSize(nDeviceIndex, eFrameType, ref pTextureBounds, ref pnWidth, ref pnHeight); + return result; + } + public EVRTrackedCameraError GetVideoStreamTextureD3D11(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize) + { + EVRTrackedCameraError result = FnTable.GetVideoStreamTextureD3D11(hTrackedCamera, eFrameType, pD3D11DeviceOrResource, ref ppD3D11ShaderResourceView, ref pFrameHeader, nFrameHeaderSize); + return result; + } + public EVRTrackedCameraError GetVideoStreamTextureGL(ulong hTrackedCamera, EVRTrackedCameraFrameType eFrameType, ref uint pglTextureId, ref CameraVideoStreamFrameHeader_t pFrameHeader, uint nFrameHeaderSize) + { + pglTextureId = 0; + EVRTrackedCameraError result = FnTable.GetVideoStreamTextureGL(hTrackedCamera, eFrameType, ref pglTextureId, ref pFrameHeader, nFrameHeaderSize); + return result; + } + public EVRTrackedCameraError ReleaseVideoStreamTextureGL(ulong hTrackedCamera, uint glTextureId) + { + EVRTrackedCameraError result = FnTable.ReleaseVideoStreamTextureGL(hTrackedCamera, glTextureId); + return result; + } + public void SetCameraTrackingSpace(ETrackingUniverseOrigin eUniverse) + { + FnTable.SetCameraTrackingSpace(eUniverse); + } + public ETrackingUniverseOrigin GetCameraTrackingSpace() + { + ETrackingUniverseOrigin result = FnTable.GetCameraTrackingSpace(); + return result; + } + } + + + public class CVRApplications + { + IVRApplications FnTable; + internal CVRApplications(IntPtr pInterface) + { + FnTable = (IVRApplications)Marshal.PtrToStructure(pInterface, typeof(IVRApplications)); + } + public EVRApplicationError AddApplicationManifest(string pchApplicationManifestFullPath, bool bTemporary) + { + IntPtr pchApplicationManifestFullPathUtf8 = Utils.ToUtf8(pchApplicationManifestFullPath); + EVRApplicationError result = FnTable.AddApplicationManifest(pchApplicationManifestFullPathUtf8, bTemporary); + Marshal.FreeHGlobal(pchApplicationManifestFullPathUtf8); + return result; + } + public EVRApplicationError RemoveApplicationManifest(string pchApplicationManifestFullPath) + { + IntPtr pchApplicationManifestFullPathUtf8 = Utils.ToUtf8(pchApplicationManifestFullPath); + EVRApplicationError result = FnTable.RemoveApplicationManifest(pchApplicationManifestFullPathUtf8); + Marshal.FreeHGlobal(pchApplicationManifestFullPathUtf8); + return result; + } + public bool IsApplicationInstalled(string pchAppKey) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + bool result = FnTable.IsApplicationInstalled(pchAppKeyUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public uint GetApplicationCount() + { + uint result = FnTable.GetApplicationCount(); + return result; + } + public EVRApplicationError GetApplicationKeyByIndex(uint unApplicationIndex, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetApplicationKeyByIndex(unApplicationIndex, pchAppKeyBuffer, unAppKeyBufferLen); + return result; + } + public EVRApplicationError GetApplicationKeyByProcessId(uint unProcessId, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetApplicationKeyByProcessId(unProcessId, pchAppKeyBuffer, unAppKeyBufferLen); + return result; + } + public EVRApplicationError LaunchApplication(string pchAppKey) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + EVRApplicationError result = FnTable.LaunchApplication(pchAppKeyUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public EVRApplicationError LaunchTemplateApplication(string pchTemplateAppKey, string pchNewAppKey, AppOverrideKeys_t[] pKeys) + { + IntPtr pchTemplateAppKeyUtf8 = Utils.ToUtf8(pchTemplateAppKey); + IntPtr pchNewAppKeyUtf8 = Utils.ToUtf8(pchNewAppKey); + EVRApplicationError result = FnTable.LaunchTemplateApplication(pchTemplateAppKeyUtf8, pchNewAppKeyUtf8, pKeys, (uint)pKeys.Length); + Marshal.FreeHGlobal(pchTemplateAppKeyUtf8); + Marshal.FreeHGlobal(pchNewAppKeyUtf8); + return result; + } + public EVRApplicationError LaunchApplicationFromMimeType(string pchMimeType, string pchArgs) + { + IntPtr pchMimeTypeUtf8 = Utils.ToUtf8(pchMimeType); + IntPtr pchArgsUtf8 = Utils.ToUtf8(pchArgs); + EVRApplicationError result = FnTable.LaunchApplicationFromMimeType(pchMimeTypeUtf8, pchArgsUtf8); + Marshal.FreeHGlobal(pchMimeTypeUtf8); + Marshal.FreeHGlobal(pchArgsUtf8); + return result; + } + public EVRApplicationError LaunchDashboardOverlay(string pchAppKey) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + EVRApplicationError result = FnTable.LaunchDashboardOverlay(pchAppKeyUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public bool CancelApplicationLaunch(string pchAppKey) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + bool result = FnTable.CancelApplicationLaunch(pchAppKeyUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public EVRApplicationError IdentifyApplication(uint unProcessId, string pchAppKey) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + EVRApplicationError result = FnTable.IdentifyApplication(unProcessId, pchAppKeyUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public uint GetApplicationProcessId(string pchAppKey) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + uint result = FnTable.GetApplicationProcessId(pchAppKeyUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public string GetApplicationsErrorNameFromEnum(EVRApplicationError error) + { + IntPtr result = FnTable.GetApplicationsErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public uint GetApplicationPropertyString(string pchAppKey, EVRApplicationProperty eProperty, System.Text.StringBuilder pchPropertyValueBuffer, uint unPropertyValueBufferLen, ref EVRApplicationError peError) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + uint result = FnTable.GetApplicationPropertyString(pchAppKeyUtf8, eProperty, pchPropertyValueBuffer, unPropertyValueBufferLen, ref peError); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public bool GetApplicationPropertyBool(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + bool result = FnTable.GetApplicationPropertyBool(pchAppKeyUtf8, eProperty, ref peError); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public ulong GetApplicationPropertyUint64(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + ulong result = FnTable.GetApplicationPropertyUint64(pchAppKeyUtf8, eProperty, ref peError); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public EVRApplicationError SetApplicationAutoLaunch(string pchAppKey, bool bAutoLaunch) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + EVRApplicationError result = FnTable.SetApplicationAutoLaunch(pchAppKeyUtf8, bAutoLaunch); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public bool GetApplicationAutoLaunch(string pchAppKey) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + bool result = FnTable.GetApplicationAutoLaunch(pchAppKeyUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public EVRApplicationError SetDefaultApplicationForMimeType(string pchAppKey, string pchMimeType) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + IntPtr pchMimeTypeUtf8 = Utils.ToUtf8(pchMimeType); + EVRApplicationError result = FnTable.SetDefaultApplicationForMimeType(pchAppKeyUtf8, pchMimeTypeUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + Marshal.FreeHGlobal(pchMimeTypeUtf8); + return result; + } + public bool GetDefaultApplicationForMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen) + { + IntPtr pchMimeTypeUtf8 = Utils.ToUtf8(pchMimeType); + bool result = FnTable.GetDefaultApplicationForMimeType(pchMimeTypeUtf8, pchAppKeyBuffer, unAppKeyBufferLen); + Marshal.FreeHGlobal(pchMimeTypeUtf8); + return result; + } + public bool GetApplicationSupportedMimeTypes(string pchAppKey, System.Text.StringBuilder pchMimeTypesBuffer, uint unMimeTypesBuffer) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + bool result = FnTable.GetApplicationSupportedMimeTypes(pchAppKeyUtf8, pchMimeTypesBuffer, unMimeTypesBuffer); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public uint GetApplicationsThatSupportMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer) + { + IntPtr pchMimeTypeUtf8 = Utils.ToUtf8(pchMimeType); + uint result = FnTable.GetApplicationsThatSupportMimeType(pchMimeTypeUtf8, pchAppKeysThatSupportBuffer, unAppKeysThatSupportBuffer); + Marshal.FreeHGlobal(pchMimeTypeUtf8); + return result; + } + public uint GetApplicationLaunchArguments(uint unHandle, System.Text.StringBuilder pchArgs, uint unArgs) + { + uint result = FnTable.GetApplicationLaunchArguments(unHandle, pchArgs, unArgs); + return result; + } + public EVRApplicationError GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetStartingApplication(pchAppKeyBuffer, unAppKeyBufferLen); + return result; + } + public EVRSceneApplicationState GetSceneApplicationState() + { + EVRSceneApplicationState result = FnTable.GetSceneApplicationState(); + return result; + } + public EVRApplicationError PerformApplicationPrelaunchCheck(string pchAppKey) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + EVRApplicationError result = FnTable.PerformApplicationPrelaunchCheck(pchAppKeyUtf8); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public string GetSceneApplicationStateNameFromEnum(EVRSceneApplicationState state) + { + IntPtr result = FnTable.GetSceneApplicationStateNameFromEnum(state); + return Marshal.PtrToStringAnsi(result); + } + public EVRApplicationError LaunchInternalProcess(string pchBinaryPath, string pchArguments, string pchWorkingDirectory) + { + IntPtr pchBinaryPathUtf8 = Utils.ToUtf8(pchBinaryPath); + IntPtr pchArgumentsUtf8 = Utils.ToUtf8(pchArguments); + IntPtr pchWorkingDirectoryUtf8 = Utils.ToUtf8(pchWorkingDirectory); + EVRApplicationError result = FnTable.LaunchInternalProcess(pchBinaryPathUtf8, pchArgumentsUtf8, pchWorkingDirectoryUtf8); + Marshal.FreeHGlobal(pchBinaryPathUtf8); + Marshal.FreeHGlobal(pchArgumentsUtf8); + Marshal.FreeHGlobal(pchWorkingDirectoryUtf8); + return result; + } + public uint GetCurrentSceneProcessId() + { + uint result = FnTable.GetCurrentSceneProcessId(); + return result; + } + } + + + public class CVRChaperone + { + IVRChaperone FnTable; + internal CVRChaperone(IntPtr pInterface) + { + FnTable = (IVRChaperone)Marshal.PtrToStructure(pInterface, typeof(IVRChaperone)); + } + public ChaperoneCalibrationState GetCalibrationState() + { + ChaperoneCalibrationState result = FnTable.GetCalibrationState(); + return result; + } + public bool GetPlayAreaSize(ref float pSizeX, ref float pSizeZ) + { + pSizeX = 0; + pSizeZ = 0; + bool result = FnTable.GetPlayAreaSize(ref pSizeX, ref pSizeZ); + return result; + } + public bool GetPlayAreaRect(ref HmdQuad_t rect) + { + bool result = FnTable.GetPlayAreaRect(ref rect); + return result; + } + public void ReloadInfo() + { + FnTable.ReloadInfo(); + } + public void SetSceneColor(HmdColor_t color) + { + FnTable.SetSceneColor(color); + } + public void GetBoundsColor(ref HmdColor_t pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, ref HmdColor_t pOutputCameraColor) + { + FnTable.GetBoundsColor(ref pOutputColorArray, nNumOutputColors, flCollisionBoundsFadeDistance, ref pOutputCameraColor); + } + public bool AreBoundsVisible() + { + bool result = FnTable.AreBoundsVisible(); + return result; + } + public void ForceBoundsVisible(bool bForce) + { + FnTable.ForceBoundsVisible(bForce); + } + public void ResetZeroPose(ETrackingUniverseOrigin eTrackingUniverseOrigin) + { + FnTable.ResetZeroPose(eTrackingUniverseOrigin); + } + } + + + public class CVRChaperoneSetup + { + IVRChaperoneSetup FnTable; + internal CVRChaperoneSetup(IntPtr pInterface) + { + FnTable = (IVRChaperoneSetup)Marshal.PtrToStructure(pInterface, typeof(IVRChaperoneSetup)); + } + public bool CommitWorkingCopy(EChaperoneConfigFile configFile) + { + bool result = FnTable.CommitWorkingCopy(configFile); + return result; + } + public void RevertWorkingCopy() + { + FnTable.RevertWorkingCopy(); + } + public bool GetWorkingPlayAreaSize(ref float pSizeX, ref float pSizeZ) + { + pSizeX = 0; + pSizeZ = 0; + bool result = FnTable.GetWorkingPlayAreaSize(ref pSizeX, ref pSizeZ); + return result; + } + public bool GetWorkingPlayAreaRect(ref HmdQuad_t rect) + { + bool result = FnTable.GetWorkingPlayAreaRect(ref rect); + return result; + } + public bool GetWorkingCollisionBoundsInfo(out HmdQuad_t[] pQuadsBuffer) + { + uint punQuadsCount = 0; + bool result = FnTable.GetWorkingCollisionBoundsInfo(null, ref punQuadsCount); + pQuadsBuffer = new HmdQuad_t[punQuadsCount]; + result = FnTable.GetWorkingCollisionBoundsInfo(pQuadsBuffer, ref punQuadsCount); + return result; + } + public bool GetLiveCollisionBoundsInfo(out HmdQuad_t[] pQuadsBuffer) + { + uint punQuadsCount = 0; + bool result = FnTable.GetLiveCollisionBoundsInfo(null, ref punQuadsCount); + pQuadsBuffer = new HmdQuad_t[punQuadsCount]; + result = FnTable.GetLiveCollisionBoundsInfo(pQuadsBuffer, ref punQuadsCount); + return result; + } + public bool GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetWorkingSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); + return result; + } + public bool GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetWorkingStandingZeroPoseToRawTrackingPose(ref pmatStandingZeroPoseToRawTrackingPose); + return result; + } + public void SetWorkingPlayAreaSize(float sizeX, float sizeZ) + { + FnTable.SetWorkingPlayAreaSize(sizeX, sizeZ); + } + public void SetWorkingCollisionBoundsInfo(HmdQuad_t[] pQuadsBuffer) + { + FnTable.SetWorkingCollisionBoundsInfo(pQuadsBuffer, (uint)pQuadsBuffer.Length); + } + public void SetWorkingPerimeter(HmdVector2_t[] pPointBuffer) + { + FnTable.SetWorkingPerimeter(pPointBuffer, (uint)pPointBuffer.Length); + } + public void SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose) + { + FnTable.SetWorkingSeatedZeroPoseToRawTrackingPose(ref pMatSeatedZeroPoseToRawTrackingPose); + } + public void SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose) + { + FnTable.SetWorkingStandingZeroPoseToRawTrackingPose(ref pMatStandingZeroPoseToRawTrackingPose); + } + public void ReloadFromDisk(EChaperoneConfigFile configFile) + { + FnTable.ReloadFromDisk(configFile); + } + public bool GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetLiveSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); + return result; + } + public bool ExportLiveToBuffer(System.Text.StringBuilder pBuffer, ref uint pnBufferLength) + { + pnBufferLength = 0; + bool result = FnTable.ExportLiveToBuffer(pBuffer, ref pnBufferLength); + return result; + } + public bool ImportFromBufferToWorking(string pBuffer, uint nImportFlags) + { + IntPtr pBufferUtf8 = Utils.ToUtf8(pBuffer); + bool result = FnTable.ImportFromBufferToWorking(pBufferUtf8, nImportFlags); + Marshal.FreeHGlobal(pBufferUtf8); + return result; + } + public void ShowWorkingSetPreview() + { + FnTable.ShowWorkingSetPreview(); + } + public void HideWorkingSetPreview() + { + FnTable.HideWorkingSetPreview(); + } + public void RoomSetupStarting() + { + FnTable.RoomSetupStarting(); + } + } + + + public class CVRCompositor + { + IVRCompositor FnTable; + internal CVRCompositor(IntPtr pInterface) + { + FnTable = (IVRCompositor)Marshal.PtrToStructure(pInterface, typeof(IVRCompositor)); + } + public void SetTrackingSpace(ETrackingUniverseOrigin eOrigin) + { + FnTable.SetTrackingSpace(eOrigin); + } + public ETrackingUniverseOrigin GetTrackingSpace() + { + ETrackingUniverseOrigin result = FnTable.GetTrackingSpace(); + return result; + } + public EVRCompositorError WaitGetPoses(TrackedDevicePose_t[] pRenderPoseArray, TrackedDevicePose_t[] pGamePoseArray) + { + EVRCompositorError result = FnTable.WaitGetPoses(pRenderPoseArray, (uint)pRenderPoseArray.Length, pGamePoseArray, (uint)pGamePoseArray.Length); + return result; + } + public EVRCompositorError GetLastPoses(TrackedDevicePose_t[] pRenderPoseArray, TrackedDevicePose_t[] pGamePoseArray) + { + EVRCompositorError result = FnTable.GetLastPoses(pRenderPoseArray, (uint)pRenderPoseArray.Length, pGamePoseArray, (uint)pGamePoseArray.Length); + return result; + } + public EVRCompositorError GetLastPoseForTrackedDeviceIndex(uint unDeviceIndex, ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pOutputGamePose) + { + EVRCompositorError result = FnTable.GetLastPoseForTrackedDeviceIndex(unDeviceIndex, ref pOutputPose, ref pOutputGamePose); + return result; + } + public EVRCompositorError Submit(EVREye eEye, ref Texture_t pTexture, ref VRTextureBounds_t pBounds, EVRSubmitFlags nSubmitFlags) + { + EVRCompositorError result = FnTable.Submit(eEye, ref pTexture, ref pBounds, nSubmitFlags); + return result; + } + public void ClearLastSubmittedFrame() + { + FnTable.ClearLastSubmittedFrame(); + } + public void PostPresentHandoff() + { + FnTable.PostPresentHandoff(); + } + public bool GetFrameTiming(ref Compositor_FrameTiming pTiming, uint unFramesAgo) + { + bool result = FnTable.GetFrameTiming(ref pTiming, unFramesAgo); + return result; + } + public uint GetFrameTimings(Compositor_FrameTiming[] pTiming) + { + uint result = FnTable.GetFrameTimings(pTiming, (uint)pTiming.Length); + return result; + } + public float GetFrameTimeRemaining() + { + float result = FnTable.GetFrameTimeRemaining(); + return result; + } + public void GetCumulativeStats(ref Compositor_CumulativeStats pStats, uint nStatsSizeInBytes) + { + FnTable.GetCumulativeStats(ref pStats, nStatsSizeInBytes); + } + public void FadeToColor(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground) + { + FnTable.FadeToColor(fSeconds, fRed, fGreen, fBlue, fAlpha, bBackground); + } + public HmdColor_t GetCurrentFadeColor(bool bBackground) + { + HmdColor_t result = FnTable.GetCurrentFadeColor(bBackground); + return result; + } + public void FadeGrid(float fSeconds, bool bFadeGridIn) + { + FnTable.FadeGrid(fSeconds, bFadeGridIn); + } + public float GetCurrentGridAlpha() + { + float result = FnTable.GetCurrentGridAlpha(); + return result; + } + public EVRCompositorError SetSkyboxOverride(Texture_t[] pTextures) + { + EVRCompositorError result = FnTable.SetSkyboxOverride(pTextures, (uint)pTextures.Length); + return result; + } + public void ClearSkyboxOverride() + { + FnTable.ClearSkyboxOverride(); + } + public void CompositorBringToFront() + { + FnTable.CompositorBringToFront(); + } + public void CompositorGoToBack() + { + FnTable.CompositorGoToBack(); + } + public void CompositorQuit() + { + FnTable.CompositorQuit(); + } + public bool IsFullscreen() + { + bool result = FnTable.IsFullscreen(); + return result; + } + public uint GetCurrentSceneFocusProcess() + { + uint result = FnTable.GetCurrentSceneFocusProcess(); + return result; + } + public uint GetLastFrameRenderer() + { + uint result = FnTable.GetLastFrameRenderer(); + return result; + } + public bool CanRenderScene() + { + bool result = FnTable.CanRenderScene(); + return result; + } + public void ShowMirrorWindow() + { + FnTable.ShowMirrorWindow(); + } + public void HideMirrorWindow() + { + FnTable.HideMirrorWindow(); + } + public bool IsMirrorWindowVisible() + { + bool result = FnTable.IsMirrorWindowVisible(); + return result; + } + public void CompositorDumpImages() + { + FnTable.CompositorDumpImages(); + } + public bool ShouldAppRenderWithLowResources() + { + bool result = FnTable.ShouldAppRenderWithLowResources(); + return result; + } + public void ForceInterleavedReprojectionOn(bool bOverride) + { + FnTable.ForceInterleavedReprojectionOn(bOverride); + } + public void ForceReconnectProcess() + { + FnTable.ForceReconnectProcess(); + } + public void SuspendRendering(bool bSuspend) + { + FnTable.SuspendRendering(bSuspend); + } + public EVRCompositorError GetMirrorTextureD3D11(EVREye eEye, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView) + { + EVRCompositorError result = FnTable.GetMirrorTextureD3D11(eEye, pD3D11DeviceOrResource, ref ppD3D11ShaderResourceView); + return result; + } + public void ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView) + { + FnTable.ReleaseMirrorTextureD3D11(pD3D11ShaderResourceView); + } + public EVRCompositorError GetMirrorTextureGL(EVREye eEye, ref uint pglTextureId, IntPtr pglSharedTextureHandle) + { + pglTextureId = 0; + EVRCompositorError result = FnTable.GetMirrorTextureGL(eEye, ref pglTextureId, pglSharedTextureHandle); + return result; + } + public bool ReleaseSharedGLTexture(uint glTextureId, IntPtr glSharedTextureHandle) + { + bool result = FnTable.ReleaseSharedGLTexture(glTextureId, glSharedTextureHandle); + return result; + } + public void LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle) + { + FnTable.LockGLSharedTextureForAccess(glSharedTextureHandle); + } + public void UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle) + { + FnTable.UnlockGLSharedTextureForAccess(glSharedTextureHandle); + } + public uint GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue, uint unBufferSize) + { + uint result = FnTable.GetVulkanInstanceExtensionsRequired(pchValue, unBufferSize); + return result; + } + public uint GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice, System.Text.StringBuilder pchValue, uint unBufferSize) + { + uint result = FnTable.GetVulkanDeviceExtensionsRequired(pPhysicalDevice, pchValue, unBufferSize); + return result; + } + public void SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode) + { + FnTable.SetExplicitTimingMode(eTimingMode); + } + public EVRCompositorError SubmitExplicitTimingData() + { + EVRCompositorError result = FnTable.SubmitExplicitTimingData(); + return result; + } + public bool IsMotionSmoothingEnabled() + { + bool result = FnTable.IsMotionSmoothingEnabled(); + return result; + } + public bool IsMotionSmoothingSupported() + { + bool result = FnTable.IsMotionSmoothingSupported(); + return result; + } + public bool IsCurrentSceneFocusAppLoading() + { + bool result = FnTable.IsCurrentSceneFocusAppLoading(); + return result; + } + public EVRCompositorError SetStageOverride_Async(string pchRenderModelPath, ref HmdMatrix34_t pTransform, ref Compositor_StageRenderSettings pRenderSettings, uint nSizeOfRenderSettings) + { + IntPtr pchRenderModelPathUtf8 = Utils.ToUtf8(pchRenderModelPath); + EVRCompositorError result = FnTable.SetStageOverride_Async(pchRenderModelPathUtf8, ref pTransform, ref pRenderSettings, nSizeOfRenderSettings); + Marshal.FreeHGlobal(pchRenderModelPathUtf8); + return result; + } + public void ClearStageOverride() + { + FnTable.ClearStageOverride(); + } + public bool GetCompositorBenchmarkResults(ref Compositor_BenchmarkResults pBenchmarkResults, uint nSizeOfBenchmarkResults) + { + bool result = FnTable.GetCompositorBenchmarkResults(ref pBenchmarkResults, nSizeOfBenchmarkResults); + return result; + } + public EVRCompositorError GetLastPosePredictionIDs(ref uint pRenderPosePredictionID, ref uint pGamePosePredictionID) + { + pRenderPosePredictionID = 0; + pGamePosePredictionID = 0; + EVRCompositorError result = FnTable.GetLastPosePredictionIDs(ref pRenderPosePredictionID, ref pGamePosePredictionID); + return result; + } + public EVRCompositorError GetPosesForFrame(uint unPosePredictionID, TrackedDevicePose_t[] pPoseArray) + { + EVRCompositorError result = FnTable.GetPosesForFrame(unPosePredictionID, pPoseArray, (uint)pPoseArray.Length); + return result; + } + } + + + public class CVROverlay + { + IVROverlay FnTable; + internal CVROverlay(IntPtr pInterface) + { + FnTable = (IVROverlay)Marshal.PtrToStructure(pInterface, typeof(IVROverlay)); + } + public EVROverlayError FindOverlay(string pchOverlayKey, ref ulong pOverlayHandle) + { + IntPtr pchOverlayKeyUtf8 = Utils.ToUtf8(pchOverlayKey); + pOverlayHandle = 0; + EVROverlayError result = FnTable.FindOverlay(pchOverlayKeyUtf8, ref pOverlayHandle); + Marshal.FreeHGlobal(pchOverlayKeyUtf8); + return result; + } + public EVROverlayError CreateOverlay(string pchOverlayKey, string pchOverlayName, ref ulong pOverlayHandle) + { + IntPtr pchOverlayKeyUtf8 = Utils.ToUtf8(pchOverlayKey); + IntPtr pchOverlayNameUtf8 = Utils.ToUtf8(pchOverlayName); + pOverlayHandle = 0; + EVROverlayError result = FnTable.CreateOverlay(pchOverlayKeyUtf8, pchOverlayNameUtf8, ref pOverlayHandle); + Marshal.FreeHGlobal(pchOverlayKeyUtf8); + Marshal.FreeHGlobal(pchOverlayNameUtf8); + return result; + } + public EVROverlayError DestroyOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.DestroyOverlay(ulOverlayHandle); + return result; + } + public uint GetOverlayKey(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayKey(ulOverlayHandle, pchValue, unBufferSize, ref pError); + return result; + } + public uint GetOverlayName(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayName(ulOverlayHandle, pchValue, unBufferSize, ref pError); + return result; + } + public EVROverlayError SetOverlayName(ulong ulOverlayHandle, string pchName) + { + IntPtr pchNameUtf8 = Utils.ToUtf8(pchName); + EVROverlayError result = FnTable.SetOverlayName(ulOverlayHandle, pchNameUtf8); + Marshal.FreeHGlobal(pchNameUtf8); + return result; + } + public EVROverlayError GetOverlayImageData(ulong ulOverlayHandle, IntPtr pvBuffer, uint unBufferSize, ref uint punWidth, ref uint punHeight) + { + punWidth = 0; + punHeight = 0; + EVROverlayError result = FnTable.GetOverlayImageData(ulOverlayHandle, pvBuffer, unBufferSize, ref punWidth, ref punHeight); + return result; + } + public string GetOverlayErrorNameFromEnum(EVROverlayError error) + { + IntPtr result = FnTable.GetOverlayErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public EVROverlayError SetOverlayRenderingPid(ulong ulOverlayHandle, uint unPID) + { + EVROverlayError result = FnTable.SetOverlayRenderingPid(ulOverlayHandle, unPID); + return result; + } + public uint GetOverlayRenderingPid(ulong ulOverlayHandle) + { + uint result = FnTable.GetOverlayRenderingPid(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled) + { + EVROverlayError result = FnTable.SetOverlayFlag(ulOverlayHandle, eOverlayFlag, bEnabled); + return result; + } + public EVROverlayError GetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, ref bool pbEnabled) + { + pbEnabled = false; + EVROverlayError result = FnTable.GetOverlayFlag(ulOverlayHandle, eOverlayFlag, ref pbEnabled); + return result; + } + public EVROverlayError GetOverlayFlags(ulong ulOverlayHandle, ref uint pFlags) + { + pFlags = 0; + EVROverlayError result = FnTable.GetOverlayFlags(ulOverlayHandle, ref pFlags); + return result; + } + public EVROverlayError SetOverlayColor(ulong ulOverlayHandle, float fRed, float fGreen, float fBlue) + { + EVROverlayError result = FnTable.SetOverlayColor(ulOverlayHandle, fRed, fGreen, fBlue); + return result; + } + public EVROverlayError GetOverlayColor(ulong ulOverlayHandle, ref float pfRed, ref float pfGreen, ref float pfBlue) + { + pfRed = 0; + pfGreen = 0; + pfBlue = 0; + EVROverlayError result = FnTable.GetOverlayColor(ulOverlayHandle, ref pfRed, ref pfGreen, ref pfBlue); + return result; + } + public EVROverlayError SetOverlayAlpha(ulong ulOverlayHandle, float fAlpha) + { + EVROverlayError result = FnTable.SetOverlayAlpha(ulOverlayHandle, fAlpha); + return result; + } + public EVROverlayError GetOverlayAlpha(ulong ulOverlayHandle, ref float pfAlpha) + { + pfAlpha = 0; + EVROverlayError result = FnTable.GetOverlayAlpha(ulOverlayHandle, ref pfAlpha); + return result; + } + public EVROverlayError SetOverlayTexelAspect(ulong ulOverlayHandle, float fTexelAspect) + { + EVROverlayError result = FnTable.SetOverlayTexelAspect(ulOverlayHandle, fTexelAspect); + return result; + } + public EVROverlayError GetOverlayTexelAspect(ulong ulOverlayHandle, ref float pfTexelAspect) + { + pfTexelAspect = 0; + EVROverlayError result = FnTable.GetOverlayTexelAspect(ulOverlayHandle, ref pfTexelAspect); + return result; + } + public EVROverlayError SetOverlaySortOrder(ulong ulOverlayHandle, uint unSortOrder) + { + EVROverlayError result = FnTable.SetOverlaySortOrder(ulOverlayHandle, unSortOrder); + return result; + } + public EVROverlayError GetOverlaySortOrder(ulong ulOverlayHandle, ref uint punSortOrder) + { + punSortOrder = 0; + EVROverlayError result = FnTable.GetOverlaySortOrder(ulOverlayHandle, ref punSortOrder); + return result; + } + public EVROverlayError SetOverlayWidthInMeters(ulong ulOverlayHandle, float fWidthInMeters) + { + EVROverlayError result = FnTable.SetOverlayWidthInMeters(ulOverlayHandle, fWidthInMeters); + return result; + } + public EVROverlayError GetOverlayWidthInMeters(ulong ulOverlayHandle, ref float pfWidthInMeters) + { + pfWidthInMeters = 0; + EVROverlayError result = FnTable.GetOverlayWidthInMeters(ulOverlayHandle, ref pfWidthInMeters); + return result; + } + public EVROverlayError SetOverlayCurvature(ulong ulOverlayHandle, float fCurvature) + { + EVROverlayError result = FnTable.SetOverlayCurvature(ulOverlayHandle, fCurvature); + return result; + } + public EVROverlayError GetOverlayCurvature(ulong ulOverlayHandle, ref float pfCurvature) + { + pfCurvature = 0; + EVROverlayError result = FnTable.GetOverlayCurvature(ulOverlayHandle, ref pfCurvature); + return result; + } + public EVROverlayError SetOverlayTextureColorSpace(ulong ulOverlayHandle, EColorSpace eTextureColorSpace) + { + EVROverlayError result = FnTable.SetOverlayTextureColorSpace(ulOverlayHandle, eTextureColorSpace); + return result; + } + public EVROverlayError GetOverlayTextureColorSpace(ulong ulOverlayHandle, ref EColorSpace peTextureColorSpace) + { + EVROverlayError result = FnTable.GetOverlayTextureColorSpace(ulOverlayHandle, ref peTextureColorSpace); + return result; + } + public EVROverlayError SetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds) + { + EVROverlayError result = FnTable.SetOverlayTextureBounds(ulOverlayHandle, ref pOverlayTextureBounds); + return result; + } + public EVROverlayError GetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds) + { + EVROverlayError result = FnTable.GetOverlayTextureBounds(ulOverlayHandle, ref pOverlayTextureBounds); + return result; + } + public EVROverlayError GetOverlayTransformType(ulong ulOverlayHandle, ref VROverlayTransformType peTransformType) + { + EVROverlayError result = FnTable.GetOverlayTransformType(ulOverlayHandle, ref peTransformType); + return result; + } + public EVROverlayError SetOverlayTransformAbsolute(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformAbsolute(ulOverlayHandle, eTrackingOrigin, ref pmatTrackingOriginToOverlayTransform); + return result; + } + public EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) + { + EVROverlayError result = FnTable.GetOverlayTransformAbsolute(ulOverlayHandle, ref peTrackingOrigin, ref pmatTrackingOriginToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, uint unTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceRelative(ulOverlayHandle, unTrackedDevice, ref pmatTrackedDeviceToOverlayTransform); + return result; + } + public EVROverlayError GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, ref uint punTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform) + { + punTrackedDevice = 0; + EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceRelative(ulOverlayHandle, ref punTrackedDevice, ref pmatTrackedDeviceToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, string pchComponentName) + { + IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName); + EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle, unDeviceIndex, pchComponentNameUtf8); + Marshal.FreeHGlobal(pchComponentNameUtf8); + return result; + } + public EVROverlayError GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, ref uint punDeviceIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameSize) + { + punDeviceIndex = 0; + EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceComponent(ulOverlayHandle, ref punDeviceIndex, pchComponentName, unComponentNameSize); + return result; + } + public EVROverlayError GetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ref ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform) + { + ulOverlayHandleParent = 0; + EVROverlayError result = FnTable.GetOverlayTransformOverlayRelative(ulOverlayHandle, ref ulOverlayHandleParent, ref pmatParentOverlayToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformOverlayRelative(ulOverlayHandle, ulOverlayHandleParent, ref pmatParentOverlayToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformCursor(ulong ulCursorOverlayHandle, ref HmdVector2_t pvHotspot) + { + EVROverlayError result = FnTable.SetOverlayTransformCursor(ulCursorOverlayHandle, ref pvHotspot); + return result; + } + public EVROverlayError GetOverlayTransformCursor(ulong ulOverlayHandle, ref HmdVector2_t pvHotspot) + { + EVROverlayError result = FnTable.GetOverlayTransformCursor(ulOverlayHandle, ref pvHotspot); + return result; + } + public EVROverlayError SetOverlayTransformProjection(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform, ref VROverlayProjection_t pProjection, EVREye eEye) + { + EVROverlayError result = FnTable.SetOverlayTransformProjection(ulOverlayHandle, eTrackingOrigin, ref pmatTrackingOriginToOverlayTransform, ref pProjection, eEye); + return result; + } + public EVROverlayError ShowOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ShowOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError HideOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.HideOverlay(ulOverlayHandle); + return result; + } + public bool IsOverlayVisible(ulong ulOverlayHandle) + { + bool result = FnTable.IsOverlayVisible(ulOverlayHandle); + return result; + } + public EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform) + { + EVROverlayError result = FnTable.GetTransformForOverlayCoordinates(ulOverlayHandle, eTrackingOrigin, coordinatesInOverlay, ref pmatTransform); + return result; + } + // This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were + // originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextOverlayEventPacked(ulong ulOverlayHandle, ref VREvent_t_Packed pEvent, uint uncbVREvent); + [StructLayout(LayoutKind.Explicit)] + struct PollNextOverlayEventUnion + { + [FieldOffset(0)] + public IVROverlay._PollNextOverlayEvent pPollNextOverlayEvent; + [FieldOffset(0)] + public _PollNextOverlayEventPacked pPollNextOverlayEventPacked; + } + public bool PollNextOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pEvent, uint uncbVREvent) + { +#if !UNITY_METRO + if (Environment.OSVersion.Platform == PlatformID.MacOSX || + Environment.OSVersion.Platform == 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)Marshal.SizeOf(typeof(VREvent_t_Packed))); + + event_packed.Unpack(ref pEvent); + return packed_result; + } +#endif + bool result = FnTable.PollNextOverlayEvent(ulOverlayHandle, ref pEvent, uncbVREvent); + return result; + } + public EVROverlayError GetOverlayInputMethod(ulong ulOverlayHandle, ref VROverlayInputMethod peInputMethod) + { + EVROverlayError result = FnTable.GetOverlayInputMethod(ulOverlayHandle, ref peInputMethod); + return result; + } + public EVROverlayError SetOverlayInputMethod(ulong ulOverlayHandle, VROverlayInputMethod eInputMethod) + { + EVROverlayError result = FnTable.SetOverlayInputMethod(ulOverlayHandle, eInputMethod); + return result; + } + public EVROverlayError GetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale) + { + EVROverlayError result = FnTable.GetOverlayMouseScale(ulOverlayHandle, ref pvecMouseScale); + return result; + } + public EVROverlayError SetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale) + { + EVROverlayError result = FnTable.SetOverlayMouseScale(ulOverlayHandle, ref pvecMouseScale); + return result; + } + public bool ComputeOverlayIntersection(ulong ulOverlayHandle, ref VROverlayIntersectionParams_t pParams, ref VROverlayIntersectionResults_t pResults) + { + bool result = FnTable.ComputeOverlayIntersection(ulOverlayHandle, ref pParams, ref pResults); + return result; + } + public bool IsHoverTargetOverlay(ulong ulOverlayHandle) + { + bool result = FnTable.IsHoverTargetOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayIntersectionMask(ulong ulOverlayHandle, ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives, uint unNumMaskPrimitives, uint unPrimitiveSize) + { + EVROverlayError result = FnTable.SetOverlayIntersectionMask(ulOverlayHandle, ref pMaskPrimitives, unNumMaskPrimitives, unPrimitiveSize); + return result; + } + public EVROverlayError TriggerLaserMouseHapticVibration(ulong ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude) + { + EVROverlayError result = FnTable.TriggerLaserMouseHapticVibration(ulOverlayHandle, fDurationSeconds, fFrequency, fAmplitude); + return result; + } + public EVROverlayError SetOverlayCursor(ulong ulOverlayHandle, ulong ulCursorHandle) + { + EVROverlayError result = FnTable.SetOverlayCursor(ulOverlayHandle, ulCursorHandle); + return result; + } + public EVROverlayError SetOverlayCursorPositionOverride(ulong ulOverlayHandle, ref HmdVector2_t pvCursor) + { + EVROverlayError result = FnTable.SetOverlayCursorPositionOverride(ulOverlayHandle, ref pvCursor); + return result; + } + public EVROverlayError ClearOverlayCursorPositionOverride(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ClearOverlayCursorPositionOverride(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayTexture(ulong ulOverlayHandle, ref Texture_t pTexture) + { + EVROverlayError result = FnTable.SetOverlayTexture(ulOverlayHandle, ref pTexture); + return result; + } + public EVROverlayError ClearOverlayTexture(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ClearOverlayTexture(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayRaw(ulong ulOverlayHandle, IntPtr pvBuffer, uint unWidth, uint unHeight, uint unBytesPerPixel) + { + EVROverlayError result = FnTable.SetOverlayRaw(ulOverlayHandle, pvBuffer, unWidth, unHeight, unBytesPerPixel); + return result; + } + public EVROverlayError SetOverlayFromFile(ulong ulOverlayHandle, string pchFilePath) + { + IntPtr pchFilePathUtf8 = Utils.ToUtf8(pchFilePath); + EVROverlayError result = FnTable.SetOverlayFromFile(ulOverlayHandle, pchFilePathUtf8); + Marshal.FreeHGlobal(pchFilePathUtf8); + return result; + } + public EVROverlayError GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref ETextureType pAPIType, ref EColorSpace pColorSpace, ref VRTextureBounds_t pTextureBounds) + { + pWidth = 0; + pHeight = 0; + pNativeFormat = 0; + EVROverlayError result = FnTable.GetOverlayTexture(ulOverlayHandle, ref pNativeTextureHandle, pNativeTextureRef, ref pWidth, ref pHeight, ref pNativeFormat, ref pAPIType, ref pColorSpace, ref pTextureBounds); + return result; + } + public EVROverlayError ReleaseNativeOverlayHandle(ulong ulOverlayHandle, IntPtr pNativeTextureHandle) + { + EVROverlayError result = FnTable.ReleaseNativeOverlayHandle(ulOverlayHandle, pNativeTextureHandle); + return result; + } + public EVROverlayError GetOverlayTextureSize(ulong ulOverlayHandle, ref uint pWidth, ref uint pHeight) + { + pWidth = 0; + pHeight = 0; + EVROverlayError result = FnTable.GetOverlayTextureSize(ulOverlayHandle, ref pWidth, ref pHeight); + return result; + } + public EVROverlayError CreateDashboardOverlay(string pchOverlayKey, string pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle) + { + IntPtr pchOverlayKeyUtf8 = Utils.ToUtf8(pchOverlayKey); + IntPtr pchOverlayFriendlyNameUtf8 = Utils.ToUtf8(pchOverlayFriendlyName); + pMainHandle = 0; + pThumbnailHandle = 0; + EVROverlayError result = FnTable.CreateDashboardOverlay(pchOverlayKeyUtf8, pchOverlayFriendlyNameUtf8, ref pMainHandle, ref pThumbnailHandle); + Marshal.FreeHGlobal(pchOverlayKeyUtf8); + Marshal.FreeHGlobal(pchOverlayFriendlyNameUtf8); + return result; + } + public bool IsDashboardVisible() + { + bool result = FnTable.IsDashboardVisible(); + return result; + } + public bool IsActiveDashboardOverlay(ulong ulOverlayHandle) + { + bool result = FnTable.IsActiveDashboardOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError SetDashboardOverlaySceneProcess(ulong ulOverlayHandle, uint unProcessId) + { + EVROverlayError result = FnTable.SetDashboardOverlaySceneProcess(ulOverlayHandle, unProcessId); + return result; + } + public EVROverlayError GetDashboardOverlaySceneProcess(ulong ulOverlayHandle, ref uint punProcessId) + { + punProcessId = 0; + EVROverlayError result = FnTable.GetDashboardOverlaySceneProcess(ulOverlayHandle, ref punProcessId); + return result; + } + public void ShowDashboard(string pchOverlayToShow) + { + IntPtr pchOverlayToShowUtf8 = Utils.ToUtf8(pchOverlayToShow); + FnTable.ShowDashboard(pchOverlayToShowUtf8); + Marshal.FreeHGlobal(pchOverlayToShowUtf8); + } + public uint GetPrimaryDashboardDevice() + { + uint result = FnTable.GetPrimaryDashboardDevice(); + return result; + } + public EVROverlayError ShowKeyboard(int eInputMode, int eLineInputMode, uint unFlags, string pchDescription, uint unCharMax, string pchExistingText, ulong uUserValue) + { + IntPtr pchDescriptionUtf8 = Utils.ToUtf8(pchDescription); + IntPtr pchExistingTextUtf8 = Utils.ToUtf8(pchExistingText); + EVROverlayError result = FnTable.ShowKeyboard(eInputMode, eLineInputMode, unFlags, pchDescriptionUtf8, unCharMax, pchExistingTextUtf8, uUserValue); + Marshal.FreeHGlobal(pchDescriptionUtf8); + Marshal.FreeHGlobal(pchExistingTextUtf8); + return result; + } + public EVROverlayError ShowKeyboardForOverlay(ulong ulOverlayHandle, int eInputMode, int eLineInputMode, uint unFlags, string pchDescription, uint unCharMax, string pchExistingText, ulong uUserValue) + { + IntPtr pchDescriptionUtf8 = Utils.ToUtf8(pchDescription); + IntPtr pchExistingTextUtf8 = Utils.ToUtf8(pchExistingText); + EVROverlayError result = FnTable.ShowKeyboardForOverlay(ulOverlayHandle, eInputMode, eLineInputMode, unFlags, pchDescriptionUtf8, unCharMax, pchExistingTextUtf8, uUserValue); + Marshal.FreeHGlobal(pchDescriptionUtf8); + Marshal.FreeHGlobal(pchExistingTextUtf8); + return result; + } + public uint GetKeyboardText(System.Text.StringBuilder pchText, uint cchText) + { + uint result = FnTable.GetKeyboardText(pchText, cchText); + return result; + } + public void HideKeyboard() + { + FnTable.HideKeyboard(); + } + public void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform) + { + FnTable.SetKeyboardTransformAbsolute(eTrackingOrigin, ref pmatTrackingOriginToKeyboardTransform); + } + public void SetKeyboardPositionForOverlay(ulong ulOverlayHandle, HmdRect2_t avoidRect) + { + FnTable.SetKeyboardPositionForOverlay(ulOverlayHandle, avoidRect); + } + public VRMessageOverlayResponse ShowMessageOverlay(string pchText, string pchCaption, string pchButton0Text, string pchButton1Text, string pchButton2Text, string pchButton3Text) + { + IntPtr pchTextUtf8 = Utils.ToUtf8(pchText); + IntPtr pchCaptionUtf8 = Utils.ToUtf8(pchCaption); + IntPtr pchButton0TextUtf8 = Utils.ToUtf8(pchButton0Text); + IntPtr pchButton1TextUtf8 = Utils.ToUtf8(pchButton1Text); + IntPtr pchButton2TextUtf8 = Utils.ToUtf8(pchButton2Text); + IntPtr pchButton3TextUtf8 = Utils.ToUtf8(pchButton3Text); + VRMessageOverlayResponse result = FnTable.ShowMessageOverlay(pchTextUtf8, pchCaptionUtf8, pchButton0TextUtf8, pchButton1TextUtf8, pchButton2TextUtf8, pchButton3TextUtf8); + Marshal.FreeHGlobal(pchTextUtf8); + Marshal.FreeHGlobal(pchCaptionUtf8); + Marshal.FreeHGlobal(pchButton0TextUtf8); + Marshal.FreeHGlobal(pchButton1TextUtf8); + Marshal.FreeHGlobal(pchButton2TextUtf8); + Marshal.FreeHGlobal(pchButton3TextUtf8); + return result; + } + public void CloseMessageOverlay() + { + FnTable.CloseMessageOverlay(); + } + } + + + public class CVROverlayView + { + IVROverlayView FnTable; + internal CVROverlayView(IntPtr pInterface) + { + FnTable = (IVROverlayView)Marshal.PtrToStructure(pInterface, typeof(IVROverlayView)); + } + public EVROverlayError AcquireOverlayView(ulong ulOverlayHandle, ref VRNativeDevice_t pNativeDevice, ref VROverlayView_t pOverlayView, uint unOverlayViewSize) + { + EVROverlayError result = FnTable.AcquireOverlayView(ulOverlayHandle, ref pNativeDevice, ref pOverlayView, unOverlayViewSize); + return result; + } + public EVROverlayError ReleaseOverlayView(ref VROverlayView_t pOverlayView) + { + EVROverlayError result = FnTable.ReleaseOverlayView(ref pOverlayView); + return result; + } + public void PostOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pvrEvent) + { + FnTable.PostOverlayEvent(ulOverlayHandle, ref pvrEvent); + } + public bool IsViewingPermitted(ulong ulOverlayHandle) + { + bool result = FnTable.IsViewingPermitted(ulOverlayHandle); + return result; + } + } + + + public class CVRHeadsetView + { + IVRHeadsetView FnTable; + internal CVRHeadsetView(IntPtr pInterface) + { + FnTable = (IVRHeadsetView)Marshal.PtrToStructure(pInterface, typeof(IVRHeadsetView)); + } + public void SetHeadsetViewSize(uint nWidth, uint nHeight) + { + FnTable.SetHeadsetViewSize(nWidth, nHeight); + } + public void GetHeadsetViewSize(ref uint pnWidth, ref uint pnHeight) + { + pnWidth = 0; + pnHeight = 0; + FnTable.GetHeadsetViewSize(ref pnWidth, ref pnHeight); + } + public void SetHeadsetViewMode(uint eHeadsetViewMode) + { + FnTable.SetHeadsetViewMode(eHeadsetViewMode); + } + public uint GetHeadsetViewMode() + { + uint result = FnTable.GetHeadsetViewMode(); + return result; + } + public void SetHeadsetViewCropped(bool bCropped) + { + FnTable.SetHeadsetViewCropped(bCropped); + } + public bool GetHeadsetViewCropped() + { + bool result = FnTable.GetHeadsetViewCropped(); + return result; + } + public float GetHeadsetViewAspectRatio() + { + float result = FnTable.GetHeadsetViewAspectRatio(); + return result; + } + public void SetHeadsetViewBlendRange(float flStartPct, float flEndPct) + { + FnTable.SetHeadsetViewBlendRange(flStartPct, flEndPct); + } + public void GetHeadsetViewBlendRange(ref float pStartPct, ref float pEndPct) + { + pStartPct = 0; + pEndPct = 0; + FnTable.GetHeadsetViewBlendRange(ref pStartPct, ref pEndPct); + } + } + + + public class CVRRenderModels + { + IVRRenderModels FnTable; + internal CVRRenderModels(IntPtr pInterface) + { + FnTable = (IVRRenderModels)Marshal.PtrToStructure(pInterface, typeof(IVRRenderModels)); + } + public EVRRenderModelError LoadRenderModel_Async(string pchRenderModelName, ref IntPtr ppRenderModel) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + EVRRenderModelError result = FnTable.LoadRenderModel_Async(pchRenderModelNameUtf8, ref ppRenderModel); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + return result; + } + public void FreeRenderModel(IntPtr pRenderModel) + { + FnTable.FreeRenderModel(pRenderModel); + } + public EVRRenderModelError LoadTexture_Async(int textureId, ref IntPtr ppTexture) + { + EVRRenderModelError result = FnTable.LoadTexture_Async(textureId, ref ppTexture); + return result; + } + public void FreeTexture(IntPtr pTexture) + { + FnTable.FreeTexture(pTexture); + } + public EVRRenderModelError LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D) + { + EVRRenderModelError result = FnTable.LoadTextureD3D11_Async(textureId, pD3D11Device, ref ppD3D11Texture2D); + return result; + } + public EVRRenderModelError LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture) + { + EVRRenderModelError result = FnTable.LoadIntoTextureD3D11_Async(textureId, pDstTexture); + return result; + } + public void FreeTextureD3D11(IntPtr pD3D11Texture2D) + { + FnTable.FreeTextureD3D11(pD3D11Texture2D); + } + public uint GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen) + { + uint result = FnTable.GetRenderModelName(unRenderModelIndex, pchRenderModelName, unRenderModelNameLen); + return result; + } + public uint GetRenderModelCount() + { + uint result = FnTable.GetRenderModelCount(); + return result; + } + public uint GetComponentCount(string pchRenderModelName) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + uint result = FnTable.GetComponentCount(pchRenderModelNameUtf8); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + return result; + } + public uint GetComponentName(string pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + uint result = FnTable.GetComponentName(pchRenderModelNameUtf8, unComponentIndex, pchComponentName, unComponentNameLen); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + return result; + } + public ulong GetComponentButtonMask(string pchRenderModelName, string pchComponentName) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName); + ulong result = FnTable.GetComponentButtonMask(pchRenderModelNameUtf8, pchComponentNameUtf8); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + Marshal.FreeHGlobal(pchComponentNameUtf8); + return result; + } + public uint GetComponentRenderModelName(string pchRenderModelName, string pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName); + uint result = FnTable.GetComponentRenderModelName(pchRenderModelNameUtf8, pchComponentNameUtf8, pchComponentRenderModelName, unComponentRenderModelNameLen); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + Marshal.FreeHGlobal(pchComponentNameUtf8); + return result; + } + public bool GetComponentStateForDevicePath(string pchRenderModelName, string pchComponentName, ulong devicePath, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName); + bool result = FnTable.GetComponentStateForDevicePath(pchRenderModelNameUtf8, pchComponentNameUtf8, devicePath, ref pState, ref pComponentState); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + Marshal.FreeHGlobal(pchComponentNameUtf8); + return result; + } + // This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were + // originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentStatePacked(IntPtr pchRenderModelName, IntPtr pchComponentName, ref VRControllerState_t_Packed pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); + [StructLayout(LayoutKind.Explicit)] + struct GetComponentStateUnion + { + [FieldOffset(0)] + public IVRRenderModels._GetComponentState pGetComponentState; + [FieldOffset(0)] + public _GetComponentStatePacked pGetComponentStatePacked; + } + public bool GetComponentState(string pchRenderModelName, string pchComponentName, ref VRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName); +#if !UNITY_METRO + if (Environment.OSVersion.Platform == PlatformID.MacOSX || + Environment.OSVersion.Platform == PlatformID.Unix) + { + GetComponentStateUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetComponentStatePacked = null; + u.pGetComponentState = FnTable.GetComponentState; + bool packed_result = u.pGetComponentStatePacked(pchRenderModelNameUtf8, pchComponentNameUtf8, ref state_packed, ref pState, ref pComponentState); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetComponentState(pchRenderModelNameUtf8, pchComponentNameUtf8, ref pControllerState, ref pState, ref pComponentState); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + Marshal.FreeHGlobal(pchComponentNameUtf8); + return result; + } + public bool RenderModelHasComponent(string pchRenderModelName, string pchComponentName) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName); + bool result = FnTable.RenderModelHasComponent(pchRenderModelNameUtf8, pchComponentNameUtf8); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + Marshal.FreeHGlobal(pchComponentNameUtf8); + return result; + } + public uint GetRenderModelThumbnailURL(string pchRenderModelName, System.Text.StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + uint result = FnTable.GetRenderModelThumbnailURL(pchRenderModelNameUtf8, pchThumbnailURL, unThumbnailURLLen, ref peError); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + return result; + } + public uint GetRenderModelOriginalPath(string pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + uint result = FnTable.GetRenderModelOriginalPath(pchRenderModelNameUtf8, pchOriginalPath, unOriginalPathLen, ref peError); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + return result; + } + public string GetRenderModelErrorNameFromEnum(EVRRenderModelError error) + { + IntPtr result = FnTable.GetRenderModelErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + } + + + public class CVRNotifications + { + IVRNotifications FnTable; + internal CVRNotifications(IntPtr pInterface) + { + FnTable = (IVRNotifications)Marshal.PtrToStructure(pInterface, typeof(IVRNotifications)); + } + public EVRNotificationError CreateNotification(ulong ulOverlayHandle, ulong ulUserValue, EVRNotificationType type, string pchText, EVRNotificationStyle style, ref NotificationBitmap_t pImage, ref uint pNotificationId) + { + IntPtr pchTextUtf8 = Utils.ToUtf8(pchText); + pNotificationId = 0; + EVRNotificationError result = FnTable.CreateNotification(ulOverlayHandle, ulUserValue, type, pchTextUtf8, style, ref pImage, ref pNotificationId); + Marshal.FreeHGlobal(pchTextUtf8); + return result; + } + public EVRNotificationError RemoveNotification(uint notificationId) + { + EVRNotificationError result = FnTable.RemoveNotification(notificationId); + return result; + } + } + + + public class CVRSettings + { + IVRSettings FnTable; + internal CVRSettings(IntPtr pInterface) + { + FnTable = (IVRSettings)Marshal.PtrToStructure(pInterface, typeof(IVRSettings)); + } + public string GetSettingsErrorNameFromEnum(EVRSettingsError eError) + { + IntPtr result = FnTable.GetSettingsErrorNameFromEnum(eError); + return Marshal.PtrToStringAnsi(result); + } + public void SetBool(string pchSection, string pchSettingsKey, bool bValue, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + FnTable.SetBool(pchSectionUtf8, pchSettingsKeyUtf8, bValue, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + } + public void SetInt32(string pchSection, string pchSettingsKey, int nValue, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + FnTable.SetInt32(pchSectionUtf8, pchSettingsKeyUtf8, nValue, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + } + public void SetFloat(string pchSection, string pchSettingsKey, float flValue, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + FnTable.SetFloat(pchSectionUtf8, pchSettingsKeyUtf8, flValue, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + } + public void SetString(string pchSection, string pchSettingsKey, string pchValue, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + IntPtr pchValueUtf8 = Utils.ToUtf8(pchValue); + FnTable.SetString(pchSectionUtf8, pchSettingsKeyUtf8, pchValueUtf8, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + Marshal.FreeHGlobal(pchValueUtf8); + } + public bool GetBool(string pchSection, string pchSettingsKey, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + bool result = FnTable.GetBool(pchSectionUtf8, pchSettingsKeyUtf8, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + return result; + } + public int GetInt32(string pchSection, string pchSettingsKey, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + int result = FnTable.GetInt32(pchSectionUtf8, pchSettingsKeyUtf8, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + return result; + } + public float GetFloat(string pchSection, string pchSettingsKey, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + float result = FnTable.GetFloat(pchSectionUtf8, pchSettingsKeyUtf8, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + return result; + } + public void GetString(string pchSection, string pchSettingsKey, System.Text.StringBuilder pchValue, uint unValueLen, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + FnTable.GetString(pchSectionUtf8, pchSettingsKeyUtf8, pchValue, unValueLen, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + } + public void RemoveSection(string pchSection, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + FnTable.RemoveSection(pchSectionUtf8, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + } + public void RemoveKeyInSection(string pchSection, string pchSettingsKey, ref EVRSettingsError peError) + { + IntPtr pchSectionUtf8 = Utils.ToUtf8(pchSection); + IntPtr pchSettingsKeyUtf8 = Utils.ToUtf8(pchSettingsKey); + FnTable.RemoveKeyInSection(pchSectionUtf8, pchSettingsKeyUtf8, ref peError); + Marshal.FreeHGlobal(pchSectionUtf8); + Marshal.FreeHGlobal(pchSettingsKeyUtf8); + } + } + + + public class CVRScreenshots + { + IVRScreenshots FnTable; + internal CVRScreenshots(IntPtr pInterface) + { + FnTable = (IVRScreenshots)Marshal.PtrToStructure(pInterface, typeof(IVRScreenshots)); + } + public EVRScreenshotError RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, string pchPreviewFilename, string pchVRFilename) + { + pOutScreenshotHandle = 0; + IntPtr pchPreviewFilenameUtf8 = Utils.ToUtf8(pchPreviewFilename); + IntPtr pchVRFilenameUtf8 = Utils.ToUtf8(pchVRFilename); + EVRScreenshotError result = FnTable.RequestScreenshot(ref pOutScreenshotHandle, type, pchPreviewFilenameUtf8, pchVRFilenameUtf8); + Marshal.FreeHGlobal(pchPreviewFilenameUtf8); + Marshal.FreeHGlobal(pchVRFilenameUtf8); + return result; + } + public EVRScreenshotError HookScreenshot(EVRScreenshotType[] pSupportedTypes) + { + EVRScreenshotError result = FnTable.HookScreenshot(pSupportedTypes, pSupportedTypes.Length); + return result; + } + public EVRScreenshotType GetScreenshotPropertyType(uint screenshotHandle, ref EVRScreenshotError pError) + { + EVRScreenshotType result = FnTable.GetScreenshotPropertyType(screenshotHandle, ref pError); + return result; + } + public uint GetScreenshotPropertyFilename(uint screenshotHandle, EVRScreenshotPropertyFilenames filenameType, System.Text.StringBuilder pchFilename, uint cchFilename, ref EVRScreenshotError pError) + { + uint result = FnTable.GetScreenshotPropertyFilename(screenshotHandle, filenameType, pchFilename, cchFilename, ref pError); + return result; + } + public EVRScreenshotError UpdateScreenshotProgress(uint screenshotHandle, float flProgress) + { + EVRScreenshotError result = FnTable.UpdateScreenshotProgress(screenshotHandle, flProgress); + return result; + } + public EVRScreenshotError TakeStereoScreenshot(ref uint pOutScreenshotHandle, string pchPreviewFilename, string pchVRFilename) + { + pOutScreenshotHandle = 0; + IntPtr pchPreviewFilenameUtf8 = Utils.ToUtf8(pchPreviewFilename); + IntPtr pchVRFilenameUtf8 = Utils.ToUtf8(pchVRFilename); + EVRScreenshotError result = FnTable.TakeStereoScreenshot(ref pOutScreenshotHandle, pchPreviewFilenameUtf8, pchVRFilenameUtf8); + Marshal.FreeHGlobal(pchPreviewFilenameUtf8); + Marshal.FreeHGlobal(pchVRFilenameUtf8); + return result; + } + public EVRScreenshotError SubmitScreenshot(uint screenshotHandle, EVRScreenshotType type, string pchSourcePreviewFilename, string pchSourceVRFilename) + { + IntPtr pchSourcePreviewFilenameUtf8 = Utils.ToUtf8(pchSourcePreviewFilename); + IntPtr pchSourceVRFilenameUtf8 = Utils.ToUtf8(pchSourceVRFilename); + EVRScreenshotError result = FnTable.SubmitScreenshot(screenshotHandle, type, pchSourcePreviewFilenameUtf8, pchSourceVRFilenameUtf8); + Marshal.FreeHGlobal(pchSourcePreviewFilenameUtf8); + Marshal.FreeHGlobal(pchSourceVRFilenameUtf8); + return result; + } + } + + + public class CVRResources + { + IVRResources FnTable; + internal CVRResources(IntPtr pInterface) + { + FnTable = (IVRResources)Marshal.PtrToStructure(pInterface, typeof(IVRResources)); + } + public uint LoadSharedResource(string pchResourceName, string pchBuffer, uint unBufferLen) + { + IntPtr pchResourceNameUtf8 = Utils.ToUtf8(pchResourceName); + uint result = FnTable.LoadSharedResource(pchResourceNameUtf8, pchBuffer, unBufferLen); + Marshal.FreeHGlobal(pchResourceNameUtf8); + return result; + } + public uint GetResourceFullPath(string pchResourceName, string pchResourceTypeDirectory, System.Text.StringBuilder pchPathBuffer, uint unBufferLen) + { + IntPtr pchResourceNameUtf8 = Utils.ToUtf8(pchResourceName); + IntPtr pchResourceTypeDirectoryUtf8 = Utils.ToUtf8(pchResourceTypeDirectory); + uint result = FnTable.GetResourceFullPath(pchResourceNameUtf8, pchResourceTypeDirectoryUtf8, pchPathBuffer, unBufferLen); + Marshal.FreeHGlobal(pchResourceNameUtf8); + Marshal.FreeHGlobal(pchResourceTypeDirectoryUtf8); + return result; + } + } + + + public class CVRDriverManager + { + IVRDriverManager FnTable; + internal CVRDriverManager(IntPtr pInterface) + { + FnTable = (IVRDriverManager)Marshal.PtrToStructure(pInterface, typeof(IVRDriverManager)); + } + public uint GetDriverCount() + { + uint result = FnTable.GetDriverCount(); + return result; + } + public uint GetDriverName(uint nDriver, System.Text.StringBuilder pchValue, uint unBufferSize) + { + uint result = FnTable.GetDriverName(nDriver, pchValue, unBufferSize); + return result; + } + public ulong GetDriverHandle(string pchDriverName) + { + IntPtr pchDriverNameUtf8 = Utils.ToUtf8(pchDriverName); + ulong result = FnTable.GetDriverHandle(pchDriverNameUtf8); + Marshal.FreeHGlobal(pchDriverNameUtf8); + return result; + } + public bool IsEnabled(uint nDriver) + { + bool result = FnTable.IsEnabled(nDriver); + return result; + } + } + + + public class CVRInput + { + IVRInput FnTable; + internal CVRInput(IntPtr pInterface) + { + FnTable = (IVRInput)Marshal.PtrToStructure(pInterface, typeof(IVRInput)); + } + public EVRInputError SetActionManifestPath(string pchActionManifestPath) + { + IntPtr pchActionManifestPathUtf8 = Utils.ToUtf8(pchActionManifestPath); + EVRInputError result = FnTable.SetActionManifestPath(pchActionManifestPathUtf8); + Marshal.FreeHGlobal(pchActionManifestPathUtf8); + return result; + } + public EVRInputError GetActionSetHandle(string pchActionSetName, ref ulong pHandle) + { + IntPtr pchActionSetNameUtf8 = Utils.ToUtf8(pchActionSetName); + pHandle = 0; + EVRInputError result = FnTable.GetActionSetHandle(pchActionSetNameUtf8, ref pHandle); + Marshal.FreeHGlobal(pchActionSetNameUtf8); + return result; + } + public EVRInputError GetActionHandle(string pchActionName, ref ulong pHandle) + { + IntPtr pchActionNameUtf8 = Utils.ToUtf8(pchActionName); + pHandle = 0; + EVRInputError result = FnTable.GetActionHandle(pchActionNameUtf8, ref pHandle); + Marshal.FreeHGlobal(pchActionNameUtf8); + return result; + } + public EVRInputError GetInputSourceHandle(string pchInputSourcePath, ref ulong pHandle) + { + IntPtr pchInputSourcePathUtf8 = Utils.ToUtf8(pchInputSourcePath); + pHandle = 0; + EVRInputError result = FnTable.GetInputSourceHandle(pchInputSourcePathUtf8, ref pHandle); + Marshal.FreeHGlobal(pchInputSourcePathUtf8); + return result; + } + public EVRInputError UpdateActionState(VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t) + { + EVRInputError result = FnTable.UpdateActionState(pSets, unSizeOfVRSelectedActionSet_t, (uint)pSets.Length); + return result; + } + public EVRInputError GetDigitalActionData(ulong action, ref InputDigitalActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetDigitalActionData(action, ref pActionData, unActionDataSize, ulRestrictToDevice); + return result; + } + public EVRInputError GetAnalogActionData(ulong action, ref InputAnalogActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetAnalogActionData(action, ref pActionData, unActionDataSize, ulRestrictToDevice); + return result; + } + public EVRInputError GetPoseActionDataRelativeToNow(ulong action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, ref InputPoseActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetPoseActionDataRelativeToNow(action, eOrigin, fPredictedSecondsFromNow, ref pActionData, unActionDataSize, ulRestrictToDevice); + return result; + } + public EVRInputError GetPoseActionDataForNextFrame(ulong action, ETrackingUniverseOrigin eOrigin, ref InputPoseActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetPoseActionDataForNextFrame(action, eOrigin, ref pActionData, unActionDataSize, ulRestrictToDevice); + return result; + } + public EVRInputError GetSkeletalActionData(ulong action, ref InputSkeletalActionData_t pActionData, uint unActionDataSize) + { + EVRInputError result = FnTable.GetSkeletalActionData(action, ref pActionData, unActionDataSize); + return result; + } + public EVRInputError GetDominantHand(ref ETrackedControllerRole peDominantHand) + { + EVRInputError result = FnTable.GetDominantHand(ref peDominantHand); + return result; + } + public EVRInputError SetDominantHand(ETrackedControllerRole eDominantHand) + { + EVRInputError result = FnTable.SetDominantHand(eDominantHand); + return result; + } + public EVRInputError GetBoneCount(ulong action, ref uint pBoneCount) + { + pBoneCount = 0; + EVRInputError result = FnTable.GetBoneCount(action, ref pBoneCount); + return result; + } + public EVRInputError GetBoneHierarchy(ulong action, int[] pParentIndices) + { + EVRInputError result = FnTable.GetBoneHierarchy(action, pParentIndices, (uint)pParentIndices.Length); + return result; + } + public EVRInputError GetBoneName(ulong action, int nBoneIndex, System.Text.StringBuilder pchBoneName, uint unNameBufferSize) + { + EVRInputError result = FnTable.GetBoneName(action, nBoneIndex, pchBoneName, unNameBufferSize); + return result; + } + public EVRInputError GetSkeletalReferenceTransforms(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, VRBoneTransform_t[] pTransformArray) + { + EVRInputError result = FnTable.GetSkeletalReferenceTransforms(action, eTransformSpace, eReferencePose, pTransformArray, (uint)pTransformArray.Length); + return result; + } + public EVRInputError GetSkeletalTrackingLevel(ulong action, ref EVRSkeletalTrackingLevel pSkeletalTrackingLevel) + { + EVRInputError result = FnTable.GetSkeletalTrackingLevel(action, ref pSkeletalTrackingLevel); + return result; + } + public EVRInputError GetSkeletalBoneData(ulong action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, VRBoneTransform_t[] pTransformArray) + { + EVRInputError result = FnTable.GetSkeletalBoneData(action, eTransformSpace, eMotionRange, pTransformArray, (uint)pTransformArray.Length); + return result; + } + public EVRInputError GetSkeletalSummaryData(ulong action, EVRSummaryType eSummaryType, ref VRSkeletalSummaryData_t pSkeletalSummaryData) + { + EVRInputError result = FnTable.GetSkeletalSummaryData(action, eSummaryType, ref pSkeletalSummaryData); + return result; + } + public EVRInputError GetSkeletalBoneDataCompressed(ulong action, EVRSkeletalMotionRange eMotionRange, IntPtr pvCompressedData, uint unCompressedSize, ref uint punRequiredCompressedSize) + { + punRequiredCompressedSize = 0; + EVRInputError result = FnTable.GetSkeletalBoneDataCompressed(action, eMotionRange, pvCompressedData, unCompressedSize, ref punRequiredCompressedSize); + return result; + } + public EVRInputError DecompressSkeletalBoneData(IntPtr pvCompressedBuffer, uint unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, VRBoneTransform_t[] pTransformArray) + { + EVRInputError result = FnTable.DecompressSkeletalBoneData(pvCompressedBuffer, unCompressedBufferSize, eTransformSpace, pTransformArray, (uint)pTransformArray.Length); + return result; + } + public EVRInputError TriggerHapticVibrationAction(ulong action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.TriggerHapticVibrationAction(action, fStartSecondsFromNow, fDurationSeconds, fFrequency, fAmplitude, ulRestrictToDevice); + return result; + } + public EVRInputError GetActionOrigins(ulong actionSetHandle, ulong digitalActionHandle, ulong[] originsOut) + { + EVRInputError result = FnTable.GetActionOrigins(actionSetHandle, digitalActionHandle, originsOut, (uint)originsOut.Length); + return result; + } + public EVRInputError GetOriginLocalizedName(ulong origin, System.Text.StringBuilder pchNameArray, uint unNameArraySize, int unStringSectionsToInclude) + { + EVRInputError result = FnTable.GetOriginLocalizedName(origin, pchNameArray, unNameArraySize, unStringSectionsToInclude); + return result; + } + public EVRInputError GetOriginTrackedDeviceInfo(ulong origin, ref InputOriginInfo_t pOriginInfo, uint unOriginInfoSize) + { + EVRInputError result = FnTable.GetOriginTrackedDeviceInfo(origin, ref pOriginInfo, unOriginInfoSize); + return result; + } + public EVRInputError GetActionBindingInfo(ulong action, ref InputBindingInfo_t pOriginInfo, uint unBindingInfoSize, uint unBindingInfoCount, ref uint punReturnedBindingInfoCount) + { + punReturnedBindingInfoCount = 0; + EVRInputError result = FnTable.GetActionBindingInfo(action, ref pOriginInfo, unBindingInfoSize, unBindingInfoCount, ref punReturnedBindingInfoCount); + return result; + } + public EVRInputError ShowActionOrigins(ulong actionSetHandle, ulong ulActionHandle) + { + EVRInputError result = FnTable.ShowActionOrigins(actionSetHandle, ulActionHandle); + return result; + } + public EVRInputError ShowBindingsForActionSet(VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, ulong originToHighlight) + { + EVRInputError result = FnTable.ShowBindingsForActionSet(pSets, unSizeOfVRSelectedActionSet_t, (uint)pSets.Length, originToHighlight); + return result; + } + public EVRInputError GetComponentStateForBinding(string pchRenderModelName, string pchComponentName, ref InputBindingInfo_t pOriginInfo, uint unBindingInfoSize, uint unBindingInfoCount, ref RenderModel_ComponentState_t pComponentState) + { + IntPtr pchRenderModelNameUtf8 = Utils.ToUtf8(pchRenderModelName); + IntPtr pchComponentNameUtf8 = Utils.ToUtf8(pchComponentName); + EVRInputError result = FnTable.GetComponentStateForBinding(pchRenderModelNameUtf8, pchComponentNameUtf8, ref pOriginInfo, unBindingInfoSize, unBindingInfoCount, ref pComponentState); + Marshal.FreeHGlobal(pchRenderModelNameUtf8); + Marshal.FreeHGlobal(pchComponentNameUtf8); + return result; + } + public bool IsUsingLegacyInput() + { + bool result = FnTable.IsUsingLegacyInput(); + return result; + } + public EVRInputError OpenBindingUI(string pchAppKey, ulong ulActionSetHandle, ulong ulDeviceHandle, bool bShowOnDesktop) + { + IntPtr pchAppKeyUtf8 = Utils.ToUtf8(pchAppKey); + EVRInputError result = FnTable.OpenBindingUI(pchAppKeyUtf8, ulActionSetHandle, ulDeviceHandle, bShowOnDesktop); + Marshal.FreeHGlobal(pchAppKeyUtf8); + return result; + } + public EVRInputError GetBindingVariant(ulong ulDevicePath, System.Text.StringBuilder pchVariantArray, uint unVariantArraySize) + { + EVRInputError result = FnTable.GetBindingVariant(ulDevicePath, pchVariantArray, unVariantArraySize); + return result; + } + } + + + public class CVRIOBuffer + { + IVRIOBuffer FnTable; + internal CVRIOBuffer(IntPtr pInterface) + { + FnTable = (IVRIOBuffer)Marshal.PtrToStructure(pInterface, typeof(IVRIOBuffer)); + } + public EIOBufferError Open(string pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer) + { + IntPtr pchPathUtf8 = Utils.ToUtf8(pchPath); + pulBuffer = 0; + EIOBufferError result = FnTable.Open(pchPathUtf8, mode, unElementSize, unElements, ref pulBuffer); + Marshal.FreeHGlobal(pchPathUtf8); + return result; + } + public EIOBufferError Close(ulong ulBuffer) + { + EIOBufferError result = FnTable.Close(ulBuffer); + return result; + } + public EIOBufferError Read(ulong ulBuffer, IntPtr pDst, uint unBytes, ref uint punRead) + { + punRead = 0; + EIOBufferError result = FnTable.Read(ulBuffer, pDst, unBytes, ref punRead); + return result; + } + public EIOBufferError Write(ulong ulBuffer, IntPtr pSrc, uint unBytes) + { + EIOBufferError result = FnTable.Write(ulBuffer, pSrc, unBytes); + return result; + } + public ulong PropertyContainer(ulong ulBuffer) + { + ulong result = FnTable.PropertyContainer(ulBuffer); + return result; + } + public bool HasReaders(ulong ulBuffer) + { + bool result = FnTable.HasReaders(ulBuffer); + return result; + } + } + + + public class CVRSpatialAnchors + { + IVRSpatialAnchors FnTable; + internal CVRSpatialAnchors(IntPtr pInterface) + { + FnTable = (IVRSpatialAnchors)Marshal.PtrToStructure(pInterface, typeof(IVRSpatialAnchors)); + } + public EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor(string pchDescriptor, ref uint pHandleOut) + { + IntPtr pchDescriptorUtf8 = Utils.ToUtf8(pchDescriptor); + pHandleOut = 0; + EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromDescriptor(pchDescriptorUtf8, ref pHandleOut); + Marshal.FreeHGlobal(pchDescriptorUtf8); + return result; + } + public EVRSpatialAnchorError CreateSpatialAnchorFromPose(uint unDeviceIndex, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPose, ref uint pHandleOut) + { + pHandleOut = 0; + EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromPose(unDeviceIndex, eOrigin, ref pPose, ref pHandleOut); + return result; + } + public EVRSpatialAnchorError GetSpatialAnchorPose(uint unHandle, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPoseOut) + { + EVRSpatialAnchorError result = FnTable.GetSpatialAnchorPose(unHandle, eOrigin, ref pPoseOut); + return result; + } + public EVRSpatialAnchorError GetSpatialAnchorDescriptor(uint unHandle, System.Text.StringBuilder pchDescriptorOut, ref uint punDescriptorBufferLenInOut) + { + punDescriptorBufferLenInOut = 0; + EVRSpatialAnchorError result = FnTable.GetSpatialAnchorDescriptor(unHandle, pchDescriptorOut, ref punDescriptorBufferLenInOut); + return result; + } + } + + + public class CVRDebug + { + IVRDebug FnTable; + internal CVRDebug(IntPtr pInterface) + { + FnTable = (IVRDebug)Marshal.PtrToStructure(pInterface, typeof(IVRDebug)); + } + public EVRDebugError EmitVrProfilerEvent(string pchMessage) + { + IntPtr pchMessageUtf8 = Utils.ToUtf8(pchMessage); + EVRDebugError result = FnTable.EmitVrProfilerEvent(pchMessageUtf8); + Marshal.FreeHGlobal(pchMessageUtf8); + return result; + } + public EVRDebugError BeginVrProfilerEvent(ref ulong pHandleOut) + { + pHandleOut = 0; + EVRDebugError result = FnTable.BeginVrProfilerEvent(ref pHandleOut); + return result; + } + public EVRDebugError FinishVrProfilerEvent(ulong hHandle, string pchMessage) + { + IntPtr pchMessageUtf8 = Utils.ToUtf8(pchMessage); + EVRDebugError result = FnTable.FinishVrProfilerEvent(hHandle, pchMessageUtf8); + Marshal.FreeHGlobal(pchMessageUtf8); + return result; + } + public uint DriverDebugRequest(uint unDeviceIndex, string pchRequest, System.Text.StringBuilder pchResponseBuffer, uint unResponseBufferSize) + { + IntPtr pchRequestUtf8 = Utils.ToUtf8(pchRequest); + uint result = FnTable.DriverDebugRequest(unDeviceIndex, pchRequestUtf8, pchResponseBuffer, unResponseBufferSize); + Marshal.FreeHGlobal(pchRequestUtf8); + return result; + } + } + + + public class CVRProperties + { + IVRProperties FnTable; + internal CVRProperties(IntPtr pInterface) + { + FnTable = (IVRProperties)Marshal.PtrToStructure(pInterface, typeof(IVRProperties)); + } + public ETrackedPropertyError ReadPropertyBatch(ulong ulContainerHandle, ref PropertyRead_t pBatch, uint unBatchEntryCount) + { + ETrackedPropertyError result = FnTable.ReadPropertyBatch(ulContainerHandle, ref pBatch, unBatchEntryCount); + return result; + } + public ETrackedPropertyError WritePropertyBatch(ulong ulContainerHandle, ref PropertyWrite_t pBatch, uint unBatchEntryCount) + { + ETrackedPropertyError result = FnTable.WritePropertyBatch(ulContainerHandle, ref pBatch, unBatchEntryCount); + return result; + } + public string GetPropErrorNameFromEnum(ETrackedPropertyError error) + { + IntPtr result = FnTable.GetPropErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public ulong TrackedDeviceToPropertyContainer(uint nDevice) + { + ulong result = FnTable.TrackedDeviceToPropertyContainer(nDevice); + return result; + } + } + + + public class CVRPaths + { + IVRPaths FnTable; + internal CVRPaths(IntPtr pInterface) + { + FnTable = (IVRPaths)Marshal.PtrToStructure(pInterface, typeof(IVRPaths)); + } + public ETrackedPropertyError ReadPathBatch(ulong ulRootHandle, ref PathRead_t pBatch, uint unBatchEntryCount) + { + ETrackedPropertyError result = FnTable.ReadPathBatch(ulRootHandle, ref pBatch, unBatchEntryCount); + return result; + } + public ETrackedPropertyError WritePathBatch(ulong ulRootHandle, ref PathWrite_t pBatch, uint unBatchEntryCount) + { + ETrackedPropertyError result = FnTable.WritePathBatch(ulRootHandle, ref pBatch, unBatchEntryCount); + return result; + } + public ETrackedPropertyError StringToHandle(ref ulong pHandle, string pchPath) + { + pHandle = 0; + IntPtr pchPathUtf8 = Utils.ToUtf8(pchPath); + ETrackedPropertyError result = FnTable.StringToHandle(ref pHandle, pchPathUtf8); + Marshal.FreeHGlobal(pchPathUtf8); + return result; + } + public ETrackedPropertyError HandleToString(ulong pHandle, string pchBuffer, uint unBufferSize, ref uint punBufferSizeUsed) + { + punBufferSizeUsed = 0; + ETrackedPropertyError result = FnTable.HandleToString(pHandle, pchBuffer, unBufferSize, ref punBufferSizeUsed); + return result; + } + } + + + public class CVRBlockQueue + { + IVRBlockQueue FnTable; + internal CVRBlockQueue(IntPtr pInterface) + { + FnTable = (IVRBlockQueue)Marshal.PtrToStructure(pInterface, typeof(IVRBlockQueue)); + } + public EBlockQueueError Create(ref ulong pulQueueHandle, string pchPath, uint unBlockDataSize, uint unBlockHeaderSize, uint unBlockCount) + { + pulQueueHandle = 0; + IntPtr pchPathUtf8 = Utils.ToUtf8(pchPath); + EBlockQueueError result = FnTable.Create(ref pulQueueHandle, pchPathUtf8, unBlockDataSize, unBlockHeaderSize, unBlockCount); + Marshal.FreeHGlobal(pchPathUtf8); + return result; + } + public EBlockQueueError Connect(ref ulong pulQueueHandle, string pchPath) + { + pulQueueHandle = 0; + IntPtr pchPathUtf8 = Utils.ToUtf8(pchPath); + EBlockQueueError result = FnTable.Connect(ref pulQueueHandle, pchPathUtf8); + Marshal.FreeHGlobal(pchPathUtf8); + return result; + } + public EBlockQueueError Destroy(ulong ulQueueHandle) + { + EBlockQueueError result = FnTable.Destroy(ulQueueHandle); + return result; + } + public EBlockQueueError AcquireWriteOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer) + { + pulBlockHandle = 0; + EBlockQueueError result = FnTable.AcquireWriteOnlyBlock(ulQueueHandle, ref pulBlockHandle, ref ppvBuffer); + return result; + } + public EBlockQueueError ReleaseWriteOnlyBlock(ulong ulQueueHandle, ulong ulBlockHandle) + { + EBlockQueueError result = FnTable.ReleaseWriteOnlyBlock(ulQueueHandle, ulBlockHandle); + return result; + } + public EBlockQueueError WaitAndAcquireReadOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer, EBlockQueueReadType eReadType, uint unTimeoutMs) + { + pulBlockHandle = 0; + EBlockQueueError result = FnTable.WaitAndAcquireReadOnlyBlock(ulQueueHandle, ref pulBlockHandle, ref ppvBuffer, eReadType, unTimeoutMs); + return result; + } + public EBlockQueueError AcquireReadOnlyBlock(ulong ulQueueHandle, ref ulong pulBlockHandle, ref IntPtr ppvBuffer, EBlockQueueReadType eReadType) + { + pulBlockHandle = 0; + EBlockQueueError result = FnTable.AcquireReadOnlyBlock(ulQueueHandle, ref pulBlockHandle, ref ppvBuffer, eReadType); + return result; + } + public EBlockQueueError ReleaseReadOnlyBlock(ulong ulQueueHandle, ulong ulBlockHandle) + { + EBlockQueueError result = FnTable.ReleaseReadOnlyBlock(ulQueueHandle, ulBlockHandle); + return result; + } + public EBlockQueueError QueueHasReader(ulong ulQueueHandle, ref bool pbHasReaders) + { + pbHasReaders = false; + EBlockQueueError result = FnTable.QueueHasReader(ulQueueHandle, ref pbHasReaders); + return result; + } + } + + + public class OpenVRInterop + { + [DllImport("openvr_api", EntryPoint = "VR_InitInternal", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType); + [DllImport("openvr_api", EntryPoint = "VR_InitInternal2", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType, [In, MarshalAs(UnmanagedType.LPStr)] string pStartupInfo); + [DllImport("openvr_api", EntryPoint = "VR_ShutdownInternal", CallingConvention = CallingConvention.Cdecl)] + internal static extern void ShutdownInternal(); + [DllImport("openvr_api", EntryPoint = "VR_IsHmdPresent", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsHmdPresent(); + [DllImport("openvr_api", EntryPoint = "VR_IsRuntimeInstalled", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsRuntimeInstalled(); + [DllImport("openvr_api", EntryPoint = "VR_RuntimePath", CallingConvention = CallingConvention.Cdecl)] + internal static extern string RuntimePath(); + [DllImport("openvr_api", EntryPoint = "VR_GetRuntimePath", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool GetRuntimePath(System.Text.StringBuilder pchPathBuffer, uint unBufferSize, ref uint punRequiredBufferSize); + [DllImport("openvr_api", EntryPoint = "VR_GetStringForHmdError", CallingConvention = CallingConvention.Cdecl)] + internal static extern IntPtr GetStringForHmdError(EVRInitError error); + [DllImport("openvr_api", EntryPoint = "VR_GetGenericInterface", CallingConvention = CallingConvention.Cdecl)] + internal static extern IntPtr GetGenericInterface([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion, ref EVRInitError peError); + [DllImport("openvr_api", EntryPoint = "VR_IsInterfaceVersionValid", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsInterfaceVersionValid([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion); + [DllImport("openvr_api", EntryPoint = "VR_GetInitToken", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint GetInitToken(); + } + + + public enum EVREye + { + Eye_Left = 0, + Eye_Right = 1, + } + public enum ETextureType + { + Invalid = -1, + DirectX = 0, + OpenGL = 1, + Vulkan = 2, + IOSurface = 3, + DirectX12 = 4, + DXGISharedHandle = 5, + Metal = 6, + } + public enum EColorSpace + { + Auto = 0, + Gamma = 1, + Linear = 2, + } + public enum ETrackingResult + { + Uninitialized = 1, + Calibrating_InProgress = 100, + Calibrating_OutOfRange = 101, + Running_OK = 200, + Running_OutOfRange = 201, + Fallback_RotationOnly = 300, + } + public enum ETrackedDeviceClass + { + Invalid = 0, + HMD = 1, + Controller = 2, + GenericTracker = 3, + TrackingReference = 4, + DisplayRedirect = 5, + Max = 6, + } + public enum ETrackedControllerRole + { + Invalid = 0, + LeftHand = 1, + RightHand = 2, + OptOut = 3, + Treadmill = 4, + Stylus = 5, + Max = 5, + } + public enum ETrackingUniverseOrigin + { + TrackingUniverseSeated = 0, + TrackingUniverseStanding = 1, + TrackingUniverseRawAndUncalibrated = 2, + } + public enum EAdditionalRadioFeatures + { + None = 0, + HTCLinkBox = 1, + InternalDongle = 2, + ExternalDongle = 4, + } + public enum ETrackedDeviceProperty + { + Prop_Invalid = 0, + Prop_TrackingSystemName_String = 1000, + Prop_ModelNumber_String = 1001, + Prop_SerialNumber_String = 1002, + Prop_RenderModelName_String = 1003, + Prop_WillDriftInYaw_Bool = 1004, + Prop_ManufacturerName_String = 1005, + Prop_TrackingFirmwareVersion_String = 1006, + Prop_HardwareRevision_String = 1007, + Prop_AllWirelessDongleDescriptions_String = 1008, + Prop_ConnectedWirelessDongle_String = 1009, + Prop_DeviceIsWireless_Bool = 1010, + Prop_DeviceIsCharging_Bool = 1011, + Prop_DeviceBatteryPercentage_Float = 1012, + Prop_StatusDisplayTransform_Matrix34 = 1013, + Prop_Firmware_UpdateAvailable_Bool = 1014, + Prop_Firmware_ManualUpdate_Bool = 1015, + Prop_Firmware_ManualUpdateURL_String = 1016, + Prop_HardwareRevision_Uint64 = 1017, + Prop_FirmwareVersion_Uint64 = 1018, + Prop_FPGAVersion_Uint64 = 1019, + Prop_VRCVersion_Uint64 = 1020, + Prop_RadioVersion_Uint64 = 1021, + Prop_DongleVersion_Uint64 = 1022, + Prop_BlockServerShutdown_Bool = 1023, + Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024, + Prop_ContainsProximitySensor_Bool = 1025, + Prop_DeviceProvidesBatteryStatus_Bool = 1026, + Prop_DeviceCanPowerOff_Bool = 1027, + Prop_Firmware_ProgrammingTarget_String = 1028, + Prop_DeviceClass_Int32 = 1029, + Prop_HasCamera_Bool = 1030, + Prop_DriverVersion_String = 1031, + Prop_Firmware_ForceUpdateRequired_Bool = 1032, + Prop_ViveSystemButtonFixRequired_Bool = 1033, + Prop_ParentDriver_Uint64 = 1034, + Prop_ResourceRoot_String = 1035, + Prop_RegisteredDeviceType_String = 1036, + Prop_InputProfilePath_String = 1037, + Prop_NeverTracked_Bool = 1038, + Prop_NumCameras_Int32 = 1039, + Prop_CameraFrameLayout_Int32 = 1040, + Prop_CameraStreamFormat_Int32 = 1041, + Prop_AdditionalDeviceSettingsPath_String = 1042, + Prop_Identifiable_Bool = 1043, + Prop_BootloaderVersion_Uint64 = 1044, + Prop_AdditionalSystemReportData_String = 1045, + Prop_CompositeFirmwareVersion_String = 1046, + Prop_Firmware_RemindUpdate_Bool = 1047, + Prop_PeripheralApplicationVersion_Uint64 = 1048, + Prop_ManufacturerSerialNumber_String = 1049, + Prop_ComputedSerialNumber_String = 1050, + Prop_EstimatedDeviceFirstUseTime_Int32 = 1051, + Prop_ReportsTimeSinceVSync_Bool = 2000, + Prop_SecondsFromVsyncToPhotons_Float = 2001, + Prop_DisplayFrequency_Float = 2002, + Prop_UserIpdMeters_Float = 2003, + Prop_CurrentUniverseId_Uint64 = 2004, + Prop_PreviousUniverseId_Uint64 = 2005, + Prop_DisplayFirmwareVersion_Uint64 = 2006, + Prop_IsOnDesktop_Bool = 2007, + Prop_DisplayMCType_Int32 = 2008, + Prop_DisplayMCOffset_Float = 2009, + Prop_DisplayMCScale_Float = 2010, + Prop_EdidVendorID_Int32 = 2011, + Prop_DisplayMCImageLeft_String = 2012, + Prop_DisplayMCImageRight_String = 2013, + Prop_DisplayGCBlackClamp_Float = 2014, + Prop_EdidProductID_Int32 = 2015, + Prop_CameraToHeadTransform_Matrix34 = 2016, + Prop_DisplayGCType_Int32 = 2017, + Prop_DisplayGCOffset_Float = 2018, + Prop_DisplayGCScale_Float = 2019, + Prop_DisplayGCPrescale_Float = 2020, + Prop_DisplayGCImage_String = 2021, + Prop_LensCenterLeftU_Float = 2022, + Prop_LensCenterLeftV_Float = 2023, + Prop_LensCenterRightU_Float = 2024, + Prop_LensCenterRightV_Float = 2025, + Prop_UserHeadToEyeDepthMeters_Float = 2026, + Prop_CameraFirmwareVersion_Uint64 = 2027, + Prop_CameraFirmwareDescription_String = 2028, + Prop_DisplayFPGAVersion_Uint64 = 2029, + Prop_DisplayBootloaderVersion_Uint64 = 2030, + Prop_DisplayHardwareVersion_Uint64 = 2031, + Prop_AudioFirmwareVersion_Uint64 = 2032, + Prop_CameraCompatibilityMode_Int32 = 2033, + Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034, + Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035, + Prop_DisplaySuppressed_Bool = 2036, + Prop_DisplayAllowNightMode_Bool = 2037, + Prop_DisplayMCImageWidth_Int32 = 2038, + Prop_DisplayMCImageHeight_Int32 = 2039, + Prop_DisplayMCImageNumChannels_Int32 = 2040, + Prop_DisplayMCImageData_Binary = 2041, + Prop_SecondsFromPhotonsToVblank_Float = 2042, + Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043, + Prop_DisplayDebugMode_Bool = 2044, + Prop_GraphicsAdapterLuid_Uint64 = 2045, + Prop_DriverProvidedChaperonePath_String = 2048, + Prop_ExpectedTrackingReferenceCount_Int32 = 2049, + Prop_ExpectedControllerCount_Int32 = 2050, + Prop_NamedIconPathControllerLeftDeviceOff_String = 2051, + Prop_NamedIconPathControllerRightDeviceOff_String = 2052, + Prop_NamedIconPathTrackingReferenceDeviceOff_String = 2053, + Prop_DoNotApplyPrediction_Bool = 2054, + Prop_CameraToHeadTransforms_Matrix34_Array = 2055, + Prop_DistortionMeshResolution_Int32 = 2056, + Prop_DriverIsDrawingControllers_Bool = 2057, + Prop_DriverRequestsApplicationPause_Bool = 2058, + Prop_DriverRequestsReducedRendering_Bool = 2059, + Prop_MinimumIpdStepMeters_Float = 2060, + Prop_AudioBridgeFirmwareVersion_Uint64 = 2061, + Prop_ImageBridgeFirmwareVersion_Uint64 = 2062, + Prop_ImuToHeadTransform_Matrix34 = 2063, + Prop_ImuFactoryGyroBias_Vector3 = 2064, + Prop_ImuFactoryGyroScale_Vector3 = 2065, + Prop_ImuFactoryAccelerometerBias_Vector3 = 2066, + Prop_ImuFactoryAccelerometerScale_Vector3 = 2067, + Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069, + Prop_AdditionalRadioFeatures_Uint64 = 2070, + Prop_CameraWhiteBalance_Vector4_Array = 2071, + Prop_CameraDistortionFunction_Int32_Array = 2072, + Prop_CameraDistortionCoefficients_Float_Array = 2073, + Prop_ExpectedControllerType_String = 2074, + Prop_HmdTrackingStyle_Int32 = 2075, + Prop_DriverProvidedChaperoneVisibility_Bool = 2076, + Prop_HmdColumnCorrectionSettingPrefix_String = 2077, + Prop_CameraSupportsCompatibilityModes_Bool = 2078, + Prop_SupportsRoomViewDepthProjection_Bool = 2079, + Prop_DisplayAvailableFrameRates_Float_Array = 2080, + Prop_DisplaySupportsMultipleFramerates_Bool = 2081, + Prop_DisplayColorMultLeft_Vector3 = 2082, + Prop_DisplayColorMultRight_Vector3 = 2083, + Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084, + Prop_DisplaySupportsAnalogGain_Bool = 2085, + Prop_DisplayMinAnalogGain_Float = 2086, + Prop_DisplayMaxAnalogGain_Float = 2087, + Prop_CameraExposureTime_Float = 2088, + Prop_CameraGlobalGain_Float = 2089, + Prop_DashboardScale_Float = 2091, + Prop_IpdUIRangeMinMeters_Float = 2100, + Prop_IpdUIRangeMaxMeters_Float = 2101, + Prop_Hmd_SupportsHDCP14LegacyCompat_Bool = 2102, + Prop_Hmd_SupportsMicMonitoring_Bool = 2103, + Prop_DriverRequestedMuraCorrectionMode_Int32 = 2200, + Prop_DriverRequestedMuraFeather_InnerLeft_Int32 = 2201, + Prop_DriverRequestedMuraFeather_InnerRight_Int32 = 2202, + Prop_DriverRequestedMuraFeather_InnerTop_Int32 = 2203, + Prop_DriverRequestedMuraFeather_InnerBottom_Int32 = 2204, + Prop_DriverRequestedMuraFeather_OuterLeft_Int32 = 2205, + Prop_DriverRequestedMuraFeather_OuterRight_Int32 = 2206, + Prop_DriverRequestedMuraFeather_OuterTop_Int32 = 2207, + Prop_DriverRequestedMuraFeather_OuterBottom_Int32 = 2208, + Prop_Audio_DefaultPlaybackDeviceId_String = 2300, + Prop_Audio_DefaultRecordingDeviceId_String = 2301, + Prop_Audio_DefaultPlaybackDeviceVolume_Float = 2302, + Prop_Audio_SupportsDualSpeakerAndJackOutput_Bool = 2303, + Prop_AttachedDeviceId_String = 3000, + Prop_SupportedButtons_Uint64 = 3001, + Prop_Axis0Type_Int32 = 3002, + Prop_Axis1Type_Int32 = 3003, + Prop_Axis2Type_Int32 = 3004, + Prop_Axis3Type_Int32 = 3005, + Prop_Axis4Type_Int32 = 3006, + Prop_ControllerRoleHint_Int32 = 3007, + Prop_FieldOfViewLeftDegrees_Float = 4000, + Prop_FieldOfViewRightDegrees_Float = 4001, + Prop_FieldOfViewTopDegrees_Float = 4002, + Prop_FieldOfViewBottomDegrees_Float = 4003, + Prop_TrackingRangeMinimumMeters_Float = 4004, + Prop_TrackingRangeMaximumMeters_Float = 4005, + Prop_ModeLabel_String = 4006, + Prop_CanWirelessIdentify_Bool = 4007, + Prop_Nonce_Int32 = 4008, + Prop_IconPathName_String = 5000, + Prop_NamedIconPathDeviceOff_String = 5001, + Prop_NamedIconPathDeviceSearching_String = 5002, + Prop_NamedIconPathDeviceSearchingAlert_String = 5003, + Prop_NamedIconPathDeviceReady_String = 5004, + Prop_NamedIconPathDeviceReadyAlert_String = 5005, + Prop_NamedIconPathDeviceNotReady_String = 5006, + Prop_NamedIconPathDeviceStandby_String = 5007, + Prop_NamedIconPathDeviceAlertLow_String = 5008, + Prop_NamedIconPathDeviceStandbyAlert_String = 5009, + Prop_DisplayHiddenArea_Binary_Start = 5100, + Prop_DisplayHiddenArea_Binary_End = 5150, + Prop_ParentContainer = 5151, + Prop_OverrideContainer_Uint64 = 5152, + Prop_UserConfigPath_String = 6000, + Prop_InstallPath_String = 6001, + Prop_HasDisplayComponent_Bool = 6002, + Prop_HasControllerComponent_Bool = 6003, + Prop_HasCameraComponent_Bool = 6004, + Prop_HasDriverDirectModeComponent_Bool = 6005, + Prop_HasVirtualDisplayComponent_Bool = 6006, + Prop_HasSpatialAnchorsSupport_Bool = 6007, + Prop_ControllerType_String = 7000, + Prop_ControllerHandSelectionPriority_Int32 = 7002, + Prop_VendorSpecific_Reserved_Start = 10000, + Prop_VendorSpecific_Reserved_End = 10999, + Prop_TrackedDeviceProperty_Max = 1000000, + } + public enum ETrackedPropertyError + { + TrackedProp_Success = 0, + TrackedProp_WrongDataType = 1, + TrackedProp_WrongDeviceClass = 2, + TrackedProp_BufferTooSmall = 3, + TrackedProp_UnknownProperty = 4, + TrackedProp_InvalidDevice = 5, + TrackedProp_CouldNotContactServer = 6, + TrackedProp_ValueNotProvidedByDevice = 7, + TrackedProp_StringExceedsMaximumLength = 8, + TrackedProp_NotYetAvailable = 9, + TrackedProp_PermissionDenied = 10, + TrackedProp_InvalidOperation = 11, + TrackedProp_CannotWriteToWildcards = 12, + TrackedProp_IPCReadFailure = 13, + TrackedProp_OutOfMemory = 14, + TrackedProp_InvalidContainer = 15, + } + public enum EHmdTrackingStyle + { + Unknown = 0, + Lighthouse = 1, + OutsideInCameras = 2, + InsideOutCameras = 3, + } + public enum EVRSubmitFlags + { + Submit_Default = 0, + Submit_LensDistortionAlreadyApplied = 1, + Submit_GlRenderBuffer = 2, + Submit_Reserved = 4, + Submit_TextureWithPose = 8, + Submit_TextureWithDepth = 16, + Submit_FrameDiscontinuty = 32, + Submit_VulkanTextureWithArrayData = 64, + Submit_GlArrayTexture = 128, + Submit_Reserved2 = 32768, + } + public enum EVRState + { + Undefined = -1, + Off = 0, + Searching = 1, + Searching_Alert = 2, + Ready = 3, + Ready_Alert = 4, + NotReady = 5, + Standby = 6, + Ready_Alert_Low = 7, + } + public enum EVREventType + { + VREvent_None = 0, + VREvent_TrackedDeviceActivated = 100, + VREvent_TrackedDeviceDeactivated = 101, + VREvent_TrackedDeviceUpdated = 102, + VREvent_TrackedDeviceUserInteractionStarted = 103, + VREvent_TrackedDeviceUserInteractionEnded = 104, + VREvent_IpdChanged = 105, + VREvent_EnterStandbyMode = 106, + VREvent_LeaveStandbyMode = 107, + VREvent_TrackedDeviceRoleChanged = 108, + VREvent_WatchdogWakeUpRequested = 109, + VREvent_LensDistortionChanged = 110, + VREvent_PropertyChanged = 111, + VREvent_WirelessDisconnect = 112, + VREvent_WirelessReconnect = 113, + VREvent_ButtonPress = 200, + VREvent_ButtonUnpress = 201, + VREvent_ButtonTouch = 202, + VREvent_ButtonUntouch = 203, + VREvent_Modal_Cancel = 257, + VREvent_MouseMove = 300, + VREvent_MouseButtonDown = 301, + VREvent_MouseButtonUp = 302, + VREvent_FocusEnter = 303, + VREvent_FocusLeave = 304, + VREvent_ScrollDiscrete = 305, + VREvent_TouchPadMove = 306, + VREvent_OverlayFocusChanged = 307, + VREvent_ReloadOverlays = 308, + VREvent_ScrollSmooth = 309, + VREvent_LockMousePosition = 310, + VREvent_UnlockMousePosition = 311, + VREvent_InputFocusCaptured = 400, + VREvent_InputFocusReleased = 401, + VREvent_SceneApplicationChanged = 404, + VREvent_SceneFocusChanged = 405, + VREvent_InputFocusChanged = 406, + VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, + VREvent_ActionBindingReloaded = 409, + VREvent_HideRenderModels = 410, + VREvent_ShowRenderModels = 411, + VREvent_SceneApplicationStateChanged = 412, + VREvent_ConsoleOpened = 420, + VREvent_ConsoleClosed = 421, + VREvent_OverlayShown = 500, + VREvent_OverlayHidden = 501, + VREvent_DashboardActivated = 502, + VREvent_DashboardDeactivated = 503, + VREvent_DashboardRequested = 505, + VREvent_ResetDashboard = 506, + VREvent_ImageLoaded = 508, + VREvent_ShowKeyboard = 509, + VREvent_HideKeyboard = 510, + VREvent_OverlayGamepadFocusGained = 511, + VREvent_OverlayGamepadFocusLost = 512, + VREvent_OverlaySharedTextureChanged = 513, + VREvent_ScreenshotTriggered = 516, + VREvent_ImageFailed = 517, + VREvent_DashboardOverlayCreated = 518, + VREvent_SwitchGamepadFocus = 519, + VREvent_RequestScreenshot = 520, + VREvent_ScreenshotTaken = 521, + VREvent_ScreenshotFailed = 522, + VREvent_SubmitScreenshotToDashboard = 523, + VREvent_ScreenshotProgressToDashboard = 524, + VREvent_PrimaryDashboardDeviceChanged = 525, + VREvent_RoomViewShown = 526, + VREvent_RoomViewHidden = 527, + VREvent_ShowUI = 528, + VREvent_ShowDevTools = 529, + VREvent_DesktopViewUpdating = 530, + VREvent_DesktopViewReady = 531, + VREvent_Notification_Shown = 600, + VREvent_Notification_Hidden = 601, + VREvent_Notification_BeginInteraction = 602, + VREvent_Notification_Destroyed = 603, + VREvent_Quit = 700, + VREvent_ProcessQuit = 701, + VREvent_QuitAcknowledged = 703, + VREvent_DriverRequestedQuit = 704, + VREvent_RestartRequested = 705, + VREvent_ChaperoneDataHasChanged = 800, + VREvent_ChaperoneUniverseHasChanged = 801, + VREvent_ChaperoneTempDataHasChanged = 802, + VREvent_ChaperoneSettingsHaveChanged = 803, + VREvent_SeatedZeroPoseReset = 804, + VREvent_ChaperoneFlushCache = 805, + VREvent_ChaperoneRoomSetupStarting = 806, + VREvent_ChaperoneRoomSetupFinished = 807, + VREvent_StandingZeroPoseReset = 808, + VREvent_AudioSettingsHaveChanged = 820, + VREvent_BackgroundSettingHasChanged = 850, + VREvent_CameraSettingsHaveChanged = 851, + VREvent_ReprojectionSettingHasChanged = 852, + VREvent_ModelSkinSettingsHaveChanged = 853, + VREvent_EnvironmentSettingsHaveChanged = 854, + VREvent_PowerSettingsHaveChanged = 855, + VREvent_EnableHomeAppSettingsHaveChanged = 856, + VREvent_SteamVRSectionSettingChanged = 857, + VREvent_LighthouseSectionSettingChanged = 858, + VREvent_NullSectionSettingChanged = 859, + VREvent_UserInterfaceSectionSettingChanged = 860, + VREvent_NotificationsSectionSettingChanged = 861, + VREvent_KeyboardSectionSettingChanged = 862, + VREvent_PerfSectionSettingChanged = 863, + VREvent_DashboardSectionSettingChanged = 864, + VREvent_WebInterfaceSectionSettingChanged = 865, + VREvent_TrackersSectionSettingChanged = 866, + VREvent_LastKnownSectionSettingChanged = 867, + VREvent_DismissedWarningsSectionSettingChanged = 868, + VREvent_GpuSpeedSectionSettingChanged = 869, + VREvent_WindowsMRSectionSettingChanged = 870, + VREvent_OtherSectionSettingChanged = 871, + VREvent_StatusUpdate = 900, + VREvent_WebInterface_InstallDriverCompleted = 950, + VREvent_MCImageUpdated = 1000, + VREvent_FirmwareUpdateStarted = 1100, + VREvent_FirmwareUpdateFinished = 1101, + VREvent_KeyboardClosed = 1200, + VREvent_KeyboardCharInput = 1201, + VREvent_KeyboardDone = 1202, + VREvent_ApplicationListUpdated = 1303, + VREvent_ApplicationMimeTypeLoad = 1304, + VREvent_ProcessConnected = 1306, + VREvent_ProcessDisconnected = 1307, + VREvent_Compositor_ChaperoneBoundsShown = 1410, + VREvent_Compositor_ChaperoneBoundsHidden = 1411, + VREvent_Compositor_DisplayDisconnected = 1412, + VREvent_Compositor_DisplayReconnected = 1413, + VREvent_Compositor_HDCPError = 1414, + VREvent_Compositor_ApplicationNotResponding = 1415, + VREvent_Compositor_ApplicationResumed = 1416, + VREvent_Compositor_OutOfVideoMemory = 1417, + VREvent_Compositor_DisplayModeNotSupported = 1418, + VREvent_Compositor_StageOverrideReady = 1419, + VREvent_TrackedCamera_StartVideoStream = 1500, + VREvent_TrackedCamera_StopVideoStream = 1501, + VREvent_TrackedCamera_PauseVideoStream = 1502, + VREvent_TrackedCamera_ResumeVideoStream = 1503, + VREvent_TrackedCamera_EditingSurface = 1550, + VREvent_PerformanceTest_EnableCapture = 1600, + VREvent_PerformanceTest_DisableCapture = 1601, + VREvent_PerformanceTest_FidelityLevel = 1602, + VREvent_MessageOverlay_Closed = 1650, + VREvent_MessageOverlayCloseRequested = 1651, + VREvent_Input_HapticVibration = 1700, + VREvent_Input_BindingLoadFailed = 1701, + VREvent_Input_BindingLoadSuccessful = 1702, + VREvent_Input_ActionManifestReloaded = 1703, + VREvent_Input_ActionManifestLoadFailed = 1704, + VREvent_Input_ProgressUpdate = 1705, + VREvent_Input_TrackerActivated = 1706, + VREvent_Input_BindingsUpdated = 1707, + VREvent_Input_BindingSubscriptionChanged = 1708, + VREvent_SpatialAnchors_PoseUpdated = 1800, + VREvent_SpatialAnchors_DescriptorUpdated = 1801, + VREvent_SpatialAnchors_RequestPoseUpdate = 1802, + VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, + VREvent_SystemReport_Started = 1900, + VREvent_Monitor_ShowHeadsetView = 2000, + VREvent_Monitor_HideHeadsetView = 2001, + VREvent_VendorSpecific_Reserved_Start = 10000, + VREvent_VendorSpecific_Reserved_End = 19999, + } + public enum EDeviceActivityLevel + { + k_EDeviceActivityLevel_Unknown = -1, + k_EDeviceActivityLevel_Idle = 0, + k_EDeviceActivityLevel_UserInteraction = 1, + k_EDeviceActivityLevel_UserInteraction_Timeout = 2, + k_EDeviceActivityLevel_Standby = 3, + k_EDeviceActivityLevel_Idle_Timeout = 4, + } + public enum EVRButtonId + { + k_EButton_System = 0, + k_EButton_ApplicationMenu = 1, + k_EButton_Grip = 2, + k_EButton_DPad_Left = 3, + k_EButton_DPad_Up = 4, + k_EButton_DPad_Right = 5, + k_EButton_DPad_Down = 6, + k_EButton_A = 7, + k_EButton_ProximitySensor = 31, + k_EButton_Axis0 = 32, + k_EButton_Axis1 = 33, + k_EButton_Axis2 = 34, + k_EButton_Axis3 = 35, + k_EButton_Axis4 = 36, + k_EButton_SteamVR_Touchpad = 32, + k_EButton_SteamVR_Trigger = 33, + k_EButton_Dashboard_Back = 2, + k_EButton_IndexController_A = 2, + k_EButton_IndexController_B = 1, + k_EButton_IndexController_JoyStick = 35, + k_EButton_Max = 64, + } + public enum EVRMouseButton + { + Left = 1, + Right = 2, + Middle = 4, + } + public enum EShowUIType + { + ShowUI_ControllerBinding = 0, + ShowUI_ManageTrackers = 1, + ShowUI_Pairing = 3, + ShowUI_Settings = 4, + ShowUI_DebugCommands = 5, + ShowUI_FullControllerBinding = 6, + ShowUI_ManageDrivers = 7, + } + public enum EHDCPError + { + None = 0, + LinkLost = 1, + Tampered = 2, + DeviceRevoked = 3, + Unknown = 4, + } + public enum EVRComponentProperty + { + IsStatic = 1, + IsVisible = 2, + IsTouched = 4, + IsPressed = 8, + IsScrolled = 16, + IsHighlighted = 32, + } + public enum EVRInputError + { + None = 0, + NameNotFound = 1, + WrongType = 2, + InvalidHandle = 3, + InvalidParam = 4, + NoSteam = 5, + MaxCapacityReached = 6, + IPCError = 7, + NoActiveActionSet = 8, + InvalidDevice = 9, + InvalidSkeleton = 10, + InvalidBoneCount = 11, + InvalidCompressedData = 12, + NoData = 13, + BufferTooSmall = 14, + MismatchedActionManifest = 15, + MissingSkeletonData = 16, + InvalidBoneIndex = 17, + InvalidPriority = 18, + PermissionDenied = 19, + InvalidRenderModel = 20, + } + public enum EVRSpatialAnchorError + { + Success = 0, + Internal = 1, + UnknownHandle = 2, + ArrayTooSmall = 3, + InvalidDescriptorChar = 4, + NotYetAvailable = 5, + NotAvailableInThisUniverse = 6, + PermanentlyUnavailable = 7, + WrongDriver = 8, + DescriptorTooLong = 9, + Unknown = 10, + NoRoomCalibration = 11, + InvalidArgument = 12, + UnknownDriver = 13, + } + public enum EHiddenAreaMeshType + { + k_eHiddenAreaMesh_Standard = 0, + k_eHiddenAreaMesh_Inverse = 1, + k_eHiddenAreaMesh_LineLoop = 2, + k_eHiddenAreaMesh_Max = 3, + } + public enum EVRControllerAxisType + { + k_eControllerAxis_None = 0, + k_eControllerAxis_TrackPad = 1, + k_eControllerAxis_Joystick = 2, + k_eControllerAxis_Trigger = 3, + } + public enum EVRControllerEventOutputType + { + ControllerEventOutput_OSEvents = 0, + ControllerEventOutput_VREvents = 1, + } + public enum ECollisionBoundsStyle + { + COLLISION_BOUNDS_STYLE_BEGINNER = 0, + COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1, + COLLISION_BOUNDS_STYLE_SQUARES = 2, + COLLISION_BOUNDS_STYLE_ADVANCED = 3, + COLLISION_BOUNDS_STYLE_NONE = 4, + COLLISION_BOUNDS_STYLE_COUNT = 5, + } + public enum EVROverlayError + { + None = 0, + UnknownOverlay = 10, + InvalidHandle = 11, + PermissionDenied = 12, + OverlayLimitExceeded = 13, + WrongVisibilityType = 14, + KeyTooLong = 15, + NameTooLong = 16, + KeyInUse = 17, + WrongTransformType = 18, + InvalidTrackedDevice = 19, + InvalidParameter = 20, + ThumbnailCantBeDestroyed = 21, + ArrayTooSmall = 22, + RequestFailed = 23, + InvalidTexture = 24, + UnableToLoadFile = 25, + KeyboardAlreadyInUse = 26, + NoNeighbor = 27, + TooManyMaskPrimitives = 29, + BadMaskPrimitive = 30, + TextureAlreadyLocked = 31, + TextureLockCapacityReached = 32, + TextureNotLocked = 33, + } + public enum EVRApplicationType + { + VRApplication_Other = 0, + VRApplication_Scene = 1, + VRApplication_Overlay = 2, + VRApplication_Background = 3, + VRApplication_Utility = 4, + VRApplication_VRMonitor = 5, + VRApplication_SteamWatchdog = 6, + VRApplication_Bootstrapper = 7, + VRApplication_WebHelper = 8, + VRApplication_OpenXRInstance = 9, + VRApplication_OpenXRScene = 10, + VRApplication_OpenXROverlay = 11, + VRApplication_Prism = 12, + VRApplication_Max = 13, + } + public enum EVRFirmwareError + { + None = 0, + Success = 1, + Fail = 2, + } + public enum EVRNotificationError + { + OK = 0, + InvalidNotificationId = 100, + NotificationQueueFull = 101, + InvalidOverlayHandle = 102, + SystemWithUserValueAlreadyExists = 103, + } + public enum EVRSkeletalMotionRange + { + WithController = 0, + WithoutController = 1, + } + public enum EVRSkeletalTrackingLevel + { + VRSkeletalTracking_Estimated = 0, + VRSkeletalTracking_Partial = 1, + VRSkeletalTracking_Full = 2, + Count = 3, + Max = 2, + } + public enum EVRInitError + { + None = 0, + Unknown = 1, + Init_InstallationNotFound = 100, + Init_InstallationCorrupt = 101, + Init_VRClientDLLNotFound = 102, + Init_FileNotFound = 103, + Init_FactoryNotFound = 104, + Init_InterfaceNotFound = 105, + Init_InvalidInterface = 106, + Init_UserConfigDirectoryInvalid = 107, + Init_HmdNotFound = 108, + Init_NotInitialized = 109, + Init_PathRegistryNotFound = 110, + Init_NoConfigPath = 111, + Init_NoLogPath = 112, + Init_PathRegistryNotWritable = 113, + Init_AppInfoInitFailed = 114, + Init_Retry = 115, + Init_InitCanceledByUser = 116, + Init_AnotherAppLaunching = 117, + Init_SettingsInitFailed = 118, + Init_ShuttingDown = 119, + Init_TooManyObjects = 120, + Init_NoServerForBackgroundApp = 121, + Init_NotSupportedWithCompositor = 122, + Init_NotAvailableToUtilityApps = 123, + Init_Internal = 124, + Init_HmdDriverIdIsNone = 125, + Init_HmdNotFoundPresenceFailed = 126, + Init_VRMonitorNotFound = 127, + Init_VRMonitorStartupFailed = 128, + Init_LowPowerWatchdogNotSupported = 129, + Init_InvalidApplicationType = 130, + Init_NotAvailableToWatchdogApps = 131, + Init_WatchdogDisabledInSettings = 132, + Init_VRDashboardNotFound = 133, + Init_VRDashboardStartupFailed = 134, + Init_VRHomeNotFound = 135, + Init_VRHomeStartupFailed = 136, + Init_RebootingBusy = 137, + Init_FirmwareUpdateBusy = 138, + Init_FirmwareRecoveryBusy = 139, + Init_USBServiceBusy = 140, + Init_VRWebHelperStartupFailed = 141, + Init_TrackerManagerInitFailed = 142, + Init_AlreadyRunning = 143, + Init_FailedForVrMonitor = 144, + Init_PropertyManagerInitFailed = 145, + Init_WebServerFailed = 146, + Init_IllegalTypeTransition = 147, + Init_MismatchedRuntimes = 148, + Init_InvalidProcessId = 149, + Init_VRServiceStartupFailed = 150, + Init_PrismNeedsNewDrivers = 151, + Init_PrismStartupTimedOut = 152, + Init_CouldNotStartPrism = 153, + Init_CreateDriverDirectDeviceFailed = 154, + Init_PrismExitedUnexpectedly = 155, + Driver_Failed = 200, + Driver_Unknown = 201, + Driver_HmdUnknown = 202, + Driver_NotLoaded = 203, + Driver_RuntimeOutOfDate = 204, + Driver_HmdInUse = 205, + Driver_NotCalibrated = 206, + Driver_CalibrationInvalid = 207, + Driver_HmdDisplayNotFound = 208, + Driver_TrackedDeviceInterfaceUnknown = 209, + Driver_HmdDriverIdOutOfBounds = 211, + Driver_HmdDisplayMirrored = 212, + Driver_HmdDisplayNotFoundLaptop = 213, + IPC_ServerInitFailed = 300, + IPC_ConnectFailed = 301, + IPC_SharedStateInitFailed = 302, + IPC_CompositorInitFailed = 303, + IPC_MutexInitFailed = 304, + IPC_Failed = 305, + IPC_CompositorConnectFailed = 306, + IPC_CompositorInvalidConnectResponse = 307, + IPC_ConnectFailedAfterMultipleAttempts = 308, + IPC_ConnectFailedAfterTargetExited = 309, + IPC_NamespaceUnavailable = 310, + Compositor_Failed = 400, + Compositor_D3D11HardwareRequired = 401, + Compositor_FirmwareRequiresUpdate = 402, + Compositor_OverlayInitFailed = 403, + Compositor_ScreenshotsInitFailed = 404, + Compositor_UnableToCreateDevice = 405, + Compositor_SharedStateIsNull = 406, + Compositor_NotificationManagerIsNull = 407, + Compositor_ResourceManagerClientIsNull = 408, + Compositor_MessageOverlaySharedStateInitFailure = 409, + Compositor_PropertiesInterfaceIsNull = 410, + Compositor_CreateFullscreenWindowFailed = 411, + Compositor_SettingsInterfaceIsNull = 412, + Compositor_FailedToShowWindow = 413, + Compositor_DistortInterfaceIsNull = 414, + Compositor_DisplayFrequencyFailure = 415, + Compositor_RendererInitializationFailed = 416, + Compositor_DXGIFactoryInterfaceIsNull = 417, + Compositor_DXGIFactoryCreateFailed = 418, + Compositor_DXGIFactoryQueryFailed = 419, + Compositor_InvalidAdapterDesktop = 420, + Compositor_InvalidHmdAttachment = 421, + Compositor_InvalidOutputDesktop = 422, + Compositor_InvalidDeviceProvided = 423, + Compositor_D3D11RendererInitializationFailed = 424, + Compositor_FailedToFindDisplayMode = 425, + Compositor_FailedToCreateSwapChain = 426, + Compositor_FailedToGetBackBuffer = 427, + Compositor_FailedToCreateRenderTarget = 428, + Compositor_FailedToCreateDXGI2SwapChain = 429, + Compositor_FailedtoGetDXGI2BackBuffer = 430, + Compositor_FailedToCreateDXGI2RenderTarget = 431, + Compositor_FailedToGetDXGIDeviceInterface = 432, + Compositor_SelectDisplayMode = 433, + Compositor_FailedToCreateNvAPIRenderTargets = 434, + Compositor_NvAPISetDisplayMode = 435, + Compositor_FailedToCreateDirectModeDisplay = 436, + Compositor_InvalidHmdPropertyContainer = 437, + Compositor_UpdateDisplayFrequency = 438, + Compositor_CreateRasterizerState = 439, + Compositor_CreateWireframeRasterizerState = 440, + Compositor_CreateSamplerState = 441, + Compositor_CreateClampToBorderSamplerState = 442, + Compositor_CreateAnisoSamplerState = 443, + Compositor_CreateOverlaySamplerState = 444, + Compositor_CreatePanoramaSamplerState = 445, + Compositor_CreateFontSamplerState = 446, + Compositor_CreateNoBlendState = 447, + Compositor_CreateBlendState = 448, + Compositor_CreateAlphaBlendState = 449, + Compositor_CreateBlendStateMaskR = 450, + Compositor_CreateBlendStateMaskG = 451, + Compositor_CreateBlendStateMaskB = 452, + Compositor_CreateDepthStencilState = 453, + Compositor_CreateDepthStencilStateNoWrite = 454, + Compositor_CreateDepthStencilStateNoDepth = 455, + Compositor_CreateFlushTexture = 456, + Compositor_CreateDistortionSurfaces = 457, + Compositor_CreateConstantBuffer = 458, + Compositor_CreateHmdPoseConstantBuffer = 459, + Compositor_CreateHmdPoseStagingConstantBuffer = 460, + Compositor_CreateSharedFrameInfoConstantBuffer = 461, + Compositor_CreateOverlayConstantBuffer = 462, + Compositor_CreateSceneTextureIndexConstantBuffer = 463, + Compositor_CreateReadableSceneTextureIndexConstantBuffer = 464, + Compositor_CreateLayerGraphicsTextureIndexConstantBuffer = 465, + Compositor_CreateLayerComputeTextureIndexConstantBuffer = 466, + Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer = 467, + Compositor_CreateComputeHmdPoseConstantBuffer = 468, + Compositor_CreateGeomConstantBuffer = 469, + Compositor_CreatePanelMaskConstantBuffer = 470, + Compositor_CreatePixelSimUBO = 471, + Compositor_CreateMSAARenderTextures = 472, + Compositor_CreateResolveRenderTextures = 473, + Compositor_CreateComputeResolveRenderTextures = 474, + Compositor_CreateDriverDirectModeResolveTextures = 475, + Compositor_OpenDriverDirectModeResolveTextures = 476, + Compositor_CreateFallbackSyncTexture = 477, + Compositor_ShareFallbackSyncTexture = 478, + Compositor_CreateOverlayIndexBuffer = 479, + Compositor_CreateOverlayVertexBuffer = 480, + Compositor_CreateTextVertexBuffer = 481, + Compositor_CreateTextIndexBuffer = 482, + Compositor_CreateMirrorTextures = 483, + Compositor_CreateLastFrameRenderTexture = 484, + Compositor_CreateMirrorOverlay = 485, + Compositor_FailedToCreateVirtualDisplayBackbuffer = 486, + Compositor_DisplayModeNotSupported = 487, + Compositor_CreateOverlayInvalidCall = 488, + Compositor_CreateOverlayAlreadyInitialized = 489, + Compositor_FailedToCreateMailbox = 490, + Compositor_WindowInterfaceIsNull = 491, + Compositor_SystemLayerCreateInstance = 492, + Compositor_SystemLayerCreateSession = 493, + VendorSpecific_UnableToConnectToOculusRuntime = 1000, + VendorSpecific_WindowsNotInDevMode = 1001, + VendorSpecific_HmdFound_CantOpenDevice = 1101, + VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102, + VendorSpecific_HmdFound_NoStoredConfig = 1103, + VendorSpecific_HmdFound_ConfigTooBig = 1104, + VendorSpecific_HmdFound_ConfigTooSmall = 1105, + VendorSpecific_HmdFound_UnableToInitZLib = 1106, + VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107, + VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108, + VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109, + VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110, + VendorSpecific_HmdFound_UserDataAddressRange = 1111, + VendorSpecific_HmdFound_UserDataError = 1112, + VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113, + VendorSpecific_OculusRuntimeBadInstall = 1114, + Steam_SteamInstallationNotFound = 2000, + LastError = 2001, + } + public enum EVRScreenshotType + { + None = 0, + Mono = 1, + Stereo = 2, + Cubemap = 3, + MonoPanorama = 4, + StereoPanorama = 5, + } + public enum EVRScreenshotPropertyFilenames + { + Preview = 0, + VR = 1, + } + public enum EVRTrackedCameraError + { + None = 0, + OperationFailed = 100, + InvalidHandle = 101, + InvalidFrameHeaderVersion = 102, + OutOfHandles = 103, + IPCFailure = 104, + NotSupportedForThisDevice = 105, + SharedMemoryFailure = 106, + FrameBufferingFailure = 107, + StreamSetupFailure = 108, + InvalidGLTextureId = 109, + InvalidSharedTextureHandle = 110, + FailedToGetGLTextureId = 111, + SharedTextureFailure = 112, + NoFrameAvailable = 113, + InvalidArgument = 114, + InvalidFrameBufferSize = 115, + } + public enum EVRTrackedCameraFrameLayout + { + Mono = 1, + Stereo = 2, + VerticalLayout = 16, + HorizontalLayout = 32, + } + public enum EVRTrackedCameraFrameType + { + Distorted = 0, + Undistorted = 1, + MaximumUndistorted = 2, + MAX_CAMERA_FRAME_TYPES = 3, + } + public enum EVRDistortionFunctionType + { + None = 0, + FTheta = 1, + Extended_FTheta = 2, + MAX_DISTORTION_FUNCTION_TYPES = 3, + } + public enum EVSync + { + None = 0, + WaitRender = 1, + NoWaitRender = 2, + } + public enum EVRMuraCorrectionMode + { + Default = 0, + NoCorrection = 1, + } + public enum Imu_OffScaleFlags + { + OffScale_AccelX = 1, + OffScale_AccelY = 2, + OffScale_AccelZ = 4, + OffScale_GyroX = 8, + OffScale_GyroY = 16, + OffScale_GyroZ = 32, + } + public enum EVRApplicationError + { + None = 0, + AppKeyAlreadyExists = 100, + NoManifest = 101, + NoApplication = 102, + InvalidIndex = 103, + UnknownApplication = 104, + IPCFailed = 105, + ApplicationAlreadyRunning = 106, + InvalidManifest = 107, + InvalidApplication = 108, + LaunchFailed = 109, + ApplicationAlreadyStarting = 110, + LaunchInProgress = 111, + OldApplicationQuitting = 112, + TransitionAborted = 113, + IsTemplate = 114, + SteamVRIsExiting = 115, + BufferTooSmall = 200, + PropertyNotSet = 201, + UnknownProperty = 202, + InvalidParameter = 203, + NotImplemented = 300, + } + public enum EVRApplicationProperty + { + Name_String = 0, + LaunchType_String = 11, + WorkingDirectory_String = 12, + BinaryPath_String = 13, + Arguments_String = 14, + URL_String = 15, + Description_String = 50, + NewsURL_String = 51, + ImagePath_String = 52, + Source_String = 53, + ActionManifestURL_String = 54, + IsDashboardOverlay_Bool = 60, + IsTemplate_Bool = 61, + IsInstanced_Bool = 62, + IsInternal_Bool = 63, + WantsCompositorPauseInStandby_Bool = 64, + IsHidden_Bool = 65, + LastLaunchTime_Uint64 = 70, + } + public enum EVRSceneApplicationState + { + None = 0, + Starting = 1, + Quitting = 2, + Running = 3, + Waiting = 4, + } + public enum ChaperoneCalibrationState + { + OK = 1, + Warning = 100, + Warning_BaseStationMayHaveMoved = 101, + Warning_BaseStationRemoved = 102, + Warning_SeatedBoundsInvalid = 103, + Error = 200, + Error_BaseStationUninitialized = 201, + Error_BaseStationConflict = 202, + Error_PlayAreaInvalid = 203, + Error_CollisionBoundsInvalid = 204, + } + public enum EChaperoneConfigFile + { + Live = 1, + Temp = 2, + } + public enum EChaperoneImportFlags + { + EChaperoneImport_BoundsOnly = 1, + } + public enum EVRCompositorError + { + None = 0, + RequestFailed = 1, + IncompatibleVersion = 100, + DoNotHaveFocus = 101, + InvalidTexture = 102, + IsNotSceneApplication = 103, + TextureIsOnWrongDevice = 104, + TextureUsesUnsupportedFormat = 105, + SharedTexturesNotSupported = 106, + IndexOutOfRange = 107, + AlreadySubmitted = 108, + InvalidBounds = 109, + AlreadySet = 110, + } + public enum EVRCompositorTimingMode + { + Implicit = 0, + Explicit_RuntimePerformsPostPresentHandoff = 1, + Explicit_ApplicationPerformsPostPresentHandoff = 2, + } + public enum VROverlayInputMethod + { + None = 0, + Mouse = 1, + } + public enum VROverlayTransformType + { + VROverlayTransform_Invalid = -1, + VROverlayTransform_Absolute = 0, + VROverlayTransform_TrackedDeviceRelative = 1, + VROverlayTransform_SystemOverlay = 2, + VROverlayTransform_TrackedComponent = 3, + VROverlayTransform_Cursor = 4, + VROverlayTransform_DashboardTab = 5, + VROverlayTransform_DashboardThumb = 6, + VROverlayTransform_Mountable = 7, + VROverlayTransform_Projection = 8, + } + public enum VROverlayFlags + { + NoDashboardTab = 8, + SendVRDiscreteScrollEvents = 64, + SendVRTouchpadEvents = 128, + ShowTouchPadScrollWheel = 256, + TransferOwnershipToInternalProcess = 512, + SideBySide_Parallel = 1024, + SideBySide_Crossed = 2048, + Panorama = 4096, + StereoPanorama = 8192, + SortWithNonSceneOverlays = 16384, + VisibleInDashboard = 32768, + MakeOverlaysInteractiveIfVisible = 65536, + SendVRSmoothScrollEvents = 131072, + ProtectedContent = 262144, + HideLaserIntersection = 524288, + WantsModalBehavior = 1048576, + IsPremultiplied = 2097152, + } + public enum VRMessageOverlayResponse + { + ButtonPress_0 = 0, + ButtonPress_1 = 1, + ButtonPress_2 = 2, + ButtonPress_3 = 3, + CouldntFindSystemOverlay = 4, + CouldntFindOrCreateClientOverlay = 5, + ApplicationQuit = 6, + } + public enum EGamepadTextInputMode + { + k_EGamepadTextInputModeNormal = 0, + k_EGamepadTextInputModePassword = 1, + k_EGamepadTextInputModeSubmit = 2, + } + public enum EGamepadTextInputLineMode + { + k_EGamepadTextInputLineModeSingleLine = 0, + k_EGamepadTextInputLineModeMultipleLines = 1, + } + public enum EVROverlayIntersectionMaskPrimitiveType + { + OverlayIntersectionPrimitiveType_Rectangle = 0, + OverlayIntersectionPrimitiveType_Circle = 1, + } + public enum EKeyboardFlags + { + KeyboardFlag_Minimal = 1, + KeyboardFlag_Modal = 2, + } + public enum EDeviceType + { + Invalid = -1, + DirectX11 = 0, + Vulkan = 1, + } + public enum HeadsetViewMode_t + { + HeadsetViewMode_Left = 0, + HeadsetViewMode_Right = 1, + HeadsetViewMode_Both = 2, + } + public enum EVRRenderModelError + { + None = 0, + Loading = 100, + NotSupported = 200, + InvalidArg = 300, + InvalidModel = 301, + NoShapes = 302, + MultipleShapes = 303, + TooManyVertices = 304, + MultipleTextures = 305, + BufferTooSmall = 306, + NotEnoughNormals = 307, + NotEnoughTexCoords = 308, + InvalidTexture = 400, + } + public enum EVRRenderModelTextureFormat + { + RGBA8_SRGB = 0, + BC2 = 1, + BC4 = 2, + BC7 = 3, + BC7_SRGB = 4, + } + public enum EVRNotificationType + { + Transient = 0, + Persistent = 1, + Transient_SystemWithUserValue = 2, + } + public enum EVRNotificationStyle + { + None = 0, + Application = 100, + Contact_Disabled = 200, + Contact_Enabled = 201, + Contact_Active = 202, + } + public enum EVRSettingsError + { + None = 0, + IPCFailed = 1, + WriteFailed = 2, + ReadFailed = 3, + JsonParseFailed = 4, + UnsetSettingHasNoDefault = 5, + } + public enum EVRScreenshotError + { + None = 0, + RequestFailed = 1, + IncompatibleVersion = 100, + NotFound = 101, + BufferTooSmall = 102, + ScreenshotAlreadyInProgress = 108, + } + public enum EVRSkeletalTransformSpace + { + Model = 0, + Parent = 1, + } + public enum EVRSkeletalReferencePose + { + BindPose = 0, + OpenHand = 1, + Fist = 2, + GripLimit = 3, + } + public enum EVRFinger + { + Thumb = 0, + Index = 1, + Middle = 2, + Ring = 3, + Pinky = 4, + Count = 5, + } + public enum EVRFingerSplay + { + Thumb_Index = 0, + Index_Middle = 1, + Middle_Ring = 2, + Ring_Pinky = 3, + Count = 4, + } + public enum EVRSummaryType + { + FromAnimation = 0, + FromDevice = 1, + } + public enum EVRInputFilterCancelType + { + VRInputFilterCancel_Timers = 0, + VRInputFilterCancel_Momentum = 1, + } + public enum EVRInputStringBits + { + VRInputString_Hand = 1, + VRInputString_ControllerType = 2, + VRInputString_InputSource = 4, + VRInputString_All = -1, + } + public enum EIOBufferError + { + IOBuffer_Success = 0, + IOBuffer_OperationFailed = 100, + IOBuffer_InvalidHandle = 101, + IOBuffer_InvalidArgument = 102, + IOBuffer_PathExists = 103, + IOBuffer_PathDoesNotExist = 104, + IOBuffer_Permission = 105, + } + public enum EIOBufferMode + { + Read = 1, + Write = 2, + Create = 512, + } + public enum EVRDebugError + { + Success = 0, + BadParameter = 1, + } + public enum EPropertyWriteType + { + PropertyWrite_Set = 0, + PropertyWrite_Erase = 1, + PropertyWrite_SetError = 2, + } + public enum EBlockQueueError + { + None = 0, + QueueAlreadyExists = 1, + QueueNotFound = 2, + BlockNotAvailable = 3, + InvalidHandle = 4, + InvalidParam = 5, + ParamMismatch = 6, + InternalError = 7, + AlreadyInitialized = 8, + OperationIsServerOnly = 9, + TooManyConnections = 10, + } + public enum EBlockQueueReadType + { + BlockQueueRead_Latest = 0, + BlockQueueRead_New = 1, + BlockQueueRead_Next = 2, + } + + [StructLayout(LayoutKind.Explicit)] + public struct VREvent_Data_t + { + [FieldOffset(0)] public VREvent_Reserved_t reserved; + [FieldOffset(0)] public VREvent_Controller_t controller; + [FieldOffset(0)] public VREvent_Mouse_t mouse; + [FieldOffset(0)] public VREvent_Scroll_t scroll; + [FieldOffset(0)] public VREvent_Process_t process; + [FieldOffset(0)] public VREvent_Notification_t notification; + [FieldOffset(0)] public VREvent_Overlay_t overlay; + [FieldOffset(0)] public VREvent_Status_t status; + [FieldOffset(0)] public VREvent_Ipd_t ipd; + [FieldOffset(0)] public VREvent_Chaperone_t chaperone; + [FieldOffset(0)] public VREvent_PerformanceTest_t performanceTest; + [FieldOffset(0)] public VREvent_TouchPadMove_t touchPadMove; + [FieldOffset(0)] public VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + [FieldOffset(0)] public VREvent_Screenshot_t screenshot; + [FieldOffset(0)] public VREvent_ScreenshotProgress_t screenshotProgress; + [FieldOffset(0)] public VREvent_ApplicationLaunch_t applicationLaunch; + [FieldOffset(0)] public VREvent_EditingCameraSurface_t cameraSurface; + [FieldOffset(0)] public VREvent_MessageOverlay_t messageOverlay; + [FieldOffset(0)] public VREvent_Property_t property; + [FieldOffset(0)] public VREvent_HapticVibration_t hapticVibration; + [FieldOffset(0)] public VREvent_WebConsole_t webConsole; + [FieldOffset(0)] public VREvent_InputBindingLoad_t inputBinding; + [FieldOffset(0)] public VREvent_SpatialAnchor_t spatialAnchor; + [FieldOffset(0)] public VREvent_InputActionManifestLoad_t actionManifest; + [FieldOffset(0)] public VREvent_ProgressUpdate_t progressUpdate; + [FieldOffset(0)] public VREvent_ShowUI_t showUi; + [FieldOffset(0)] public VREvent_ShowDevTools_t showDevTools; + [FieldOffset(0)] public VREvent_HDCPError_t hdcpError; + [FieldOffset(0)] public VREvent_Keyboard_t keyboard; // This has to be at the end due to a mono bug + } + + + [StructLayout(LayoutKind.Explicit)] + public struct VROverlayIntersectionMaskPrimitive_Data_t + { + [FieldOffset(0)] public IntersectionMaskRectangle_t m_Rectangle; + [FieldOffset(0)] public IntersectionMaskCircle_t m_Circle; + } + + [StructLayout(LayoutKind.Sequential)] + public struct HmdMatrix34_t + { + public float m0; //float[3][4] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + public float m9; + public float m10; + public float m11; +#if UNITY_5_3_OR_NEWER + + public Vector3 GetPosition() + { + return new Vector3(m3, m7, -m11); + } + + public bool IsRotationValid() + { + return ((m2 != 0 || m6 != 0 || m10 != 0) && (m1 != 0 || m5 != 0 || m9 != 0)); + } + + public Quaternion GetRotation() + { + if (IsRotationValid()) + { + float w = Mathf.Sqrt(Mathf.Max(0, 1 + m0 + m5 + m10)) / 2; + float x = Mathf.Sqrt(Mathf.Max(0, 1 + m0 - m5 - m10)) / 2; + float y = Mathf.Sqrt(Mathf.Max(0, 1 - m0 + m5 - m10)) / 2; + float z = Mathf.Sqrt(Mathf.Max(0, 1 - m0 - m5 + m10)) / 2; + + _copysign(ref x, -m9 - -m6); + _copysign(ref y, -m2 - -m8); + _copysign(ref z, m4 - m1); + + return new Quaternion(x, y, z, w); + } + return Quaternion.identity; + } + + private static void _copysign(ref float sizeval, float signval) + { + if (signval > 0 != sizeval > 0) + sizeval = -sizeval; + } +#endif + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdMatrix33_t + { + public float m0; //float[3][3] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdMatrix44_t + { + public float m0; //float[4][4] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + public float m9; + public float m10; + public float m11; + public float m12; + public float m13; + public float m14; + public float m15; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdVector3_t + { + public float v0; //float[3] + public float v1; + public float v2; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdVector4_t + { + public float v0; //float[4] + public float v1; + public float v2; + public float v3; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdVector3d_t + { + public double v0; //double[3] + public double v1; + public double v2; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdVector2_t + { + public float v0; //float[2] + public float v1; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdQuaternion_t + { + public double w; + public double x; + public double y; + public double z; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdQuaternionf_t + { + public float w; + public float x; + public float y; + public float z; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdColor_t + { + public float r; + public float g; + public float b; + public float a; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdQuad_t + { + public HmdVector3_t vCorners0; //HmdVector3_t[4] + public HmdVector3_t vCorners1; + public HmdVector3_t vCorners2; + public HmdVector3_t vCorners3; + } + [StructLayout(LayoutKind.Sequential)] + public struct HmdRect2_t + { + public HmdVector2_t vTopLeft; + public HmdVector2_t vBottomRight; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRBoneTransform_t + { + public HmdVector4_t position; + public HmdQuaternionf_t orientation; + } + [StructLayout(LayoutKind.Sequential)] + public struct DistortionCoordinates_t + { + public float rfRed0; //float[2] + public float rfRed1; + public float rfGreen0; //float[2] + public float rfGreen1; + public float rfBlue0; //float[2] + public float rfBlue1; + } + [StructLayout(LayoutKind.Sequential)] + public struct Texture_t + { + public IntPtr handle; // void * + public ETextureType eType; + public EColorSpace eColorSpace; + } + [StructLayout(LayoutKind.Sequential)] + public struct TrackedDevicePose_t + { + public HmdMatrix34_t mDeviceToAbsoluteTracking; + public HmdVector3_t vVelocity; + public HmdVector3_t vAngularVelocity; + public ETrackingResult eTrackingResult; + [MarshalAs(UnmanagedType.I1)] + public bool bPoseIsValid; + [MarshalAs(UnmanagedType.I1)] + public bool bDeviceIsConnected; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureBounds_t + { + public float uMin; + public float vMin; + public float uMax; + public float vMax; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureWithPose_t + { + public IntPtr handle; // void * + public ETextureType eType; + public EColorSpace eColorSpace; + public HmdMatrix34_t mDeviceToAbsoluteTracking; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureDepthInfo_t + { + public IntPtr handle; // void * + public HmdMatrix44_t mProjection; + public HmdVector2_t vRange; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureWithDepth_t + { + public IntPtr handle; // void * + public ETextureType eType; + public EColorSpace eColorSpace; + public VRTextureDepthInfo_t depth; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRTextureWithPoseAndDepth_t + { + public IntPtr handle; // void * + public ETextureType eType; + public EColorSpace eColorSpace; + public HmdMatrix34_t mDeviceToAbsoluteTracking; + public VRTextureDepthInfo_t depth; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRVulkanTextureData_t + { + public ulong m_nImage; + public IntPtr m_pDevice; // struct VkDevice_T * + public IntPtr m_pPhysicalDevice; // struct VkPhysicalDevice_T * + public IntPtr m_pInstance; // struct VkInstance_T * + public IntPtr m_pQueue; // struct VkQueue_T * + public uint m_nQueueFamilyIndex; + public uint m_nWidth; + public uint m_nHeight; + public uint m_nFormat; + public uint m_nSampleCount; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRVulkanTextureArrayData_t + { + public uint m_unArrayIndex; + public uint m_unArraySize; + } + [StructLayout(LayoutKind.Sequential)] + public struct D3D12TextureData_t + { + public IntPtr m_pResource; // struct ID3D12Resource * + public IntPtr m_pCommandQueue; // struct ID3D12CommandQueue * + public uint m_nNodeMask; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Controller_t + { + public uint button; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Mouse_t + { + public float x; + public float y; + public uint button; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Scroll_t + { + public float xdelta; + public float ydelta; + public uint unused; + public float viewportscale; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_TouchPadMove_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bFingerDown; + public float flSecondsFingerDown; + public float fValueXFirst; + public float fValueYFirst; + public float fValueXRaw; + public float fValueYRaw; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Notification_t + { + public ulong ulUserValue; + public uint notificationId; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Process_t + { + public uint pid; + public uint oldPid; + [MarshalAs(UnmanagedType.I1)] + public bool bForced; + [MarshalAs(UnmanagedType.I1)] + public bool bConnectionLost; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Overlay_t + { + public ulong overlayHandle; + public ulong devicePath; + public ulong memoryBlockId; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Status_t + { + public uint statusState; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Keyboard_t + { + public byte cNewInput0, cNewInput1, cNewInput2, cNewInput3, cNewInput4, cNewInput5, cNewInput6, cNewInput7; + public string cNewInput + { + get + { + return new string(new char[] { + (char)cNewInput0, + (char)cNewInput1, + (char)cNewInput2, + (char)cNewInput3, + (char)cNewInput4, + (char)cNewInput5, + (char)cNewInput6, + (char)cNewInput7 + }).TrimEnd('\0'); + } + } + public ulong uUserValue; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Ipd_t + { + public float ipdMeters; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Chaperone_t + { + public ulong m_nPreviousUniverse; + public ulong m_nCurrentUniverse; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Reserved_t + { + public ulong reserved0; + public ulong reserved1; + public ulong reserved2; + public ulong reserved3; + public ulong reserved4; + public ulong reserved5; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_PerformanceTest_t + { + public uint m_nFidelityLevel; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_SeatedZeroPoseReset_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bResetBySystemMenu; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Screenshot_t + { + public uint handle; + public uint type; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ScreenshotProgress_t + { + public float progress; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ApplicationLaunch_t + { + public uint pid; + public uint unArgsHandle; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_EditingCameraSurface_t + { + public ulong overlayHandle; + public uint nVisualMode; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_MessageOverlay_t + { + public uint unVRMessageOverlayResponse; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_Property_t + { + public ulong container; + public ETrackedDeviceProperty prop; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_HapticVibration_t + { + public ulong containerHandle; + public ulong componentHandle; + public float fDurationSeconds; + public float fFrequency; + public float fAmplitude; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_WebConsole_t + { + public ulong webConsoleHandle; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_InputBindingLoad_t + { + public ulong ulAppContainer; + public ulong pathMessage; + public ulong pathUrl; + public ulong pathControllerType; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_InputActionManifestLoad_t + { + public ulong pathAppKey; + public ulong pathMessage; + public ulong pathMessageParam; + public ulong pathManifestPath; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_SpatialAnchor_t + { + public uint unHandle; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ProgressUpdate_t + { + public ulong ulApplicationPropertyContainer; + public ulong pathDevice; + public ulong pathInputSource; + public ulong pathProgressAction; + public ulong pathIcon; + public float fProgress; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ShowUI_t + { + public EShowUIType eType; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_ShowDevTools_t + { + public int nBrowserIdentifier; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_HDCPError_t + { + public EHDCPError eCode; + } + [StructLayout(LayoutKind.Sequential)] + public struct VREvent_t + { + public uint eventType; + public uint trackedDeviceIndex; + public float eventAgeSeconds; + public VREvent_Data_t data; + } + // This structure is for backwards binary compatibility on Linux and OSX only + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct VREvent_t_Packed + { + public uint eventType; + public uint trackedDeviceIndex; + public float eventAgeSeconds; + public VREvent_Data_t data; + public VREvent_t_Packed(VREvent_t unpacked) + { + eventType = unpacked.eventType; + trackedDeviceIndex = unpacked.trackedDeviceIndex; + eventAgeSeconds = unpacked.eventAgeSeconds; + data = unpacked.data; + } + public void Unpack(ref VREvent_t unpacked) + { + unpacked.eventType = eventType; + unpacked.trackedDeviceIndex = trackedDeviceIndex; + unpacked.eventAgeSeconds = eventAgeSeconds; + unpacked.data = data; + } + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_ComponentState_t + { + public HmdMatrix34_t mTrackingToComponentRenderModel; + public HmdMatrix34_t mTrackingToComponentLocal; + public uint uProperties; + } + [StructLayout(LayoutKind.Sequential)] + public struct HiddenAreaMesh_t + { + public IntPtr pVertexData; // const struct vr::HmdVector2_t * + public uint unTriangleCount; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRControllerAxis_t + { + public float x; + public float y; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRControllerState_t + { + public uint unPacketNum; + public ulong ulButtonPressed; + public ulong ulButtonTouched; + public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5] + public VRControllerAxis_t rAxis1; + public VRControllerAxis_t rAxis2; + public VRControllerAxis_t rAxis3; + public VRControllerAxis_t rAxis4; + } + // This structure is for backwards binary compatibility on Linux and OSX only + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct VRControllerState_t_Packed + { + public uint unPacketNum; + public ulong ulButtonPressed; + public ulong ulButtonTouched; + public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5] + public VRControllerAxis_t rAxis1; + public VRControllerAxis_t rAxis2; + public VRControllerAxis_t rAxis3; + public VRControllerAxis_t rAxis4; + public VRControllerState_t_Packed(VRControllerState_t unpacked) + { + unPacketNum = unpacked.unPacketNum; + ulButtonPressed = unpacked.ulButtonPressed; + ulButtonTouched = unpacked.ulButtonTouched; + rAxis0 = unpacked.rAxis0; + rAxis1 = unpacked.rAxis1; + rAxis2 = unpacked.rAxis2; + rAxis3 = unpacked.rAxis3; + rAxis4 = unpacked.rAxis4; + } + public void Unpack(ref VRControllerState_t unpacked) + { + unpacked.unPacketNum = unPacketNum; + unpacked.ulButtonPressed = ulButtonPressed; + unpacked.ulButtonTouched = ulButtonTouched; + unpacked.rAxis0 = rAxis0; + unpacked.rAxis1 = rAxis1; + unpacked.rAxis2 = rAxis2; + unpacked.rAxis3 = rAxis3; + unpacked.rAxis4 = rAxis4; + } + } + [StructLayout(LayoutKind.Sequential)] + public struct CameraVideoStreamFrameHeader_t + { + public EVRTrackedCameraFrameType eFrameType; + public uint nWidth; + public uint nHeight; + public uint nBytesPerPixel; + public uint nFrameSequence; + public TrackedDevicePose_t trackedDevicePose; + public ulong ulFrameExposureTime; + } + [StructLayout(LayoutKind.Sequential)] + public struct Compositor_FrameTiming + { + public uint m_nSize; + public uint m_nFrameIndex; + public uint m_nNumFramePresents; + public uint m_nNumMisPresented; + public uint m_nNumDroppedFrames; + public uint m_nReprojectionFlags; + public double m_flSystemTimeInSeconds; + public float m_flPreSubmitGpuMs; + public float m_flPostSubmitGpuMs; + public float m_flTotalRenderGpuMs; + public float m_flCompositorRenderGpuMs; + public float m_flCompositorRenderCpuMs; + public float m_flCompositorIdleCpuMs; + public float m_flClientFrameIntervalMs; + public float m_flPresentCallCpuMs; + public float m_flWaitForPresentCpuMs; + public float m_flSubmitFrameMs; + public float m_flWaitGetPosesCalledMs; + public float m_flNewPosesReadyMs; + public float m_flNewFrameReadyMs; + public float m_flCompositorUpdateStartMs; + public float m_flCompositorUpdateEndMs; + public float m_flCompositorRenderStartMs; + public TrackedDevicePose_t m_HmdPose; + public uint m_nNumVSyncsReadyForUse; + public uint m_nNumVSyncsToFirstView; + } + [StructLayout(LayoutKind.Sequential)] + public struct Compositor_BenchmarkResults + { + public float m_flMegaPixelsPerSecond; + public float m_flHmdRecommendedMegaPixelsPerSecond; + } + [StructLayout(LayoutKind.Sequential)] + public struct DriverDirectMode_FrameTiming + { + public uint m_nSize; + public uint m_nNumFramePresents; + public uint m_nNumMisPresented; + public uint m_nNumDroppedFrames; + public uint m_nReprojectionFlags; + } + [StructLayout(LayoutKind.Sequential)] + public struct ImuSample_t + { + public double fSampleTime; + public HmdVector3d_t vAccel; + public HmdVector3d_t vGyro; + public uint unOffScaleFlags; + } + [StructLayout(LayoutKind.Sequential)] + public struct AppOverrideKeys_t + { + public IntPtr pchKey; // const char * + public IntPtr pchValue; // const char * + } + [StructLayout(LayoutKind.Sequential)] + public struct Compositor_CumulativeStats + { + public uint m_nPid; + public uint m_nNumFramePresents; + public uint m_nNumDroppedFrames; + public uint m_nNumReprojectedFrames; + public uint m_nNumFramePresentsOnStartup; + public uint m_nNumDroppedFramesOnStartup; + public uint m_nNumReprojectedFramesOnStartup; + public uint m_nNumLoading; + public uint m_nNumFramePresentsLoading; + public uint m_nNumDroppedFramesLoading; + public uint m_nNumReprojectedFramesLoading; + public uint m_nNumTimedOut; + public uint m_nNumFramePresentsTimedOut; + public uint m_nNumDroppedFramesTimedOut; + public uint m_nNumReprojectedFramesTimedOut; + } + [StructLayout(LayoutKind.Sequential)] + public struct Compositor_StageRenderSettings + { + public HmdColor_t m_PrimaryColor; + public HmdColor_t m_SecondaryColor; + public float m_flVignetteInnerRadius; + public float m_flVignetteOuterRadius; + public float m_flFresnelStrength; + [MarshalAs(UnmanagedType.I1)] + public bool m_bBackfaceCulling; + [MarshalAs(UnmanagedType.I1)] + public bool m_bGreyscale; + [MarshalAs(UnmanagedType.I1)] + public bool m_bWireframe; + } + [StructLayout(LayoutKind.Sequential)] + public struct VROverlayIntersectionParams_t + { + public HmdVector3_t vSource; + public HmdVector3_t vDirection; + public ETrackingUniverseOrigin eOrigin; + } + [StructLayout(LayoutKind.Sequential)] + public struct VROverlayIntersectionResults_t + { + public HmdVector3_t vPoint; + public HmdVector3_t vNormal; + public HmdVector2_t vUVs; + public float fDistance; + } + [StructLayout(LayoutKind.Sequential)] + public struct IntersectionMaskRectangle_t + { + public float m_flTopLeftX; + public float m_flTopLeftY; + public float m_flWidth; + public float m_flHeight; + } + [StructLayout(LayoutKind.Sequential)] + public struct IntersectionMaskCircle_t + { + public float m_flCenterX; + public float m_flCenterY; + public float m_flRadius; + } + [StructLayout(LayoutKind.Sequential)] + public struct VROverlayIntersectionMaskPrimitive_t + { + public EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType; + public VROverlayIntersectionMaskPrimitive_Data_t m_Primitive; + } + [StructLayout(LayoutKind.Sequential)] + public struct VROverlayProjection_t + { + public float fLeft; + public float fRight; + public float fTop; + public float fBottom; + } + [StructLayout(LayoutKind.Sequential)] + public struct VROverlayView_t + { + public ulong overlayHandle; + public Texture_t texture; + public VRTextureBounds_t textureBounds; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRVulkanDevice_t + { + public IntPtr m_pInstance; // struct VkInstance_T * + public IntPtr m_pDevice; // struct VkDevice_T * + public IntPtr m_pPhysicalDevice; // struct VkPhysicalDevice_T * + public IntPtr m_pQueue; // struct VkQueue_T * + public uint m_uQueueFamilyIndex; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRNativeDevice_t + { + public IntPtr handle; // void * + public EDeviceType eType; + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_Vertex_t + { + public HmdVector3_t vPosition; + public HmdVector3_t vNormal; + public float rfTextureCoord0; //float[2] + public float rfTextureCoord1; + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_TextureMap_t + { + public ushort unWidth; + public ushort unHeight; + public IntPtr rubTextureMapData; // const uint8_t * + public EVRRenderModelTextureFormat format; + } + // This structure is for backwards binary compatibility on Linux and OSX only + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct RenderModel_TextureMap_t_Packed + { + public ushort unWidth; + public ushort unHeight; + public IntPtr rubTextureMapData; // const uint8_t * + public EVRRenderModelTextureFormat format; + public RenderModel_TextureMap_t_Packed(RenderModel_TextureMap_t unpacked) + { + unWidth = unpacked.unWidth; + unHeight = unpacked.unHeight; + rubTextureMapData = unpacked.rubTextureMapData; + format = unpacked.format; + } + public void Unpack(ref RenderModel_TextureMap_t unpacked) + { + unpacked.unWidth = unWidth; + unpacked.unHeight = unHeight; + unpacked.rubTextureMapData = rubTextureMapData; + unpacked.format = format; + } + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_t + { + public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t * + public uint unVertexCount; + public IntPtr rIndexData; // const uint16_t * + public uint unTriangleCount; + public int diffuseTextureId; + } + // This structure is for backwards binary compatibility on Linux and OSX only + [StructLayout(LayoutKind.Sequential, Pack = 4)] + public struct RenderModel_t_Packed + { + public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t * + public uint unVertexCount; + public IntPtr rIndexData; // const uint16_t * + public uint unTriangleCount; + public int diffuseTextureId; + public RenderModel_t_Packed(RenderModel_t unpacked) + { + rVertexData = unpacked.rVertexData; + unVertexCount = unpacked.unVertexCount; + rIndexData = unpacked.rIndexData; + unTriangleCount = unpacked.unTriangleCount; + diffuseTextureId = unpacked.diffuseTextureId; + } + public void Unpack(ref RenderModel_t unpacked) + { + unpacked.rVertexData = rVertexData; + unpacked.unVertexCount = unVertexCount; + unpacked.rIndexData = rIndexData; + unpacked.unTriangleCount = unTriangleCount; + unpacked.diffuseTextureId = diffuseTextureId; + } + } + [StructLayout(LayoutKind.Sequential)] + public struct RenderModel_ControllerMode_State_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bScrollWheelVisible; + } + [StructLayout(LayoutKind.Sequential)] + public struct NotificationBitmap_t + { + public IntPtr m_pImageData; // void * + public int m_nWidth; + public int m_nHeight; + public int m_nBytesPerPixel; + } + [StructLayout(LayoutKind.Sequential)] + public struct CVRSettingHelper + { + public IntPtr m_pSettings; // class vr::IVRSettings * + } + [StructLayout(LayoutKind.Sequential)] + public struct InputAnalogActionData_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + public float x; + public float y; + public float z; + public float deltaX; + public float deltaY; + public float deltaZ; + public float fUpdateTime; + } + [StructLayout(LayoutKind.Sequential)] + public struct InputDigitalActionData_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + [MarshalAs(UnmanagedType.I1)] + public bool bState; + [MarshalAs(UnmanagedType.I1)] + public bool bChanged; + public float fUpdateTime; + } + [StructLayout(LayoutKind.Sequential)] + public struct InputPoseActionData_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + public TrackedDevicePose_t pose; + } + [StructLayout(LayoutKind.Sequential)] + public struct InputSkeletalActionData_t + { + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + } + [StructLayout(LayoutKind.Sequential)] + public struct InputOriginInfo_t + { + public ulong devicePath; + public uint trackedDeviceIndex; + public byte rchRenderModelComponentName0, rchRenderModelComponentName1, rchRenderModelComponentName2, rchRenderModelComponentName3, rchRenderModelComponentName4, rchRenderModelComponentName5, rchRenderModelComponentName6, rchRenderModelComponentName7, rchRenderModelComponentName8, rchRenderModelComponentName9, rchRenderModelComponentName10, rchRenderModelComponentName11, rchRenderModelComponentName12, rchRenderModelComponentName13, rchRenderModelComponentName14, rchRenderModelComponentName15, rchRenderModelComponentName16, rchRenderModelComponentName17, rchRenderModelComponentName18, rchRenderModelComponentName19, rchRenderModelComponentName20, rchRenderModelComponentName21, rchRenderModelComponentName22, rchRenderModelComponentName23, rchRenderModelComponentName24, rchRenderModelComponentName25, rchRenderModelComponentName26, rchRenderModelComponentName27, rchRenderModelComponentName28, rchRenderModelComponentName29, rchRenderModelComponentName30, rchRenderModelComponentName31, rchRenderModelComponentName32, rchRenderModelComponentName33, rchRenderModelComponentName34, rchRenderModelComponentName35, rchRenderModelComponentName36, rchRenderModelComponentName37, rchRenderModelComponentName38, rchRenderModelComponentName39, rchRenderModelComponentName40, rchRenderModelComponentName41, rchRenderModelComponentName42, rchRenderModelComponentName43, rchRenderModelComponentName44, rchRenderModelComponentName45, rchRenderModelComponentName46, rchRenderModelComponentName47, rchRenderModelComponentName48, rchRenderModelComponentName49, rchRenderModelComponentName50, rchRenderModelComponentName51, rchRenderModelComponentName52, rchRenderModelComponentName53, rchRenderModelComponentName54, rchRenderModelComponentName55, rchRenderModelComponentName56, rchRenderModelComponentName57, rchRenderModelComponentName58, rchRenderModelComponentName59, rchRenderModelComponentName60, rchRenderModelComponentName61, rchRenderModelComponentName62, rchRenderModelComponentName63, rchRenderModelComponentName64, rchRenderModelComponentName65, rchRenderModelComponentName66, rchRenderModelComponentName67, rchRenderModelComponentName68, rchRenderModelComponentName69, rchRenderModelComponentName70, rchRenderModelComponentName71, rchRenderModelComponentName72, rchRenderModelComponentName73, rchRenderModelComponentName74, rchRenderModelComponentName75, rchRenderModelComponentName76, rchRenderModelComponentName77, rchRenderModelComponentName78, rchRenderModelComponentName79, rchRenderModelComponentName80, rchRenderModelComponentName81, rchRenderModelComponentName82, rchRenderModelComponentName83, rchRenderModelComponentName84, rchRenderModelComponentName85, rchRenderModelComponentName86, rchRenderModelComponentName87, rchRenderModelComponentName88, rchRenderModelComponentName89, rchRenderModelComponentName90, rchRenderModelComponentName91, rchRenderModelComponentName92, rchRenderModelComponentName93, rchRenderModelComponentName94, rchRenderModelComponentName95, rchRenderModelComponentName96, rchRenderModelComponentName97, rchRenderModelComponentName98, rchRenderModelComponentName99, rchRenderModelComponentName100, rchRenderModelComponentName101, rchRenderModelComponentName102, rchRenderModelComponentName103, rchRenderModelComponentName104, rchRenderModelComponentName105, rchRenderModelComponentName106, rchRenderModelComponentName107, rchRenderModelComponentName108, rchRenderModelComponentName109, rchRenderModelComponentName110, rchRenderModelComponentName111, rchRenderModelComponentName112, rchRenderModelComponentName113, rchRenderModelComponentName114, rchRenderModelComponentName115, rchRenderModelComponentName116, rchRenderModelComponentName117, rchRenderModelComponentName118, rchRenderModelComponentName119, rchRenderModelComponentName120, rchRenderModelComponentName121, rchRenderModelComponentName122, rchRenderModelComponentName123, rchRenderModelComponentName124, rchRenderModelComponentName125, rchRenderModelComponentName126, rchRenderModelComponentName127; + public string rchRenderModelComponentName + { + get + { + return new string(new char[] { + (char)rchRenderModelComponentName0, + (char)rchRenderModelComponentName1, + (char)rchRenderModelComponentName2, + (char)rchRenderModelComponentName3, + (char)rchRenderModelComponentName4, + (char)rchRenderModelComponentName5, + (char)rchRenderModelComponentName6, + (char)rchRenderModelComponentName7, + (char)rchRenderModelComponentName8, + (char)rchRenderModelComponentName9, + (char)rchRenderModelComponentName10, + (char)rchRenderModelComponentName11, + (char)rchRenderModelComponentName12, + (char)rchRenderModelComponentName13, + (char)rchRenderModelComponentName14, + (char)rchRenderModelComponentName15, + (char)rchRenderModelComponentName16, + (char)rchRenderModelComponentName17, + (char)rchRenderModelComponentName18, + (char)rchRenderModelComponentName19, + (char)rchRenderModelComponentName20, + (char)rchRenderModelComponentName21, + (char)rchRenderModelComponentName22, + (char)rchRenderModelComponentName23, + (char)rchRenderModelComponentName24, + (char)rchRenderModelComponentName25, + (char)rchRenderModelComponentName26, + (char)rchRenderModelComponentName27, + (char)rchRenderModelComponentName28, + (char)rchRenderModelComponentName29, + (char)rchRenderModelComponentName30, + (char)rchRenderModelComponentName31, + (char)rchRenderModelComponentName32, + (char)rchRenderModelComponentName33, + (char)rchRenderModelComponentName34, + (char)rchRenderModelComponentName35, + (char)rchRenderModelComponentName36, + (char)rchRenderModelComponentName37, + (char)rchRenderModelComponentName38, + (char)rchRenderModelComponentName39, + (char)rchRenderModelComponentName40, + (char)rchRenderModelComponentName41, + (char)rchRenderModelComponentName42, + (char)rchRenderModelComponentName43, + (char)rchRenderModelComponentName44, + (char)rchRenderModelComponentName45, + (char)rchRenderModelComponentName46, + (char)rchRenderModelComponentName47, + (char)rchRenderModelComponentName48, + (char)rchRenderModelComponentName49, + (char)rchRenderModelComponentName50, + (char)rchRenderModelComponentName51, + (char)rchRenderModelComponentName52, + (char)rchRenderModelComponentName53, + (char)rchRenderModelComponentName54, + (char)rchRenderModelComponentName55, + (char)rchRenderModelComponentName56, + (char)rchRenderModelComponentName57, + (char)rchRenderModelComponentName58, + (char)rchRenderModelComponentName59, + (char)rchRenderModelComponentName60, + (char)rchRenderModelComponentName61, + (char)rchRenderModelComponentName62, + (char)rchRenderModelComponentName63, + (char)rchRenderModelComponentName64, + (char)rchRenderModelComponentName65, + (char)rchRenderModelComponentName66, + (char)rchRenderModelComponentName67, + (char)rchRenderModelComponentName68, + (char)rchRenderModelComponentName69, + (char)rchRenderModelComponentName70, + (char)rchRenderModelComponentName71, + (char)rchRenderModelComponentName72, + (char)rchRenderModelComponentName73, + (char)rchRenderModelComponentName74, + (char)rchRenderModelComponentName75, + (char)rchRenderModelComponentName76, + (char)rchRenderModelComponentName77, + (char)rchRenderModelComponentName78, + (char)rchRenderModelComponentName79, + (char)rchRenderModelComponentName80, + (char)rchRenderModelComponentName81, + (char)rchRenderModelComponentName82, + (char)rchRenderModelComponentName83, + (char)rchRenderModelComponentName84, + (char)rchRenderModelComponentName85, + (char)rchRenderModelComponentName86, + (char)rchRenderModelComponentName87, + (char)rchRenderModelComponentName88, + (char)rchRenderModelComponentName89, + (char)rchRenderModelComponentName90, + (char)rchRenderModelComponentName91, + (char)rchRenderModelComponentName92, + (char)rchRenderModelComponentName93, + (char)rchRenderModelComponentName94, + (char)rchRenderModelComponentName95, + (char)rchRenderModelComponentName96, + (char)rchRenderModelComponentName97, + (char)rchRenderModelComponentName98, + (char)rchRenderModelComponentName99, + (char)rchRenderModelComponentName100, + (char)rchRenderModelComponentName101, + (char)rchRenderModelComponentName102, + (char)rchRenderModelComponentName103, + (char)rchRenderModelComponentName104, + (char)rchRenderModelComponentName105, + (char)rchRenderModelComponentName106, + (char)rchRenderModelComponentName107, + (char)rchRenderModelComponentName108, + (char)rchRenderModelComponentName109, + (char)rchRenderModelComponentName110, + (char)rchRenderModelComponentName111, + (char)rchRenderModelComponentName112, + (char)rchRenderModelComponentName113, + (char)rchRenderModelComponentName114, + (char)rchRenderModelComponentName115, + (char)rchRenderModelComponentName116, + (char)rchRenderModelComponentName117, + (char)rchRenderModelComponentName118, + (char)rchRenderModelComponentName119, + (char)rchRenderModelComponentName120, + (char)rchRenderModelComponentName121, + (char)rchRenderModelComponentName122, + (char)rchRenderModelComponentName123, + (char)rchRenderModelComponentName124, + (char)rchRenderModelComponentName125, + (char)rchRenderModelComponentName126, + (char)rchRenderModelComponentName127 + }).TrimEnd('\0'); + } + } + } + [StructLayout(LayoutKind.Sequential)] + public struct InputBindingInfo_t + { + public byte rchDevicePathName0, rchDevicePathName1, rchDevicePathName2, rchDevicePathName3, rchDevicePathName4, rchDevicePathName5, rchDevicePathName6, rchDevicePathName7, rchDevicePathName8, rchDevicePathName9, rchDevicePathName10, rchDevicePathName11, rchDevicePathName12, rchDevicePathName13, rchDevicePathName14, rchDevicePathName15, rchDevicePathName16, rchDevicePathName17, rchDevicePathName18, rchDevicePathName19, rchDevicePathName20, rchDevicePathName21, rchDevicePathName22, rchDevicePathName23, rchDevicePathName24, rchDevicePathName25, rchDevicePathName26, rchDevicePathName27, rchDevicePathName28, rchDevicePathName29, rchDevicePathName30, rchDevicePathName31, rchDevicePathName32, rchDevicePathName33, rchDevicePathName34, rchDevicePathName35, rchDevicePathName36, rchDevicePathName37, rchDevicePathName38, rchDevicePathName39, rchDevicePathName40, rchDevicePathName41, rchDevicePathName42, rchDevicePathName43, rchDevicePathName44, rchDevicePathName45, rchDevicePathName46, rchDevicePathName47, rchDevicePathName48, rchDevicePathName49, rchDevicePathName50, rchDevicePathName51, rchDevicePathName52, rchDevicePathName53, rchDevicePathName54, rchDevicePathName55, rchDevicePathName56, rchDevicePathName57, rchDevicePathName58, rchDevicePathName59, rchDevicePathName60, rchDevicePathName61, rchDevicePathName62, rchDevicePathName63, rchDevicePathName64, rchDevicePathName65, rchDevicePathName66, rchDevicePathName67, rchDevicePathName68, rchDevicePathName69, rchDevicePathName70, rchDevicePathName71, rchDevicePathName72, rchDevicePathName73, rchDevicePathName74, rchDevicePathName75, rchDevicePathName76, rchDevicePathName77, rchDevicePathName78, rchDevicePathName79, rchDevicePathName80, rchDevicePathName81, rchDevicePathName82, rchDevicePathName83, rchDevicePathName84, rchDevicePathName85, rchDevicePathName86, rchDevicePathName87, rchDevicePathName88, rchDevicePathName89, rchDevicePathName90, rchDevicePathName91, rchDevicePathName92, rchDevicePathName93, rchDevicePathName94, rchDevicePathName95, rchDevicePathName96, rchDevicePathName97, rchDevicePathName98, rchDevicePathName99, rchDevicePathName100, rchDevicePathName101, rchDevicePathName102, rchDevicePathName103, rchDevicePathName104, rchDevicePathName105, rchDevicePathName106, rchDevicePathName107, rchDevicePathName108, rchDevicePathName109, rchDevicePathName110, rchDevicePathName111, rchDevicePathName112, rchDevicePathName113, rchDevicePathName114, rchDevicePathName115, rchDevicePathName116, rchDevicePathName117, rchDevicePathName118, rchDevicePathName119, rchDevicePathName120, rchDevicePathName121, rchDevicePathName122, rchDevicePathName123, rchDevicePathName124, rchDevicePathName125, rchDevicePathName126, rchDevicePathName127; + public string rchDevicePathName + { + get + { + return new string(new char[] { + (char)rchDevicePathName0, + (char)rchDevicePathName1, + (char)rchDevicePathName2, + (char)rchDevicePathName3, + (char)rchDevicePathName4, + (char)rchDevicePathName5, + (char)rchDevicePathName6, + (char)rchDevicePathName7, + (char)rchDevicePathName8, + (char)rchDevicePathName9, + (char)rchDevicePathName10, + (char)rchDevicePathName11, + (char)rchDevicePathName12, + (char)rchDevicePathName13, + (char)rchDevicePathName14, + (char)rchDevicePathName15, + (char)rchDevicePathName16, + (char)rchDevicePathName17, + (char)rchDevicePathName18, + (char)rchDevicePathName19, + (char)rchDevicePathName20, + (char)rchDevicePathName21, + (char)rchDevicePathName22, + (char)rchDevicePathName23, + (char)rchDevicePathName24, + (char)rchDevicePathName25, + (char)rchDevicePathName26, + (char)rchDevicePathName27, + (char)rchDevicePathName28, + (char)rchDevicePathName29, + (char)rchDevicePathName30, + (char)rchDevicePathName31, + (char)rchDevicePathName32, + (char)rchDevicePathName33, + (char)rchDevicePathName34, + (char)rchDevicePathName35, + (char)rchDevicePathName36, + (char)rchDevicePathName37, + (char)rchDevicePathName38, + (char)rchDevicePathName39, + (char)rchDevicePathName40, + (char)rchDevicePathName41, + (char)rchDevicePathName42, + (char)rchDevicePathName43, + (char)rchDevicePathName44, + (char)rchDevicePathName45, + (char)rchDevicePathName46, + (char)rchDevicePathName47, + (char)rchDevicePathName48, + (char)rchDevicePathName49, + (char)rchDevicePathName50, + (char)rchDevicePathName51, + (char)rchDevicePathName52, + (char)rchDevicePathName53, + (char)rchDevicePathName54, + (char)rchDevicePathName55, + (char)rchDevicePathName56, + (char)rchDevicePathName57, + (char)rchDevicePathName58, + (char)rchDevicePathName59, + (char)rchDevicePathName60, + (char)rchDevicePathName61, + (char)rchDevicePathName62, + (char)rchDevicePathName63, + (char)rchDevicePathName64, + (char)rchDevicePathName65, + (char)rchDevicePathName66, + (char)rchDevicePathName67, + (char)rchDevicePathName68, + (char)rchDevicePathName69, + (char)rchDevicePathName70, + (char)rchDevicePathName71, + (char)rchDevicePathName72, + (char)rchDevicePathName73, + (char)rchDevicePathName74, + (char)rchDevicePathName75, + (char)rchDevicePathName76, + (char)rchDevicePathName77, + (char)rchDevicePathName78, + (char)rchDevicePathName79, + (char)rchDevicePathName80, + (char)rchDevicePathName81, + (char)rchDevicePathName82, + (char)rchDevicePathName83, + (char)rchDevicePathName84, + (char)rchDevicePathName85, + (char)rchDevicePathName86, + (char)rchDevicePathName87, + (char)rchDevicePathName88, + (char)rchDevicePathName89, + (char)rchDevicePathName90, + (char)rchDevicePathName91, + (char)rchDevicePathName92, + (char)rchDevicePathName93, + (char)rchDevicePathName94, + (char)rchDevicePathName95, + (char)rchDevicePathName96, + (char)rchDevicePathName97, + (char)rchDevicePathName98, + (char)rchDevicePathName99, + (char)rchDevicePathName100, + (char)rchDevicePathName101, + (char)rchDevicePathName102, + (char)rchDevicePathName103, + (char)rchDevicePathName104, + (char)rchDevicePathName105, + (char)rchDevicePathName106, + (char)rchDevicePathName107, + (char)rchDevicePathName108, + (char)rchDevicePathName109, + (char)rchDevicePathName110, + (char)rchDevicePathName111, + (char)rchDevicePathName112, + (char)rchDevicePathName113, + (char)rchDevicePathName114, + (char)rchDevicePathName115, + (char)rchDevicePathName116, + (char)rchDevicePathName117, + (char)rchDevicePathName118, + (char)rchDevicePathName119, + (char)rchDevicePathName120, + (char)rchDevicePathName121, + (char)rchDevicePathName122, + (char)rchDevicePathName123, + (char)rchDevicePathName124, + (char)rchDevicePathName125, + (char)rchDevicePathName126, + (char)rchDevicePathName127 + }).TrimEnd('\0'); + } + } + public byte rchInputPathName0, rchInputPathName1, rchInputPathName2, rchInputPathName3, rchInputPathName4, rchInputPathName5, rchInputPathName6, rchInputPathName7, rchInputPathName8, rchInputPathName9, rchInputPathName10, rchInputPathName11, rchInputPathName12, rchInputPathName13, rchInputPathName14, rchInputPathName15, rchInputPathName16, rchInputPathName17, rchInputPathName18, rchInputPathName19, rchInputPathName20, rchInputPathName21, rchInputPathName22, rchInputPathName23, rchInputPathName24, rchInputPathName25, rchInputPathName26, rchInputPathName27, rchInputPathName28, rchInputPathName29, rchInputPathName30, rchInputPathName31, rchInputPathName32, rchInputPathName33, rchInputPathName34, rchInputPathName35, rchInputPathName36, rchInputPathName37, rchInputPathName38, rchInputPathName39, rchInputPathName40, rchInputPathName41, rchInputPathName42, rchInputPathName43, rchInputPathName44, rchInputPathName45, rchInputPathName46, rchInputPathName47, rchInputPathName48, rchInputPathName49, rchInputPathName50, rchInputPathName51, rchInputPathName52, rchInputPathName53, rchInputPathName54, rchInputPathName55, rchInputPathName56, rchInputPathName57, rchInputPathName58, rchInputPathName59, rchInputPathName60, rchInputPathName61, rchInputPathName62, rchInputPathName63, rchInputPathName64, rchInputPathName65, rchInputPathName66, rchInputPathName67, rchInputPathName68, rchInputPathName69, rchInputPathName70, rchInputPathName71, rchInputPathName72, rchInputPathName73, rchInputPathName74, rchInputPathName75, rchInputPathName76, rchInputPathName77, rchInputPathName78, rchInputPathName79, rchInputPathName80, rchInputPathName81, rchInputPathName82, rchInputPathName83, rchInputPathName84, rchInputPathName85, rchInputPathName86, rchInputPathName87, rchInputPathName88, rchInputPathName89, rchInputPathName90, rchInputPathName91, rchInputPathName92, rchInputPathName93, rchInputPathName94, rchInputPathName95, rchInputPathName96, rchInputPathName97, rchInputPathName98, rchInputPathName99, rchInputPathName100, rchInputPathName101, rchInputPathName102, rchInputPathName103, rchInputPathName104, rchInputPathName105, rchInputPathName106, rchInputPathName107, rchInputPathName108, rchInputPathName109, rchInputPathName110, rchInputPathName111, rchInputPathName112, rchInputPathName113, rchInputPathName114, rchInputPathName115, rchInputPathName116, rchInputPathName117, rchInputPathName118, rchInputPathName119, rchInputPathName120, rchInputPathName121, rchInputPathName122, rchInputPathName123, rchInputPathName124, rchInputPathName125, rchInputPathName126, rchInputPathName127; + public string rchInputPathName + { + get + { + return new string(new char[] { + (char)rchInputPathName0, + (char)rchInputPathName1, + (char)rchInputPathName2, + (char)rchInputPathName3, + (char)rchInputPathName4, + (char)rchInputPathName5, + (char)rchInputPathName6, + (char)rchInputPathName7, + (char)rchInputPathName8, + (char)rchInputPathName9, + (char)rchInputPathName10, + (char)rchInputPathName11, + (char)rchInputPathName12, + (char)rchInputPathName13, + (char)rchInputPathName14, + (char)rchInputPathName15, + (char)rchInputPathName16, + (char)rchInputPathName17, + (char)rchInputPathName18, + (char)rchInputPathName19, + (char)rchInputPathName20, + (char)rchInputPathName21, + (char)rchInputPathName22, + (char)rchInputPathName23, + (char)rchInputPathName24, + (char)rchInputPathName25, + (char)rchInputPathName26, + (char)rchInputPathName27, + (char)rchInputPathName28, + (char)rchInputPathName29, + (char)rchInputPathName30, + (char)rchInputPathName31, + (char)rchInputPathName32, + (char)rchInputPathName33, + (char)rchInputPathName34, + (char)rchInputPathName35, + (char)rchInputPathName36, + (char)rchInputPathName37, + (char)rchInputPathName38, + (char)rchInputPathName39, + (char)rchInputPathName40, + (char)rchInputPathName41, + (char)rchInputPathName42, + (char)rchInputPathName43, + (char)rchInputPathName44, + (char)rchInputPathName45, + (char)rchInputPathName46, + (char)rchInputPathName47, + (char)rchInputPathName48, + (char)rchInputPathName49, + (char)rchInputPathName50, + (char)rchInputPathName51, + (char)rchInputPathName52, + (char)rchInputPathName53, + (char)rchInputPathName54, + (char)rchInputPathName55, + (char)rchInputPathName56, + (char)rchInputPathName57, + (char)rchInputPathName58, + (char)rchInputPathName59, + (char)rchInputPathName60, + (char)rchInputPathName61, + (char)rchInputPathName62, + (char)rchInputPathName63, + (char)rchInputPathName64, + (char)rchInputPathName65, + (char)rchInputPathName66, + (char)rchInputPathName67, + (char)rchInputPathName68, + (char)rchInputPathName69, + (char)rchInputPathName70, + (char)rchInputPathName71, + (char)rchInputPathName72, + (char)rchInputPathName73, + (char)rchInputPathName74, + (char)rchInputPathName75, + (char)rchInputPathName76, + (char)rchInputPathName77, + (char)rchInputPathName78, + (char)rchInputPathName79, + (char)rchInputPathName80, + (char)rchInputPathName81, + (char)rchInputPathName82, + (char)rchInputPathName83, + (char)rchInputPathName84, + (char)rchInputPathName85, + (char)rchInputPathName86, + (char)rchInputPathName87, + (char)rchInputPathName88, + (char)rchInputPathName89, + (char)rchInputPathName90, + (char)rchInputPathName91, + (char)rchInputPathName92, + (char)rchInputPathName93, + (char)rchInputPathName94, + (char)rchInputPathName95, + (char)rchInputPathName96, + (char)rchInputPathName97, + (char)rchInputPathName98, + (char)rchInputPathName99, + (char)rchInputPathName100, + (char)rchInputPathName101, + (char)rchInputPathName102, + (char)rchInputPathName103, + (char)rchInputPathName104, + (char)rchInputPathName105, + (char)rchInputPathName106, + (char)rchInputPathName107, + (char)rchInputPathName108, + (char)rchInputPathName109, + (char)rchInputPathName110, + (char)rchInputPathName111, + (char)rchInputPathName112, + (char)rchInputPathName113, + (char)rchInputPathName114, + (char)rchInputPathName115, + (char)rchInputPathName116, + (char)rchInputPathName117, + (char)rchInputPathName118, + (char)rchInputPathName119, + (char)rchInputPathName120, + (char)rchInputPathName121, + (char)rchInputPathName122, + (char)rchInputPathName123, + (char)rchInputPathName124, + (char)rchInputPathName125, + (char)rchInputPathName126, + (char)rchInputPathName127 + }).TrimEnd('\0'); + } + } + public byte rchModeName0, rchModeName1, rchModeName2, rchModeName3, rchModeName4, rchModeName5, rchModeName6, rchModeName7, rchModeName8, rchModeName9, rchModeName10, rchModeName11, rchModeName12, rchModeName13, rchModeName14, rchModeName15, rchModeName16, rchModeName17, rchModeName18, rchModeName19, rchModeName20, rchModeName21, rchModeName22, rchModeName23, rchModeName24, rchModeName25, rchModeName26, rchModeName27, rchModeName28, rchModeName29, rchModeName30, rchModeName31, rchModeName32, rchModeName33, rchModeName34, rchModeName35, rchModeName36, rchModeName37, rchModeName38, rchModeName39, rchModeName40, rchModeName41, rchModeName42, rchModeName43, rchModeName44, rchModeName45, rchModeName46, rchModeName47, rchModeName48, rchModeName49, rchModeName50, rchModeName51, rchModeName52, rchModeName53, rchModeName54, rchModeName55, rchModeName56, rchModeName57, rchModeName58, rchModeName59, rchModeName60, rchModeName61, rchModeName62, rchModeName63, rchModeName64, rchModeName65, rchModeName66, rchModeName67, rchModeName68, rchModeName69, rchModeName70, rchModeName71, rchModeName72, rchModeName73, rchModeName74, rchModeName75, rchModeName76, rchModeName77, rchModeName78, rchModeName79, rchModeName80, rchModeName81, rchModeName82, rchModeName83, rchModeName84, rchModeName85, rchModeName86, rchModeName87, rchModeName88, rchModeName89, rchModeName90, rchModeName91, rchModeName92, rchModeName93, rchModeName94, rchModeName95, rchModeName96, rchModeName97, rchModeName98, rchModeName99, rchModeName100, rchModeName101, rchModeName102, rchModeName103, rchModeName104, rchModeName105, rchModeName106, rchModeName107, rchModeName108, rchModeName109, rchModeName110, rchModeName111, rchModeName112, rchModeName113, rchModeName114, rchModeName115, rchModeName116, rchModeName117, rchModeName118, rchModeName119, rchModeName120, rchModeName121, rchModeName122, rchModeName123, rchModeName124, rchModeName125, rchModeName126, rchModeName127; + public string rchModeName + { + get + { + return new string(new char[] { + (char)rchModeName0, + (char)rchModeName1, + (char)rchModeName2, + (char)rchModeName3, + (char)rchModeName4, + (char)rchModeName5, + (char)rchModeName6, + (char)rchModeName7, + (char)rchModeName8, + (char)rchModeName9, + (char)rchModeName10, + (char)rchModeName11, + (char)rchModeName12, + (char)rchModeName13, + (char)rchModeName14, + (char)rchModeName15, + (char)rchModeName16, + (char)rchModeName17, + (char)rchModeName18, + (char)rchModeName19, + (char)rchModeName20, + (char)rchModeName21, + (char)rchModeName22, + (char)rchModeName23, + (char)rchModeName24, + (char)rchModeName25, + (char)rchModeName26, + (char)rchModeName27, + (char)rchModeName28, + (char)rchModeName29, + (char)rchModeName30, + (char)rchModeName31, + (char)rchModeName32, + (char)rchModeName33, + (char)rchModeName34, + (char)rchModeName35, + (char)rchModeName36, + (char)rchModeName37, + (char)rchModeName38, + (char)rchModeName39, + (char)rchModeName40, + (char)rchModeName41, + (char)rchModeName42, + (char)rchModeName43, + (char)rchModeName44, + (char)rchModeName45, + (char)rchModeName46, + (char)rchModeName47, + (char)rchModeName48, + (char)rchModeName49, + (char)rchModeName50, + (char)rchModeName51, + (char)rchModeName52, + (char)rchModeName53, + (char)rchModeName54, + (char)rchModeName55, + (char)rchModeName56, + (char)rchModeName57, + (char)rchModeName58, + (char)rchModeName59, + (char)rchModeName60, + (char)rchModeName61, + (char)rchModeName62, + (char)rchModeName63, + (char)rchModeName64, + (char)rchModeName65, + (char)rchModeName66, + (char)rchModeName67, + (char)rchModeName68, + (char)rchModeName69, + (char)rchModeName70, + (char)rchModeName71, + (char)rchModeName72, + (char)rchModeName73, + (char)rchModeName74, + (char)rchModeName75, + (char)rchModeName76, + (char)rchModeName77, + (char)rchModeName78, + (char)rchModeName79, + (char)rchModeName80, + (char)rchModeName81, + (char)rchModeName82, + (char)rchModeName83, + (char)rchModeName84, + (char)rchModeName85, + (char)rchModeName86, + (char)rchModeName87, + (char)rchModeName88, + (char)rchModeName89, + (char)rchModeName90, + (char)rchModeName91, + (char)rchModeName92, + (char)rchModeName93, + (char)rchModeName94, + (char)rchModeName95, + (char)rchModeName96, + (char)rchModeName97, + (char)rchModeName98, + (char)rchModeName99, + (char)rchModeName100, + (char)rchModeName101, + (char)rchModeName102, + (char)rchModeName103, + (char)rchModeName104, + (char)rchModeName105, + (char)rchModeName106, + (char)rchModeName107, + (char)rchModeName108, + (char)rchModeName109, + (char)rchModeName110, + (char)rchModeName111, + (char)rchModeName112, + (char)rchModeName113, + (char)rchModeName114, + (char)rchModeName115, + (char)rchModeName116, + (char)rchModeName117, + (char)rchModeName118, + (char)rchModeName119, + (char)rchModeName120, + (char)rchModeName121, + (char)rchModeName122, + (char)rchModeName123, + (char)rchModeName124, + (char)rchModeName125, + (char)rchModeName126, + (char)rchModeName127 + }).TrimEnd('\0'); + } + } + public byte rchSlotName0, rchSlotName1, rchSlotName2, rchSlotName3, rchSlotName4, rchSlotName5, rchSlotName6, rchSlotName7, rchSlotName8, rchSlotName9, rchSlotName10, rchSlotName11, rchSlotName12, rchSlotName13, rchSlotName14, rchSlotName15, rchSlotName16, rchSlotName17, rchSlotName18, rchSlotName19, rchSlotName20, rchSlotName21, rchSlotName22, rchSlotName23, rchSlotName24, rchSlotName25, rchSlotName26, rchSlotName27, rchSlotName28, rchSlotName29, rchSlotName30, rchSlotName31, rchSlotName32, rchSlotName33, rchSlotName34, rchSlotName35, rchSlotName36, rchSlotName37, rchSlotName38, rchSlotName39, rchSlotName40, rchSlotName41, rchSlotName42, rchSlotName43, rchSlotName44, rchSlotName45, rchSlotName46, rchSlotName47, rchSlotName48, rchSlotName49, rchSlotName50, rchSlotName51, rchSlotName52, rchSlotName53, rchSlotName54, rchSlotName55, rchSlotName56, rchSlotName57, rchSlotName58, rchSlotName59, rchSlotName60, rchSlotName61, rchSlotName62, rchSlotName63, rchSlotName64, rchSlotName65, rchSlotName66, rchSlotName67, rchSlotName68, rchSlotName69, rchSlotName70, rchSlotName71, rchSlotName72, rchSlotName73, rchSlotName74, rchSlotName75, rchSlotName76, rchSlotName77, rchSlotName78, rchSlotName79, rchSlotName80, rchSlotName81, rchSlotName82, rchSlotName83, rchSlotName84, rchSlotName85, rchSlotName86, rchSlotName87, rchSlotName88, rchSlotName89, rchSlotName90, rchSlotName91, rchSlotName92, rchSlotName93, rchSlotName94, rchSlotName95, rchSlotName96, rchSlotName97, rchSlotName98, rchSlotName99, rchSlotName100, rchSlotName101, rchSlotName102, rchSlotName103, rchSlotName104, rchSlotName105, rchSlotName106, rchSlotName107, rchSlotName108, rchSlotName109, rchSlotName110, rchSlotName111, rchSlotName112, rchSlotName113, rchSlotName114, rchSlotName115, rchSlotName116, rchSlotName117, rchSlotName118, rchSlotName119, rchSlotName120, rchSlotName121, rchSlotName122, rchSlotName123, rchSlotName124, rchSlotName125, rchSlotName126, rchSlotName127; + public string rchSlotName + { + get + { + return new string(new char[] { + (char)rchSlotName0, + (char)rchSlotName1, + (char)rchSlotName2, + (char)rchSlotName3, + (char)rchSlotName4, + (char)rchSlotName5, + (char)rchSlotName6, + (char)rchSlotName7, + (char)rchSlotName8, + (char)rchSlotName9, + (char)rchSlotName10, + (char)rchSlotName11, + (char)rchSlotName12, + (char)rchSlotName13, + (char)rchSlotName14, + (char)rchSlotName15, + (char)rchSlotName16, + (char)rchSlotName17, + (char)rchSlotName18, + (char)rchSlotName19, + (char)rchSlotName20, + (char)rchSlotName21, + (char)rchSlotName22, + (char)rchSlotName23, + (char)rchSlotName24, + (char)rchSlotName25, + (char)rchSlotName26, + (char)rchSlotName27, + (char)rchSlotName28, + (char)rchSlotName29, + (char)rchSlotName30, + (char)rchSlotName31, + (char)rchSlotName32, + (char)rchSlotName33, + (char)rchSlotName34, + (char)rchSlotName35, + (char)rchSlotName36, + (char)rchSlotName37, + (char)rchSlotName38, + (char)rchSlotName39, + (char)rchSlotName40, + (char)rchSlotName41, + (char)rchSlotName42, + (char)rchSlotName43, + (char)rchSlotName44, + (char)rchSlotName45, + (char)rchSlotName46, + (char)rchSlotName47, + (char)rchSlotName48, + (char)rchSlotName49, + (char)rchSlotName50, + (char)rchSlotName51, + (char)rchSlotName52, + (char)rchSlotName53, + (char)rchSlotName54, + (char)rchSlotName55, + (char)rchSlotName56, + (char)rchSlotName57, + (char)rchSlotName58, + (char)rchSlotName59, + (char)rchSlotName60, + (char)rchSlotName61, + (char)rchSlotName62, + (char)rchSlotName63, + (char)rchSlotName64, + (char)rchSlotName65, + (char)rchSlotName66, + (char)rchSlotName67, + (char)rchSlotName68, + (char)rchSlotName69, + (char)rchSlotName70, + (char)rchSlotName71, + (char)rchSlotName72, + (char)rchSlotName73, + (char)rchSlotName74, + (char)rchSlotName75, + (char)rchSlotName76, + (char)rchSlotName77, + (char)rchSlotName78, + (char)rchSlotName79, + (char)rchSlotName80, + (char)rchSlotName81, + (char)rchSlotName82, + (char)rchSlotName83, + (char)rchSlotName84, + (char)rchSlotName85, + (char)rchSlotName86, + (char)rchSlotName87, + (char)rchSlotName88, + (char)rchSlotName89, + (char)rchSlotName90, + (char)rchSlotName91, + (char)rchSlotName92, + (char)rchSlotName93, + (char)rchSlotName94, + (char)rchSlotName95, + (char)rchSlotName96, + (char)rchSlotName97, + (char)rchSlotName98, + (char)rchSlotName99, + (char)rchSlotName100, + (char)rchSlotName101, + (char)rchSlotName102, + (char)rchSlotName103, + (char)rchSlotName104, + (char)rchSlotName105, + (char)rchSlotName106, + (char)rchSlotName107, + (char)rchSlotName108, + (char)rchSlotName109, + (char)rchSlotName110, + (char)rchSlotName111, + (char)rchSlotName112, + (char)rchSlotName113, + (char)rchSlotName114, + (char)rchSlotName115, + (char)rchSlotName116, + (char)rchSlotName117, + (char)rchSlotName118, + (char)rchSlotName119, + (char)rchSlotName120, + (char)rchSlotName121, + (char)rchSlotName122, + (char)rchSlotName123, + (char)rchSlotName124, + (char)rchSlotName125, + (char)rchSlotName126, + (char)rchSlotName127 + }).TrimEnd('\0'); + } + } + public byte rchInputSourceType0, rchInputSourceType1, rchInputSourceType2, rchInputSourceType3, rchInputSourceType4, rchInputSourceType5, rchInputSourceType6, rchInputSourceType7, rchInputSourceType8, rchInputSourceType9, rchInputSourceType10, rchInputSourceType11, rchInputSourceType12, rchInputSourceType13, rchInputSourceType14, rchInputSourceType15, rchInputSourceType16, rchInputSourceType17, rchInputSourceType18, rchInputSourceType19, rchInputSourceType20, rchInputSourceType21, rchInputSourceType22, rchInputSourceType23, rchInputSourceType24, rchInputSourceType25, rchInputSourceType26, rchInputSourceType27, rchInputSourceType28, rchInputSourceType29, rchInputSourceType30, rchInputSourceType31; + public string rchInputSourceType + { + get + { + return new string(new char[] { + (char)rchInputSourceType0, + (char)rchInputSourceType1, + (char)rchInputSourceType2, + (char)rchInputSourceType3, + (char)rchInputSourceType4, + (char)rchInputSourceType5, + (char)rchInputSourceType6, + (char)rchInputSourceType7, + (char)rchInputSourceType8, + (char)rchInputSourceType9, + (char)rchInputSourceType10, + (char)rchInputSourceType11, + (char)rchInputSourceType12, + (char)rchInputSourceType13, + (char)rchInputSourceType14, + (char)rchInputSourceType15, + (char)rchInputSourceType16, + (char)rchInputSourceType17, + (char)rchInputSourceType18, + (char)rchInputSourceType19, + (char)rchInputSourceType20, + (char)rchInputSourceType21, + (char)rchInputSourceType22, + (char)rchInputSourceType23, + (char)rchInputSourceType24, + (char)rchInputSourceType25, + (char)rchInputSourceType26, + (char)rchInputSourceType27, + (char)rchInputSourceType28, + (char)rchInputSourceType29, + (char)rchInputSourceType30, + (char)rchInputSourceType31 + }).TrimEnd('\0'); + } + } + } + [StructLayout(LayoutKind.Sequential)] + public struct VRActiveActionSet_t + { + public ulong ulActionSet; + public ulong ulRestrictedToDevice; + public ulong ulSecondaryActionSet; + public uint unPadding; + public int nPriority; + } + [StructLayout(LayoutKind.Sequential)] + public struct VRSkeletalSummaryData_t + { + public float flFingerCurl0; //float[5] + public float flFingerCurl1; + public float flFingerCurl2; + public float flFingerCurl3; + public float flFingerCurl4; + public float flFingerSplay0; //float[4] + public float flFingerSplay1; + public float flFingerSplay2; + public float flFingerSplay3; + } + [StructLayout(LayoutKind.Sequential)] + public struct SpatialAnchorPose_t + { + public HmdMatrix34_t mAnchorToAbsoluteTracking; + } + [StructLayout(LayoutKind.Sequential)] + public struct COpenVRContext + { + public IntPtr m_pVRSystem; // class vr::IVRSystem * + public IntPtr m_pVRChaperone; // class vr::IVRChaperone * + public IntPtr m_pVRChaperoneSetup; // class vr::IVRChaperoneSetup * + public IntPtr m_pVRCompositor; // class vr::IVRCompositor * + public IntPtr m_pVRHeadsetView; // class vr::IVRHeadsetView * + public IntPtr m_pVROverlay; // class vr::IVROverlay * + public IntPtr m_pVROverlayView; // class vr::IVROverlayView * + public IntPtr m_pVRResources; // class vr::IVRResources * + public IntPtr m_pVRRenderModels; // class vr::IVRRenderModels * + public IntPtr m_pVRExtendedDisplay; // class vr::IVRExtendedDisplay * + public IntPtr m_pVRSettings; // class vr::IVRSettings * + public IntPtr m_pVRApplications; // class vr::IVRApplications * + public IntPtr m_pVRTrackedCamera; // class vr::IVRTrackedCamera * + public IntPtr m_pVRScreenshots; // class vr::IVRScreenshots * + public IntPtr m_pVRDriverManager; // class vr::IVRDriverManager * + public IntPtr m_pVRInput; // class vr::IVRInput * + public IntPtr m_pVRIOBuffer; // class vr::IVRIOBuffer * + public IntPtr m_pVRSpatialAnchors; // class vr::IVRSpatialAnchors * + public IntPtr m_pVRDebug; // class vr::IVRDebug * + public IntPtr m_pVRNotifications; // class vr::IVRNotifications * + } + [StructLayout(LayoutKind.Sequential)] + public struct PropertyWrite_t + { + public ETrackedDeviceProperty prop; + public EPropertyWriteType writeType; + public ETrackedPropertyError eSetError; + public IntPtr pvBuffer; // void * + public uint unBufferSize; + public uint unTag; + public ETrackedPropertyError eError; + } + [StructLayout(LayoutKind.Sequential)] + public struct PropertyRead_t + { + public ETrackedDeviceProperty prop; + public IntPtr pvBuffer; // void * + public uint unBufferSize; + public uint unTag; + public uint unRequiredBufferSize; + public ETrackedPropertyError eError; + } + [StructLayout(LayoutKind.Sequential)] + public struct CVRPropertyHelpers + { + public IntPtr m_pProperties; // class vr::IVRProperties * + } + [StructLayout(LayoutKind.Sequential)] + public struct PathWrite_t + { + public ulong ulPath; + public EPropertyWriteType writeType; + public ETrackedPropertyError eSetError; + public IntPtr pvBuffer; // void * + public uint unBufferSize; + public uint unTag; + public ETrackedPropertyError eError; + public IntPtr pszPath; // const char * + } + [StructLayout(LayoutKind.Sequential)] + public struct PathRead_t + { + public ulong ulPath; + public IntPtr pvBuffer; // void * + public uint unBufferSize; + public uint unTag; + public uint unRequiredBufferSize; + public ETrackedPropertyError eError; + public IntPtr pszPath; // const char * + } + + public class OpenVR + { + + public static uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType) + { + return OpenVRInterop.InitInternal(ref peError, eApplicationType); + } + + public static uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType, string pchStartupInfo) + { + return OpenVRInterop.InitInternal2(ref peError, eApplicationType, pchStartupInfo); + } + + public static void ShutdownInternal() + { + OpenVRInterop.ShutdownInternal(); + } + + public static bool IsHmdPresent() + { + return OpenVRInterop.IsHmdPresent(); + } + + public static bool IsRuntimeInstalled() + { + return OpenVRInterop.IsRuntimeInstalled(); + } + + public static string RuntimePath() + { + try + { + uint pathSize = 512; + uint requiredPathSize = 512; + System.Text.StringBuilder path = new System.Text.StringBuilder((int)pathSize); + bool success = OpenVRInterop.GetRuntimePath(path, pathSize, ref requiredPathSize); + if (success == false) + { + return null; + } + + return path.ToString(); + } + catch + { + return OpenVRInterop.RuntimePath(); //this api is deprecated but here to support older unity versions + } + } + + public static string GetStringForHmdError(EVRInitError error) + { + return Marshal.PtrToStringAnsi(OpenVRInterop.GetStringForHmdError(error)); + } + + public static IntPtr GetGenericInterface(string pchInterfaceVersion, ref EVRInitError peError) + { + return OpenVRInterop.GetGenericInterface(pchInterfaceVersion, ref peError); + } + + public static bool IsInterfaceVersionValid(string pchInterfaceVersion) + { + return OpenVRInterop.IsInterfaceVersionValid(pchInterfaceVersion); + } + + public static uint GetInitToken() + { + return OpenVRInterop.GetInitToken(); + } + + public const uint k_nDriverNone = 4294967295; + public const uint k_unMaxDriverDebugResponseSize = 32768; + public const uint k_unTrackedDeviceIndex_Hmd = 0; + public const uint k_unMaxTrackedDeviceCount = 64; + public const uint k_unTrackedDeviceIndexOther = 4294967294; + public const uint k_unTrackedDeviceIndexInvalid = 4294967295; + public const ulong k_ulInvalidPropertyContainer = 0; + public const uint k_unInvalidPropertyTag = 0; + public const ulong k_ulInvalidDriverHandle = 0; + public const uint k_unFloatPropertyTag = 1; + public const uint k_unInt32PropertyTag = 2; + public const uint k_unUint64PropertyTag = 3; + public const uint k_unBoolPropertyTag = 4; + public const uint k_unStringPropertyTag = 5; + public const uint k_unErrorPropertyTag = 6; + public const uint k_unDoublePropertyTag = 7; + public const uint k_unHmdMatrix34PropertyTag = 20; + public const uint k_unHmdMatrix44PropertyTag = 21; + public const uint k_unHmdVector3PropertyTag = 22; + public const uint k_unHmdVector4PropertyTag = 23; + public const uint k_unHmdVector2PropertyTag = 24; + public const uint k_unHmdQuadPropertyTag = 25; + public const uint k_unHiddenAreaPropertyTag = 30; + public const uint k_unPathHandleInfoTag = 31; + public const uint k_unActionPropertyTag = 32; + public const uint k_unInputValuePropertyTag = 33; + public const uint k_unWildcardPropertyTag = 34; + public const uint k_unHapticVibrationPropertyTag = 35; + public const uint k_unSkeletonPropertyTag = 36; + public const uint k_unSpatialAnchorPosePropertyTag = 40; + public const uint k_unJsonPropertyTag = 41; + public const uint k_unActiveActionSetPropertyTag = 42; + public const uint k_unOpenVRInternalReserved_Start = 1000; + public const uint k_unOpenVRInternalReserved_End = 10000; + public const uint k_unMaxPropertyStringSize = 32768; + public const ulong k_ulInvalidActionHandle = 0; + public const ulong k_ulInvalidActionSetHandle = 0; + public const ulong k_ulInvalidInputValueHandle = 0; + public const uint k_unControllerStateAxisCount = 5; + public const ulong k_ulOverlayHandleInvalid = 0; + public const uint k_unMaxDistortionFunctionParameters = 8; + public const uint k_unScreenshotHandleInvalid = 0; + public const string IVRSystem_Version = "IVRSystem_022"; + public const string IVRExtendedDisplay_Version = "IVRExtendedDisplay_001"; + public const string IVRTrackedCamera_Version = "IVRTrackedCamera_006"; + public const uint k_unMaxApplicationKeyLength = 128; + public const string k_pch_MimeType_HomeApp = "vr/home"; + public const string k_pch_MimeType_GameTheater = "vr/game_theater"; + public const string IVRApplications_Version = "IVRApplications_007"; + public const string IVRChaperone_Version = "IVRChaperone_004"; + public const string IVRChaperoneSetup_Version = "IVRChaperoneSetup_006"; + public const string IVRCompositor_Version = "IVRCompositor_027"; + public const uint k_unVROverlayMaxKeyLength = 128; + public const uint k_unVROverlayMaxNameLength = 128; + public const uint k_unMaxOverlayCount = 128; + public const uint k_unMaxOverlayIntersectionMaskPrimitivesCount = 32; + public const string IVROverlay_Version = "IVROverlay_025"; + public const string IVROverlayView_Version = "IVROverlayView_003"; + public const uint k_unHeadsetViewMaxWidth = 3840; + public const uint k_unHeadsetViewMaxHeight = 2160; + public const string k_pchHeadsetViewOverlayKey = "system.HeadsetView"; + public const string IVRHeadsetView_Version = "IVRHeadsetView_001"; + public const string k_pch_Controller_Component_GDC2015 = "gdc2015"; + public const string k_pch_Controller_Component_Base = "base"; + public const string k_pch_Controller_Component_Tip = "tip"; + public const string k_pch_Controller_Component_HandGrip = "handgrip"; + public const string k_pch_Controller_Component_Status = "status"; + public const string IVRRenderModels_Version = "IVRRenderModels_006"; + public const uint k_unNotificationTextMaxSize = 256; + public const string IVRNotifications_Version = "IVRNotifications_002"; + public const uint k_unMaxSettingsKeyLength = 128; + public const string IVRSettings_Version = "IVRSettings_003"; + public const string k_pch_SteamVR_Section = "steamvr"; + public const string k_pch_SteamVR_RequireHmd_String = "requireHmd"; + public const string k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver"; + public const string k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd"; + public const string k_pch_SteamVR_DisplayDebug_Bool = "displayDebug"; + public const string k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe"; + public const string k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX"; + public const string k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY"; + public const string k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps"; + public const string k_pch_SteamVR_LogLevel_Int32 = "loglevel"; + public const string k_pch_SteamVR_IPD_Float = "ipd"; + public const string k_pch_SteamVR_Background_String = "background"; + public const string k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection"; + public const string k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight"; + public const string k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius"; + public const string k_pch_SteamVR_GridColor_String = "gridColor"; + public const string k_pch_SteamVR_PlayAreaColor_String = "playAreaColor"; + public const string k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor"; + public const string k_pch_SteamVR_ShowStage_Bool = "showStage"; + public const string k_pch_SteamVR_DrawTrackingReferences_Bool = "drawTrackingReferences"; + public const string k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers"; + public const string k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers"; + public const string k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees"; + public const string k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement"; + public const string k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip"; + public const string k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses"; + public const string k_pch_SteamVR_SupersampleScale_Float = "supersampleScale"; + public const string k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution"; + public const string k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing"; + public const string k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride"; + public const string k_pch_SteamVR_FramesToThrottle_Int32 = "framesToThrottle"; + public const string k_pch_SteamVR_AdditionalFramesToPredict_Int32 = "additionalFramesToPredict"; + public const string k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync"; + public const string k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking"; + public const string k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView"; + public const string k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView"; + public const string k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView"; + public const string k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode"; + public const string k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye"; + public const string k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry"; + public const string k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized"; + public const string k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph"; + public const string k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch"; + public const string k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch"; + public const string k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch"; + public const string k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard"; + public const string k_pch_SteamVR_EnableHomeApp = "enableHomeApp"; + public const string k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec"; + public const string k_pch_SteamVR_RetailDemo_Bool = "retailDemo"; + public const string k_pch_SteamVR_IpdOffset_Float = "ipdOffset"; + public const string k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering"; + public const string k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride"; + public const string k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync"; + public const string k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode"; + public const string k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver"; + public const string k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor"; + public const string k_pch_SteamVR_DebugInputBinding = "debugInputBinding"; + public const string k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid"; + public const string k_pch_SteamVR_RenderCameraMode = "renderCameraMode"; + public const string k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling"; + public const string k_pch_SteamVR_EnableSafeMode = "enableSafeMode"; + public const string k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate"; + public const string k_pch_SteamVR_LastVersionNotice = "lastVersionNotice"; + public const string k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate"; + public const string k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR"; + public const string k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG"; + public const string k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB"; + public const string k_pch_SteamVR_CustomIconStyle_String = "customIconStyle"; + public const string k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle"; + public const string k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate"; + public const string k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority"; + public const string k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2"; + public const string k_pch_SteamVR_BlockOculusSDKOnOpenVRLaunchOption_Bool = "blockOculusSDKOnOpenVRLaunchOption"; + public const string k_pch_SteamVR_BlockOculusSDKOnAllLaunches_Bool = "blockOculusSDKOnAllLaunches"; + public const string k_pch_SteamVR_HDCPLegacyCompatibility_Bool = "hdcp14legacyCompatibility"; + public const string k_pch_SteamVR_UsePrism_Bool = "usePrism"; + public const string k_pch_DirectMode_Section = "direct_mode"; + public const string k_pch_DirectMode_Enable_Bool = "enable"; + public const string k_pch_DirectMode_Count_Int32 = "count"; + public const string k_pch_DirectMode_EdidVid_Int32 = "edidVid"; + public const string k_pch_DirectMode_EdidPid_Int32 = "edidPid"; + public const string k_pch_Lighthouse_Section = "driver_lighthouse"; + public const string k_pch_Lighthouse_DisableIMU_Bool = "disableimu"; + public const string k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd"; + public const string k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation"; + public const string k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug"; + public const string k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation"; + public const string k_pch_Lighthouse_DBHistory_Bool = "dbhistory"; + public const string k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth"; + public const string k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations"; + public const string k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2"; + public const string k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations"; + public const string k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback"; + public const string k_pch_Null_Section = "driver_null"; + public const string k_pch_Null_SerialNumber_String = "serialNumber"; + public const string k_pch_Null_ModelNumber_String = "modelNumber"; + public const string k_pch_Null_WindowX_Int32 = "windowX"; + public const string k_pch_Null_WindowY_Int32 = "windowY"; + public const string k_pch_Null_WindowWidth_Int32 = "windowWidth"; + public const string k_pch_Null_WindowHeight_Int32 = "windowHeight"; + public const string k_pch_Null_RenderWidth_Int32 = "renderWidth"; + public const string k_pch_Null_RenderHeight_Int32 = "renderHeight"; + public const string k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons"; + public const string k_pch_Null_DisplayFrequency_Float = "displayFrequency"; + public const string k_pch_WindowsMR_Section = "driver_holographic"; + public const string k_pch_UserInterface_Section = "userinterface"; + public const string k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop"; + public const string k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray"; + public const string k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized"; + public const string k_pch_UserInterface_Screenshots_Bool = "screenshots"; + public const string k_pch_UserInterface_ScreenshotType_Int = "screenshotType"; + public const string k_pch_Notifications_Section = "notifications"; + public const string k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb"; + public const string k_pch_Keyboard_Section = "keyboard"; + public const string k_pch_Keyboard_TutorialCompletions = "TutorialCompletions"; + public const string k_pch_Keyboard_ScaleX = "ScaleX"; + public const string k_pch_Keyboard_ScaleY = "ScaleY"; + public const string k_pch_Keyboard_OffsetLeftX = "OffsetLeftX"; + public const string k_pch_Keyboard_OffsetRightX = "OffsetRightX"; + public const string k_pch_Keyboard_OffsetY = "OffsetY"; + public const string k_pch_Keyboard_Smoothing = "Smoothing"; + public const string k_pch_Perf_Section = "perfcheck"; + public const string k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD"; + public const string k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore"; + public const string k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit"; + public const string k_pch_Perf_TestData_Float = "perfTestData"; + public const string k_pch_Perf_GPUProfiling_Bool = "GPUProfiling"; + public const string k_pch_CollisionBounds_Section = "collisionBounds"; + public const string k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle"; + public const string k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn"; + public const string k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn"; + public const string k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn"; + public const string k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance"; + public const string k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight"; + public const string k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR"; + public const string k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG"; + public const string k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB"; + public const string k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA"; + public const string k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport"; + public const string k_pch_Camera_Section = "camera"; + public const string k_pch_Camera_EnableCamera_Bool = "enableCamera"; + public const string k_pch_Camera_ShowOnController_Bool = "showOnController"; + public const string k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds"; + public const string k_pch_Camera_RoomView_Int32 = "roomView"; + public const string k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR"; + public const string k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG"; + public const string k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB"; + public const string k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA"; + public const string k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength"; + public const string k_pch_Camera_RoomViewStyle_Int32 = "roomViewStyle"; + public const string k_pch_audio_Section = "audio"; + public const string k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice"; + public const string k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride"; + public const string k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride"; + public const string k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName"; + public const string k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice"; + public const string k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride"; + public const string k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride"; + public const string k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName"; + public const string k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror"; + public const string k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice"; + public const string k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName"; + public const string k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice"; + public const string k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice"; + public const string k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume"; + public const string k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId"; + public const string k_pch_audio_VIVEHDMIGain = "viveHDMIGain"; + public const string k_pch_audio_DualSpeakerAndJackOutput_Bool = "dualSpeakerAndJackOutput"; + public const string k_pch_audio_MuteMicMonitor_Bool = "muteMicMonitor"; + public const string k_pch_Power_Section = "power"; + public const string k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit"; + public const string k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout"; + public const string k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout"; + public const string k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout"; + public const string k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress"; + public const string k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby"; + public const string k_pch_Dashboard_Section = "dashboard"; + public const string k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard"; + public const string k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode"; + public const string k_pch_Dashboard_Position = "position"; + public const string k_pch_Dashboard_DesktopScale = "desktopScale"; + public const string k_pch_Dashboard_DashboardScale = "dashboardScale"; + public const string k_pch_Dashboard_UseStandaloneSystemLayer = "standaloneSystemLayer"; + public const string k_pch_modelskin_Section = "modelskins"; + public const string k_pch_Driver_Enable_Bool = "enable"; + public const string k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode"; + public const string k_pch_Driver_LoadPriority_Int32 = "loadPriority"; + public const string k_pch_WebInterface_Section = "WebInterface"; + public const string k_pch_VRWebHelper_Section = "VRWebHelper"; + public const string k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled"; + public const string k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort"; + public const string k_pch_TrackingOverride_Section = "TrackingOverrides"; + public const string k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL"; + public const string k_pch_App_BindingLegacyAPISuffix_String = "_legacy"; + public const string k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput"; + public const string k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL"; + public const string k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL"; + public const string k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave"; + public const string k_pch_App_DominantHand_Int32 = "DominantHand"; + public const string k_pch_App_BlockOculusSDK_Bool = "blockOculusSDK"; + public const string k_pch_Trackers_Section = "trackers"; + public const string k_pch_DesktopUI_Section = "DesktopUI"; + public const string k_pch_LastKnown_Section = "LastKnown"; + public const string k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer"; + public const string k_pch_LastKnown_HMDModel_String = "HMDModel"; + public const string k_pch_DismissedWarnings_Section = "DismissedWarnings"; + public const string k_pch_Input_Section = "input"; + public const string k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation"; + public const string k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation"; + public const string k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone"; + public const string k_pch_GpuSpeed_Section = "GpuSpeed"; + public const string IVRScreenshots_Version = "IVRScreenshots_001"; + public const string IVRResources_Version = "IVRResources_001"; + public const string IVRDriverManager_Version = "IVRDriverManager_001"; + public const uint k_unMaxActionNameLength = 64; + public const uint k_unMaxActionSetNameLength = 64; + public const uint k_unMaxActionOriginCount = 16; + public const uint k_unMaxBoneNameLength = 32; + public const int k_nActionSetOverlayGlobalPriorityMin = 16777216; + public const int k_nActionSetOverlayGlobalPriorityMax = 33554431; + public const int k_nActionSetPriorityReservedMin = 33554432; + public const string IVRInput_Version = "IVRInput_010"; + public const ulong k_ulInvalidIOBufferHandle = 0; + public const string IVRIOBuffer_Version = "IVRIOBuffer_002"; + public const uint k_ulInvalidSpatialAnchorHandle = 0; + public const string IVRSpatialAnchors_Version = "IVRSpatialAnchors_001"; + public const string IVRDebug_Version = "IVRDebug_001"; + public const ulong k_ulDisplayRedirectContainer = 25769803779; + public const string IVRProperties_Version = "IVRProperties_001"; + public const string k_pchPathUserHandRight = "/user/hand/right"; + public const string k_pchPathUserHandLeft = "/user/hand/left"; + public const string k_pchPathUserHandPrimary = "/user/hand/primary"; + public const string k_pchPathUserHandSecondary = "/user/hand/secondary"; + public const string k_pchPathUserHead = "/user/head"; + public const string k_pchPathUserGamepad = "/user/gamepad"; + public const string k_pchPathUserTreadmill = "/user/treadmill"; + public const string k_pchPathUserStylus = "/user/stylus"; + public const string k_pchPathDevices = "/devices"; + public const string k_pchPathDevicePath = "/device_path"; + public const string k_pchPathBestAliasPath = "/best_alias_path"; + public const string k_pchPathBoundTrackerAliasPath = "/bound_tracker_path"; + public const string k_pchPathBoundTrackerRole = "/bound_tracker_role"; + public const string k_pchPathPoseRaw = "/pose/raw"; + public const string k_pchPathPoseTip = "/pose/tip"; + public const string k_pchPathPoseGrip = "/pose/grip"; + public const string k_pchPathSystemButtonClick = "/input/system/click"; + public const string k_pchPathProximity = "/proximity"; + public const string k_pchPathControllerTypePrefix = "/controller_type/"; + public const string k_pchPathInputProfileSuffix = "/input_profile"; + public const string k_pchPathBindingNameSuffix = "/binding_name"; + public const string k_pchPathBindingUrlSuffix = "/binding_url"; + public const string k_pchPathBindingErrorSuffix = "/binding_error"; + public const string k_pchPathActiveActionSets = "/active_action_sets"; + public const string k_pchPathComponentUpdates = "/total_component_updates"; + public const string k_pchPathUserFootLeft = "/user/foot/left"; + public const string k_pchPathUserFootRight = "/user/foot/right"; + public const string k_pchPathUserShoulderLeft = "/user/shoulder/left"; + public const string k_pchPathUserShoulderRight = "/user/shoulder/right"; + public const string k_pchPathUserElbowLeft = "/user/elbow/left"; + public const string k_pchPathUserElbowRight = "/user/elbow/right"; + public const string k_pchPathUserKneeLeft = "/user/knee/left"; + public const string k_pchPathUserKneeRight = "/user/knee/right"; + public const string k_pchPathUserWaist = "/user/waist"; + public const string k_pchPathUserChest = "/user/chest"; + public const string k_pchPathUserCamera = "/user/camera"; + public const string k_pchPathUserKeyboard = "/user/keyboard"; + public const string k_pchPathClientAppKey = "/client_info/app_key"; + public const ulong k_ulInvalidPathHandle = 0; + public const string IVRPaths_Version = "IVRPaths_001"; + public const string IVRBlockQueue_Version = "IVRBlockQueue_004"; + + static uint VRToken { get; set; } + + const string FnTable_Prefix = "FnTable:"; + + class COpenVRContext + { + public COpenVRContext() { Clear(); } + + public void Clear() + { + m_pVRSystem = null; + m_pVRChaperone = null; + m_pVRChaperoneSetup = null; + m_pVRCompositor = null; + m_pVRHeadsetView = null; + m_pVROverlay = null; + m_pVROverlayView = null; + m_pVRRenderModels = null; + m_pVRExtendedDisplay = null; + m_pVRSettings = null; + m_pVRApplications = null; + m_pVRScreenshots = null; + m_pVRTrackedCamera = null; + m_pVRInput = null; + m_pVRIOBuffer = null; + m_pVRSpatialAnchors = null; + m_pVRNotifications = null; + m_pVRDebug = null; + } + + void CheckClear() + { + if (VRToken != GetInitToken()) + { + Clear(); + VRToken = GetInitToken(); + } + } + + public CVRSystem VRSystem() + { + CheckClear(); + if (m_pVRSystem == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSystem_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSystem = new CVRSystem(pInterface); + } + return m_pVRSystem; + } + + public CVRChaperone VRChaperone() + { + CheckClear(); + if (m_pVRChaperone == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRChaperone_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRChaperone = new CVRChaperone(pInterface); + } + return m_pVRChaperone; + } + + public CVRChaperoneSetup VRChaperoneSetup() + { + CheckClear(); + if (m_pVRChaperoneSetup == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRChaperoneSetup_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRChaperoneSetup = new CVRChaperoneSetup(pInterface); + } + return m_pVRChaperoneSetup; + } + + public CVRCompositor VRCompositor() + { + CheckClear(); + if (m_pVRCompositor == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRCompositor_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRCompositor = new CVRCompositor(pInterface); + } + return m_pVRCompositor; + } + + public CVRHeadsetView VRHeadsetView() + { + CheckClear(); + if (m_pVRHeadsetView == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRHeadsetView_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRHeadsetView = new CVRHeadsetView(pInterface); + } + return m_pVRHeadsetView; + } + + public CVROverlay VROverlay() + { + CheckClear(); + if (m_pVROverlay == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVROverlay_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVROverlay = new CVROverlay(pInterface); + } + return m_pVROverlay; + } + + public CVROverlayView VROverlayView() + { + CheckClear(); + if (m_pVROverlayView == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVROverlayView_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVROverlayView = new CVROverlayView(pInterface); + } + return m_pVROverlayView; + } + + public CVRRenderModels VRRenderModels() + { + CheckClear(); + if (m_pVRRenderModels == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRRenderModels_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRRenderModels = new CVRRenderModels(pInterface); + } + return m_pVRRenderModels; + } + + public CVRExtendedDisplay VRExtendedDisplay() + { + CheckClear(); + if (m_pVRExtendedDisplay == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRExtendedDisplay_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRExtendedDisplay = new CVRExtendedDisplay(pInterface); + } + return m_pVRExtendedDisplay; + } + + public CVRSettings VRSettings() + { + CheckClear(); + if (m_pVRSettings == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSettings_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSettings = new CVRSettings(pInterface); + } + return m_pVRSettings; + } + + public CVRApplications VRApplications() + { + CheckClear(); + if (m_pVRApplications == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRApplications_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRApplications = new CVRApplications(pInterface); + } + return m_pVRApplications; + } + + public CVRScreenshots VRScreenshots() + { + CheckClear(); + if (m_pVRScreenshots == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRScreenshots_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRScreenshots = new CVRScreenshots(pInterface); + } + return m_pVRScreenshots; + } + + public CVRTrackedCamera VRTrackedCamera() + { + CheckClear(); + if (m_pVRTrackedCamera == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRTrackedCamera_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRTrackedCamera = new CVRTrackedCamera(pInterface); + } + return m_pVRTrackedCamera; + } + + public CVRInput VRInput() + { + CheckClear(); + if (m_pVRInput == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRInput_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRInput = new CVRInput(pInterface); + } + return m_pVRInput; + } + + public CVRIOBuffer VRIOBuffer() + { + CheckClear(); + if (m_pVRIOBuffer == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRIOBuffer_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRIOBuffer = new CVRIOBuffer(pInterface); + } + return m_pVRIOBuffer; + } + + public CVRSpatialAnchors VRSpatialAnchors() + { + CheckClear(); + if (m_pVRSpatialAnchors == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSpatialAnchors_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSpatialAnchors = new CVRSpatialAnchors(pInterface); + } + return m_pVRSpatialAnchors; + } + + public CVRDebug VRDebug() + { + CheckClear(); + if (m_pVRDebug == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRDebug_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRDebug = new CVRDebug(pInterface); + } + return m_pVRDebug; + } + + public CVRNotifications VRNotifications() + { + CheckClear(); + if (m_pVRNotifications == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRNotifications_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRNotifications = new CVRNotifications(pInterface); + } + return m_pVRNotifications; + } + + private CVRSystem m_pVRSystem; + private CVRChaperone m_pVRChaperone; + private CVRChaperoneSetup m_pVRChaperoneSetup; + private CVRCompositor m_pVRCompositor; + private CVRHeadsetView m_pVRHeadsetView; + private CVROverlay m_pVROverlay; + private CVROverlayView m_pVROverlayView; + private CVRRenderModels m_pVRRenderModels; + private CVRExtendedDisplay m_pVRExtendedDisplay; + private CVRSettings m_pVRSettings; + private CVRApplications m_pVRApplications; + private CVRScreenshots m_pVRScreenshots; + private CVRTrackedCamera m_pVRTrackedCamera; + private CVRInput m_pVRInput; + private CVRIOBuffer m_pVRIOBuffer; + private CVRSpatialAnchors m_pVRSpatialAnchors; + private CVRNotifications m_pVRNotifications; + private CVRDebug m_pVRDebug; + }; + + private static COpenVRContext _OpenVRInternal_ModuleContext = null; + static COpenVRContext OpenVRInternal_ModuleContext + { + get + { + if (_OpenVRInternal_ModuleContext == null) + _OpenVRInternal_ModuleContext = new COpenVRContext(); + return _OpenVRInternal_ModuleContext; + } + } + + public static CVRSystem System { get { return OpenVRInternal_ModuleContext.VRSystem(); } } + public static CVRChaperone Chaperone { get { return OpenVRInternal_ModuleContext.VRChaperone(); } } + public static CVRChaperoneSetup ChaperoneSetup { get { return OpenVRInternal_ModuleContext.VRChaperoneSetup(); } } + public static CVRCompositor Compositor { get { return OpenVRInternal_ModuleContext.VRCompositor(); } } + public static CVRHeadsetView HeadsetView { get { return OpenVRInternal_ModuleContext.VRHeadsetView(); } } + public static CVROverlay Overlay { get { return OpenVRInternal_ModuleContext.VROverlay(); } } + public static CVROverlayView OverlayView { get { return OpenVRInternal_ModuleContext.VROverlayView(); } } + public static CVRRenderModels RenderModels { get { return OpenVRInternal_ModuleContext.VRRenderModels(); } } + public static CVRExtendedDisplay ExtendedDisplay { get { return OpenVRInternal_ModuleContext.VRExtendedDisplay(); } } + public static CVRSettings Settings { get { return OpenVRInternal_ModuleContext.VRSettings(); } } + public static CVRApplications Applications { get { return OpenVRInternal_ModuleContext.VRApplications(); } } + public static CVRScreenshots Screenshots { get { return OpenVRInternal_ModuleContext.VRScreenshots(); } } + public static CVRTrackedCamera TrackedCamera { get { return OpenVRInternal_ModuleContext.VRTrackedCamera(); } } + public static CVRInput Input { get { return OpenVRInternal_ModuleContext.VRInput(); } } + public static CVRIOBuffer IOBuffer { get { return OpenVRInternal_ModuleContext.VRIOBuffer(); } } + public static CVRSpatialAnchors SpatialAnchors { get { return OpenVRInternal_ModuleContext.VRSpatialAnchors(); } } + public static CVRNotifications Notifications { get { return OpenVRInternal_ModuleContext.VRNotifications(); } } + public static CVRDebug Debug { get { return OpenVRInternal_ModuleContext.VRDebug(); } } + + + /** Finds the active installation of vrclient.dll and initializes it */ + public static CVRSystem Init(ref EVRInitError peError, EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene, string pchStartupInfo = "") + { + try + { + VRToken = InitInternal2(ref peError, eApplicationType, pchStartupInfo); + } + catch (EntryPointNotFoundException) + { + VRToken = InitInternal(ref peError, eApplicationType); + } + + OpenVRInternal_ModuleContext.Clear(); + + if (peError != EVRInitError.None) + return null; + + bool bInterfaceValid = IsInterfaceVersionValid(IVRSystem_Version); + if (!bInterfaceValid) + { + ShutdownInternal(); + peError = EVRInitError.Init_InterfaceNotFound; + return null; + } + + return System; + } + + /** unloads vrclient.dll. Any interface pointers from the interface are + * invalid after this point */ + public static void Shutdown() + { + ShutdownInternal(); + } + + } + + + +} +#endif + diff --git a/VRGameOverlay/openvr_api.dll b/VRGameOverlay/openvr_api.dll new file mode 100644 index 0000000000000000000000000000000000000000..a4ad76404d562e80910f134d366c2a64851da34c GIT binary patch literal 818904 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 z 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ℑ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 literal 0 HcmV?d00001 diff --git a/ZTMZ.PacenoteTool.Base/Config.cs b/ZTMZ.PacenoteTool.Base/Config.cs index a071f24..e24ea46 100644 --- a/ZTMZ.PacenoteTool.Base/Config.cs +++ b/ZTMZ.PacenoteTool.Base/Config.cs @@ -204,6 +204,13 @@ namespace ZTMZ.PacenoteTool.Base get => this._UI_ShowHud; } + private bool _UI_ShowVROverlay = true; + public bool UI_ShowVROverlay + { + set { this._UI_ShowVROverlay = value; this._userconfig["UI_ShowVROverlay"] = value; } + get => this._UI_ShowVROverlay; + } + private double _UI_PlaybackAdjustSeconds = 0; public double UI_PlaybackAdjustSeconds { @@ -472,7 +479,67 @@ namespace ZTMZ.PacenoteTool.Base set { this._HudTelemetryShowSuspensionBars = value; this._userconfig["HudTelemetryShowSuspensionBars"] = value; } get => this._HudTelemetryShowSuspensionBars; } - + + #endregion + + #region VrOverlay + + private bool _VrShowOverlay = true; + public bool VrShowOverlay + { + set { this._VrShowOverlay = value; this._userconfig["VrShowOverlay"] = value; } + get => this._VrShowOverlay; + } + + public float _VrOverlayPositionX = 0.0f; + public float VrOverlayPositionX + { + set { this._VrOverlayPositionX = value; this._userconfig["VrOverlayPositionX"] = value; } + get => this._VrOverlayPositionX; + } + + public float _VrOverlayPositionY = 0.0f; + public float VrOverlayPositionY + { + set { this._VrOverlayPositionY = value; this._userconfig["VrOverlayPositionY"] = value; } + get => this._VrOverlayPositionY; + } + + public float _VrOverlayPositionZ = 1.0f; + public float VrOverlayPositionZ + { + set { this._VrOverlayPositionZ = value; this._userconfig["VrOverlayPositionZ"] = value; } + get => this._VrOverlayPositionZ; + } + + public float _VrOverlayRotationX = 0.0f; + public float VrOverlayRotationX + { + set { this._VrOverlayRotationX = value; this._userconfig["VrOverlayRotationX"] = value; } + get => this._VrOverlayRotationX; + } + + public float _VrOverlayRotationY = 0.0f; + public float VrOverlayRotationY + { + set { this._VrOverlayRotationY = value; this._userconfig["VrOverlayRotationY"] = value; } + get => this._VrOverlayRotationY; + } + + public float _VrOverlayRotationZ = 0.0f; + public float VrOverlayRotationZ + { + set { this._VrOverlayRotationZ = value; this._userconfig["VrOverlayRotationZ"] = value; } + get => this._VrOverlayRotationZ; + } + + public float _VrOverlayScale = 0.0f; + public float VrOverlayScale + { + set { this._VrOverlayScale = value; this._userconfig["VrOverlayScale"] = value; } + get => this._VrOverlayScale; + } + #endregion private string _Language = CultureInfo.CurrentCulture.Name.ToLower(); diff --git a/ZTMZ.PacenoteTool.sln b/ZTMZ.PacenoteTool.sln index 9e1ef88..b894ff6 100644 --- a/ZTMZ.PacenoteTool.sln +++ b/ZTMZ.PacenoteTool.sln @@ -17,18 +17,20 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "NewFolder1", "NewFolder1", ProjectSection(SolutionItems) = preProject autoupdate.json = autoupdate.json autoupdate.xml = autoupdate.xml - README.md = README.md README.en.md = README.en.md + README.md = README.md README.zh.md = README.zh.md EndProjectSection EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZTMZ.PacenoteTool.AudioPackageManager", "ZTMZ.PacenoteTool.AudioPackageManager\ZTMZ.PacenoteTool.AudioPackageManager.csproj", "{887AFC73-AACD-4F7C-B688-3CDA9895423F}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ZTMZ.PacenoteTool.AudioPackageManager", "ZTMZ.PacenoteTool.AudioPackageManager\ZTMZ.PacenoteTool.AudioPackageManager.csproj", "{887AFC73-AACD-4F7C-B688-3CDA9895423F}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ZTMZ.PacenoteTool.Codemasters", "ZTMZ.PacenoteTool.Codemasters\ZTMZ.PacenoteTool.Codemasters.csproj", "{487E97A7-F3C8-4044-8926-FD441BF9328F}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZTMZ.PacenoteTool.Codemasters", "ZTMZ.PacenoteTool.Codemasters\ZTMZ.PacenoteTool.Codemasters.csproj", "{487E97A7-F3C8-4044-8926-FD441BF9328F}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ZTMZ.PacenoteTool.RBR", "ZTMZ.PacenoteTool.RBR\ZTMZ.PacenoteTool.RBR.csproj", "{01C5E423-60FD-4B65-9AA0-BC5FDE22A46A}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ZTMZ.PacenoteTool.RBR", "ZTMZ.PacenoteTool.RBR\ZTMZ.PacenoteTool.RBR.csproj", "{01C5E423-60FD-4B65-9AA0-BC5FDE22A46A}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "GameOverlay", "GameOverlay\GameOverlay.csproj", "{4E8882A2-F33C-4099-B801-7F9D1281C125}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "GameOverlay", "GameOverlay\GameOverlay.csproj", "{4E8882A2-F33C-4099-B801-7F9D1281C125}" +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VRGameOverlay", "VRGameOverlay\VRGameOverlay.csproj", "{258718C6-7093-428F-AF65-4AF12028D193}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -91,6 +93,12 @@ Global {4E8882A2-F33C-4099-B801-7F9D1281C125}.Release_Portable|Any CPU.Build.0 = Debug|Any CPU {4E8882A2-F33C-4099-B801-7F9D1281C125}.Release|Any CPU.ActiveCfg = Release|Any CPU {4E8882A2-F33C-4099-B801-7F9D1281C125}.Release|Any CPU.Build.0 = Release|Any CPU + {258718C6-7093-428F-AF65-4AF12028D193}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {258718C6-7093-428F-AF65-4AF12028D193}.Debug|Any CPU.Build.0 = Debug|Any CPU + {258718C6-7093-428F-AF65-4AF12028D193}.Release_Portable|Any CPU.ActiveCfg = Release|Any CPU + {258718C6-7093-428F-AF65-4AF12028D193}.Release_Portable|Any CPU.Build.0 = Release|Any CPU + {258718C6-7093-428F-AF65-4AF12028D193}.Release|Any CPU.ActiveCfg = Release|Any CPU + {258718C6-7093-428F-AF65-4AF12028D193}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/ZTMZ.PacenoteTool/GameOverlayManager.cs b/ZTMZ.PacenoteTool/GameOverlayManager.cs index ca0da42..ee20fb1 100644 --- a/ZTMZ.PacenoteTool/GameOverlayManager.cs +++ b/ZTMZ.PacenoteTool/GameOverlayManager.cs @@ -17,6 +17,9 @@ using SharpDX.Direct2D1; using ZTMZ.PacenoteTool.Base; using Geometry = GameOverlay.Drawing.Geometry; using Image = GameOverlay.Drawing.Image; +using Point = GameOverlay.Drawing.Point; +using Rectangle = GameOverlay.Drawing.Rectangle; +using Color = GameOverlay.Drawing.Color; using ZTMZ.PacenoteTool.Base.Game; namespace ZTMZ.PacenoteTool diff --git a/ZTMZ.PacenoteTool/MainWindow.xaml b/ZTMZ.PacenoteTool/MainWindow.xaml index 6b14baf..22449a5 100644 --- a/ZTMZ.PacenoteTool/MainWindow.xaml +++ b/ZTMZ.PacenoteTool/MainWindow.xaml @@ -417,6 +417,8 @@ Content="{DynamicResource ResourceKey=ui.btn_audioTool}"/>