From 90f096c497f738cb1aedc33ab325ddf415ed3a3b Mon Sep 17 00:00:00 2001 From: pypy Date: Fri, 16 Aug 2019 22:53:04 +0900 Subject: [PATCH] Initial commit --- .gitattributes | 63 + .gitignore | 261 + App.config | 6 + Browser.cs | 72 + CpuMonitor.cs | 82 + Discord.cs | 111 + JsonSerializer.cs | 50 + LogWatcher.cs | 213 + MainForm.Designer.cs | 62 + MainForm.cs | 60 + MainForm.resx | 123 + OpenVR/openvr_api.cs | 7141 +++++++++++++++++++ OpenVR/win32/openvr_api.dll | Bin 0 -> 490784 bytes OpenVR/win64/openvr_api.dll | Bin 0 -> 598816 bytes Program.cs | 67 + Properties/AssemblyInfo.cs | 36 + Properties/Resources.Designer.cs | 71 + Properties/Resources.resx | 117 + Properties/Settings.Designer.cs | 30 + Properties/Settings.settings | 7 + RenderHandler.cs | 116 + VRCX.cs | 95 + VRCX.csproj | 211 + VRCX.sln | 31 + VRCXStorage.cs | 67 + VRCXVR.cs | 584 ++ VRChatRPC.cs | 55 + VRChatRPC/README.txt | 3 + VRChatRPC/VRChatRPC.dll | Bin 0 -> 14336 bytes VRForm.Designer.cs | 104 + VRForm.cs | 74 + VRForm.resx | 123 + WinApi.cs | 19 + html/.eslintrc.js | 67 + html/app.css | 413 ++ html/app.js | 6645 +++++++++++++++++ html/images/controller_status_off.png | Bin 0 -> 1479 bytes html/images/controller_status_ready.png | Bin 0 -> 2003 bytes html/images/controller_status_ready_low.png | Bin 0 -> 2397 bytes html/images/other_status_off.png | Bin 0 -> 1290 bytes html/images/other_status_ready.png | Bin 0 -> 1810 bytes html/images/other_status_standby.png | Bin 0 -> 1385 bytes html/images/tracker_status_off.png | Bin 0 -> 1279 bytes html/images/tracker_status_ready.png | Bin 0 -> 1799 bytes html/images/tracker_status_ready_low.png | Bin 0 -> 2287 bytes html/index.html | 1722 +++++ html/vr.css | 222 + html/vr.html | 144 + html/vr.js | 726 ++ openvr_api.cs | 7141 +++++++++++++++++++ packages.config | 17 + vrchat.ico | Bin 0 -> 372526 bytes 52 files changed, 27151 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 App.config create mode 100644 Browser.cs create mode 100644 CpuMonitor.cs create mode 100644 Discord.cs create mode 100644 JsonSerializer.cs create mode 100644 LogWatcher.cs create mode 100644 MainForm.Designer.cs create mode 100644 MainForm.cs create mode 100644 MainForm.resx create mode 100644 OpenVR/openvr_api.cs create mode 100644 OpenVR/win32/openvr_api.dll create mode 100644 OpenVR/win64/openvr_api.dll create mode 100644 Program.cs create mode 100644 Properties/AssemblyInfo.cs create mode 100644 Properties/Resources.Designer.cs create mode 100644 Properties/Resources.resx create mode 100644 Properties/Settings.Designer.cs create mode 100644 Properties/Settings.settings create mode 100644 RenderHandler.cs create mode 100644 VRCX.cs create mode 100644 VRCX.csproj create mode 100644 VRCX.sln create mode 100644 VRCXStorage.cs create mode 100644 VRCXVR.cs create mode 100644 VRChatRPC.cs create mode 100644 VRChatRPC/README.txt create mode 100644 VRChatRPC/VRChatRPC.dll create mode 100644 VRForm.Designer.cs create mode 100644 VRForm.cs create mode 100644 VRForm.resx create mode 100644 WinApi.cs create mode 100644 html/.eslintrc.js create mode 100644 html/app.css create mode 100644 html/app.js create mode 100644 html/images/controller_status_off.png create mode 100644 html/images/controller_status_ready.png create mode 100644 html/images/controller_status_ready_low.png create mode 100644 html/images/other_status_off.png create mode 100644 html/images/other_status_ready.png create mode 100644 html/images/other_status_standby.png create mode 100644 html/images/tracker_status_off.png create mode 100644 html/images/tracker_status_ready.png create mode 100644 html/images/tracker_status_ready_low.png create mode 100644 html/index.html create mode 100644 html/vr.css create mode 100644 html/vr.html create mode 100644 html/vr.js create mode 100644 openvr_api.cs create mode 100644 packages.config create mode 100644 vrchat.ico diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..1ff0c423 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,63 @@ +############################################################################### +# Set default behavior to automatically normalize line endings. +############################################################################### +* text=auto + +############################################################################### +# Set default behavior for command prompt diff. +# +# This is need for earlier builds of msysgit that does not have it on by +# default for csharp files. +# Note: This is only used by command line +############################################################################### +#*.cs diff=csharp + +############################################################################### +# Set the merge driver for project and solution files +# +# Merging from the command prompt will add diff markers to the files if there +# are conflicts (Merging from VS is not affected by the settings below, in VS +# the diff markers are never inserted). Diff markers may cause the following +# file extensions to fail to load in VS. An alternative would be to treat +# these files as binary and thus will always conflict and require user +# intervention with every merge. To do so, just uncomment the entries below +############################################################################### +#*.sln merge=binary +#*.csproj merge=binary +#*.vbproj merge=binary +#*.vcxproj merge=binary +#*.vcproj merge=binary +#*.dbproj merge=binary +#*.fsproj merge=binary +#*.lsproj merge=binary +#*.wixproj merge=binary +#*.modelproj merge=binary +#*.sqlproj merge=binary +#*.wwaproj merge=binary + +############################################################################### +# behavior for image files +# +# image files are treated as binary by default. +############################################################################### +#*.jpg binary +#*.png binary +#*.gif binary + +############################################################################### +# diff behavior for common document formats +# +# Convert binary document formats to text before diffing them. This feature +# is only available from the command line. Turn it on by uncommenting the +# entries below. +############################################################################### +#*.doc diff=astextplain +#*.DOC diff=astextplain +#*.docx diff=astextplain +#*.DOCX diff=astextplain +#*.dot diff=astextplain +#*.DOT diff=astextplain +#*.pdf diff=astextplain +#*.PDF diff=astextplain +#*.rtf diff=astextplain +#*.RTF diff=astextplain diff --git a/.gitignore b/.gitignore new file mode 100644 index 00000000..3c4efe20 --- /dev/null +++ b/.gitignore @@ -0,0 +1,261 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. + +# User-specific files +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ + +# Visual Studio 2015 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUNIT +*.VisualState.xml +TestResult.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# DNX +project.lock.json +project.fragment.lock.json +artifacts/ + +*_i.c +*_p.c +*_i.h +*.ilk +*.meta +*.obj +*.pch +*.pdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*.log +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# JustCode is a .NET coding add-in +.JustCode + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# TODO: Comment the next line if you want to checkin your web deploy settings +# but database connection strings (with potential passwords) will be unencrypted +#*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# The packages folder can be ignored because of Package Restore +**/packages/* +# except build/, which is used as an MSBuild target. +!**/packages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/packages/repositories.config +# NuGet v3's project.json files produces more ignoreable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +node_modules/ +orleans.codegen.cs + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm + +# SQL Server files +*.mdf +*.ldf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# JetBrains Rider +.idea/ +*.sln.iml + +# CodeRush +.cr/ + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc \ No newline at end of file diff --git a/App.config b/App.config new file mode 100644 index 00000000..88fa4027 --- /dev/null +++ b/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Browser.cs b/Browser.cs new file mode 100644 index 00000000..97a8bcc6 --- /dev/null +++ b/Browser.cs @@ -0,0 +1,72 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using CefSharp; +using CefSharp.OffScreen; +using SharpDX.Direct3D11; +using System; +using System.Drawing; + +namespace VRCX +{ + public class Browser : ChromiumWebBrowser + { + private Texture2D m_Texture; + + public Browser(Texture2D texture, string address) + : base(address, new BrowserSettings() + { + DefaultEncoding = "UTF-8" + }) + { + m_Texture = texture; + Size = new Size(texture.Description.Width, texture.Description.Height); + RenderHandler.Dispose(); + RenderHandler = new RenderHandler(this); + var options = new BindingOptions() + { + CamelCaseJavascriptNames = false + }; + JavascriptObjectRepository.Register("VRCX", new VRCX(), true, options); + JavascriptObjectRepository.Register("VRCXStorage", new VRCXStorage(), false, options); + } + + public void Render() + { + var handler = (RenderHandler)RenderHandler; + lock (handler.BufferLock) + { + if (handler.Buffer.IsAllocated) + { + var context = m_Texture.Device.ImmediateContext; + var box = context.MapSubresource(m_Texture, 0, MapMode.WriteDiscard, MapFlags.None); + if (box.DataPointer != IntPtr.Zero) + { + var width = handler.Width; + var height = handler.Height; + if (box.RowPitch == width * 4) + { + WinApi.CopyMemory(box.DataPointer, handler.Buffer.AddrOfPinnedObject(), (uint)handler.BufferSize); + } + else + { + var dest = box.DataPointer; + var src = handler.Buffer.AddrOfPinnedObject(); + var pitch = box.RowPitch; + var length = width * 4; + for (var i = 0; i < height; ++i) + { + WinApi.CopyMemory(dest, src, (uint)length); + dest += pitch; + src += length; + } + } + } + context.UnmapSubresource(m_Texture, 0); + } + } + } + } +} \ No newline at end of file diff --git a/CpuMonitor.cs b/CpuMonitor.cs new file mode 100644 index 00000000..27646166 --- /dev/null +++ b/CpuMonitor.cs @@ -0,0 +1,82 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using System.Diagnostics; +using System.Threading; + +namespace VRCX +{ + public static class CpuMonitor + { + public static float CpuUsage { get; private set; } + private static Thread m_Thread; + + public static void Start() + { + if (m_Thread == null) + { + m_Thread = new Thread(() => + { + PerformanceCounter cpuCounter = null; + try + { + cpuCounter = new PerformanceCounter("Processor Information", "% Processor Utility", "_Total", true); + } + catch + { + } + try + { + if (cpuCounter == null) + { + cpuCounter = new PerformanceCounter("Processor", "% Processor Time", "_Total", true); + } + } + catch + { + } + while (m_Thread != null) + { + try + { + if (cpuCounter != null) + { + CpuUsage = cpuCounter.NextValue(); + } + + Thread.Sleep(1000); + } + catch + { + // ThreadInterruptedException + } + } + if (cpuCounter != null) + { + cpuCounter.Dispose(); + } + }); + m_Thread.Start(); + } + } + + public static void Stop() + { + var thread = m_Thread; + if (thread != null) + { + m_Thread = null; + try + { + thread.Interrupt(); + thread.Join(); + } + catch + { + } + } + } + } +} \ No newline at end of file diff --git a/Discord.cs b/Discord.cs new file mode 100644 index 00000000..f963aaf5 --- /dev/null +++ b/Discord.cs @@ -0,0 +1,111 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using DiscordRPC; + +namespace VRCX +{ + public class Discord + { + private static RichPresence m_Presence = new RichPresence(); + private static DiscordRpcClient m_Client; + private static bool m_Active; + + public static void Update() + { + if (m_Client != null) + { + m_Client.Invoke(); + } + if (m_Active) + { + if (m_Client == null) + { + m_Client = new DiscordRpcClient("525953831020920832"); + m_Client.Initialize(); + } + lock (m_Presence) + { + m_Client.SetPresence(m_Presence); + } + } + else if (m_Client != null) + { + m_Client.Dispose(); + m_Client = null; + } + } + + public void SetActive(bool active) + { + m_Active = active; + } + + public void SetText(string details, string state) + { + lock (m_Presence) + { + m_Presence.Details = details; + m_Presence.State = state; + } + } + + public void SetAssets(string largeKey, string largeText, string smallKey, string smallText) + { + lock (m_Presence) + { + if (string.IsNullOrEmpty(largeKey) && + string.IsNullOrEmpty(smallKey)) + { + m_Presence.Assets = null; + } + else + { + if (m_Presence.Assets == null) + { + m_Presence.Assets = new Assets(); + } + m_Presence.Assets.LargeImageKey = largeKey; + m_Presence.Assets.LargeImageText = largeText; + m_Presence.Assets.SmallImageKey = smallKey; + m_Presence.Assets.SmallImageText = smallText; + } + } + } + + // JSB Sucks + public void SetTimestamps(double startUnixMilliseconds, double endUnixMilliseconds) + { + SetTimestamps((ulong)startUnixMilliseconds, (ulong)endUnixMilliseconds); + } + + public static void SetTimestamps(ulong startUnixMilliseconds, ulong endUnixMilliseconds) + { + lock (m_Presence) + { + if (startUnixMilliseconds == 0) + { + m_Presence.Timestamps = null; + } + else + { + if (m_Presence.Timestamps == null) + { + m_Presence.Timestamps = new Timestamps(); + } + m_Presence.Timestamps.StartUnixMilliseconds = startUnixMilliseconds; + if (endUnixMilliseconds == 0) + { + m_Presence.Timestamps.End = null; + } + else + { + m_Presence.Timestamps.EndUnixMilliseconds = endUnixMilliseconds; + } + } + } + } + } +} \ No newline at end of file diff --git a/JsonSerializer.cs b/JsonSerializer.cs new file mode 100644 index 00000000..400f77c0 --- /dev/null +++ b/JsonSerializer.cs @@ -0,0 +1,50 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using Newtonsoft.Json; +using System.IO; +using System.Text; + +namespace VRCX +{ + public static class JsonSerializer + { + public static void Serialize(string path, T obj) + { + try + { + using (var file = File.Open(path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite)) + using (var stream = new StreamWriter(file, Encoding.UTF8)) + using (var writer = new JsonTextWriter(stream)) + { + var serializer = Newtonsoft.Json.JsonSerializer.CreateDefault(); + serializer.Formatting = Formatting.Indented; + serializer.Serialize(writer, obj, typeof(T)); + } + } + catch + { + } + } + + public static bool Deserialize(string path, ref T obj) + { + try + { + using (var file = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) + using (var stream = new StreamReader(file, Encoding.UTF8)) + using (var reader = new JsonTextReader(stream)) + { + obj = Newtonsoft.Json.JsonSerializer.CreateDefault().Deserialize(reader); + return true; + } + } + catch + { + } + return false; + } + } +} \ No newline at end of file diff --git a/LogWatcher.cs b/LogWatcher.cs new file mode 100644 index 00000000..c6ee91fe --- /dev/null +++ b/LogWatcher.cs @@ -0,0 +1,213 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using System; +using System.Collections.Generic; +using System.IO; +using System.Text; +using System.Threading; + +namespace VRCX +{ + public class VRCX_LogWatcher + { + private static List m_GameLog = new List(); + private static Thread m_Thread; + private static bool m_Reset; + + public static void Start() + { + if (m_Thread == null) + { + m_Thread = new Thread(() => + { + var lastPosition = 0L; + var firstLine = string.Empty; + while (m_Thread != null) + { + if (m_Reset) + { + m_Reset = false; + firstLine = string.Empty; + lastPosition = 0; + } + var info = new DirectoryInfo(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + @"Low\VRChat\VRChat"); + if (info != null && + info.Exists) + { + var files = info.GetFiles("output_log_*.txt", SearchOption.TopDirectoryOnly); + if (files != null && + files.Length >= 1) + { + Array.Sort(files, (A, B) => B.LastWriteTime.CompareTo(A.LastWriteTime)); + if (firstLine == string.Empty) + { + for (var i = files.Length - 1; i >= 1; --i) + { + using (var stream = files[i].Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) + using (var reader = new StreamReader(stream, Encoding.UTF8)) + { + var line = string.Empty; + while ((line = reader.ReadLine()) != null) + { + if (line.Length > 32 && + line[31] == '-') + { + ParseLine(line); + } + } + } + } + } + using (var stream = files[0].Open(FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) + using (var reader = new StreamReader(stream, Encoding.UTF8)) + { + var line = reader.ReadLine(); + if (line != null) + { + if (string.Equals(firstLine, line)) + { + stream.Position = lastPosition; + } + else + { + firstLine = line; + } + do + { + lastPosition = stream.Position; + ParseLine(line); + } + while ((line = reader.ReadLine()) != null); + } + } + } + } + try + { + Thread.Sleep(3000); + } + catch + { + // ThreadInterruptedException + } + } + }); + m_Thread.Start(); + } + } + + public static void Stop() + { + var thread = m_Thread; + if (thread != null) + { + m_Thread = null; + try + { + thread.Interrupt(); + thread.Join(); + } + catch + { + } + } + } + + private static string ConvertLogTimeToISO8601(string s) + { + // 2019.07.31 22:26:24 + var dt = new DateTime( + int.Parse(s.Substring(0, 4)), + int.Parse(s.Substring(5, 2)), + int.Parse(s.Substring(8, 2)), + int.Parse(s.Substring(11, 2)), + int.Parse(s.Substring(14, 2)), + int.Parse(s.Substring(17, 2)), + DateTimeKind.Local + ).ToUniversalTime(); + return $"{dt:yyyy'-'MM'-'dd'T'HH':'mm':'ss'Z'}"; + } + + private static void ParseLine(string line) + { + try + { + // 2019.07.31 22:26:24 Log - [RoomManager] Joining wrld_4432ea9b-729c-46e3-8eaf-846aa0a37fdd:6974~private(usr_4f76a584-9d4b-46f6-8209-8305eb683661)~nonce(0000000000000000000000000000000000000000000000000000000000000000) + // 2019.07.31 22:26:24 Log - [RoomManager] Joining or Creating Room: VRChat Home + if (string.Compare(line, 34, "[RoomManager] Joining ", 0, "[RoomManager] Joining ".Length) == 0 && + string.Compare(line, 56, "or ", 0, "or ".Length) != 0) + { + lock (m_GameLog) + { + m_GameLog.Add(new[] + { + ConvertLogTimeToISO8601(line), + "Location", + line.Substring(56) + }); + } + } + // 2019.07.31 22:41:18 Log - [NetworkManager] OnPlayerJoined pypy + else if (string.Compare(line, 34, "[NetworkManager] OnPlayerJoined ", 0, "[NetworkManager] OnPlayerJoined ".Length) == 0) + { + lock (m_GameLog) + { + m_GameLog.Add(new[] + { + ConvertLogTimeToISO8601(line), + "OnPlayerJoined", + line.Substring(66) + }); + } + } + // 2019.07.31 22:29:31 Log - [NetworkManager] OnPlayerLeft pypy + else if (string.Compare(line, 34, "[NetworkManager] OnPlayerLeft ", 0, "[NetworkManager] OnPlayerLeft ".Length) == 0) + { + lock (m_GameLog) + { + m_GameLog.Add(new[] + { + ConvertLogTimeToISO8601(line), + "OnPlayerLeft", + line.Substring(64) + }); + } + } + } + catch + { + } + } + + public void Reset() + { + lock (m_GameLog) + { + m_Reset = true; + m_GameLog.Clear(); + } + m_Thread.Interrupt(); + } + + public string[][] GetLogs() + { + lock (m_GameLog) + { + var array = m_GameLog.ToArray(); + m_GameLog.Clear(); + return array; + } + } + + public bool HasLog() + { + lock (m_GameLog) + { + return m_GameLog.Count > 0; + } + } + } +} \ No newline at end of file diff --git a/MainForm.Designer.cs b/MainForm.Designer.cs new file mode 100644 index 00000000..54ad0648 --- /dev/null +++ b/MainForm.Designer.cs @@ -0,0 +1,62 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +namespace VRCX +{ + partial class MainForm + { + /// + /// 필수 디자이너 변수입니다. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// 사용 중인 모든 리소스를 정리합니다. + /// + /// 관리되는 리소스를 삭제해야 하면 true이고, 그렇지 않으면 false입니다. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form 디자이너에서 생성한 코드 + + /// + /// 디자이너 지원에 필요한 메서드입니다. + /// 이 메서드의 내용을 코드 편집기로 수정하지 마세요. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + this.timer = new System.Windows.Forms.Timer(this.components); + this.SuspendLayout(); + // + // timer + // + this.timer.Enabled = true; + this.timer.Interval = 1000; + this.timer.Tick += new System.EventHandler(this.timer_Tick); + // + // MainForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 12F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(884, 561); + this.Name = "MainForm"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "VRCX"; + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Timer timer; + } +} \ No newline at end of file diff --git a/MainForm.cs b/MainForm.cs new file mode 100644 index 00000000..cc1bf708 --- /dev/null +++ b/MainForm.cs @@ -0,0 +1,60 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using System.Drawing; +using System.Reflection; +using System.Windows.Forms; +using CefSharp; +using CefSharp.WinForms; + +namespace VRCX +{ + public partial class MainForm : Form + { + public static MainForm Instance { get; private set; } + public static ChromiumWebBrowser Browser { get; private set; } + + public MainForm() + { + Instance = this; + InitializeComponent(); + try + { + Icon = Icon.ExtractAssociatedIcon(Assembly.GetExecutingAssembly().Location); + } + catch + { + } + // Application.StartupPath + "/html/index.html" + Browser = new ChromiumWebBrowser(Application.StartupPath + "/html/index.html") + { + BrowserSettings = + { + // UniversalAccessFromFileUrls = CefState.Enabled, + DefaultEncoding = "UTF-8", + }, + Dock = DockStyle.Fill, + }; + var options = new BindingOptions() + { + CamelCaseJavascriptNames = false + }; + Browser.JavascriptObjectRepository.Register("VRCX", new VRCX(), true, options); + Browser.JavascriptObjectRepository.Register("VRCXStorage", new VRCXStorage(), false, options); + Browser.JavascriptObjectRepository.Register("LogWatcher", new VRCX_LogWatcher(), true, options); + Browser.JavascriptObjectRepository.Register("Discord", new Discord(), true, options); + Browser.IsBrowserInitializedChanged += (A, B) => + { + // Browser.ShowDevTools(); + }; + Controls.Add(Browser); + } + + private void timer_Tick(object sender, System.EventArgs e) + { + Discord.Update(); + } + } +} \ No newline at end of file diff --git a/MainForm.resx b/MainForm.resx new file mode 100644 index 00000000..e22c5ac6 --- /dev/null +++ b/MainForm.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + \ No newline at end of file diff --git a/OpenVR/openvr_api.cs b/OpenVR/openvr_api.cs new file mode 100644 index 00000000..f96ad80b --- /dev/null +++ b/OpenVR/openvr_api.cs @@ -0,0 +1,7141 @@ +//======= Copyright (c) Valve Corporation, All rights reserved. =============== +// +// Purpose: This file contains C#/managed code bindings for the OpenVR interfaces +// This file is auto-generated, do not edit it. +// +//============================================================================= + +using System; +using System.Runtime.InteropServices; +using Valve.VR; + +namespace Valve.VR +{ + +[StructLayout(LayoutKind.Sequential)] +public struct IVRSystem +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetRecommendedRenderTargetSize(ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRecommendedRenderTargetSize GetRecommendedRenderTargetSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix44_t _GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetProjectionMatrix GetProjectionMatrix; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetProjectionRaw(EVREye eEye, ref float pfLeft, ref float pfRight, ref float pfTop, ref float pfBottom); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetProjectionRaw GetProjectionRaw; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ComputeDistortion(EVREye eEye, float fU, float fV, ref DistortionCoordinates_t pDistortionCoordinates); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ComputeDistortion ComputeDistortion; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetEyeToHeadTransform(EVREye eEye); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEyeToHeadTransform GetEyeToHeadTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync, ref ulong pulFrameCounter); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTimeSinceLastVsync GetTimeSinceLastVsync; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetD3D9AdapterIndex(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetD3D9AdapterIndex GetD3D9AdapterIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDXGIOutputInfo GetDXGIOutputInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetOutputDevice(ref ulong pnDevice, ETextureType textureType, IntPtr pInstance); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOutputDevice GetOutputDevice; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsDisplayOnDesktop(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsDisplayOnDesktop IsDisplayOnDesktop; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _SetDisplayVisibility(bool bIsVisibleOnDesktop); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDisplayVisibility SetDisplayVisibility; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, [In, Out] TrackedDevicePose_t[] pTrackedDevicePoseArray, uint unTrackedDevicePoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDeviceToAbsoluteTrackingPose GetDeviceToAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ResetSeatedZeroPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ResetSeatedZeroPose ResetSeatedZeroPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSeatedZeroPoseToStandingAbsoluteTrackingPose GetSeatedZeroPoseToStandingAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetRawZeroPoseToStandingAbsoluteTrackingPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRawZeroPoseToStandingAbsoluteTrackingPose GetRawZeroPoseToStandingAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, [In, Out] uint[] punTrackedDeviceIndexArray, uint unTrackedDeviceIndexArrayCount, uint unRelativeToTrackedDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSortedTrackedDeviceIndicesOfClass GetSortedTrackedDeviceIndicesOfClass; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EDeviceActivityLevel _GetTrackedDeviceActivityLevel(uint unDeviceId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceActivityLevel GetTrackedDeviceActivityLevel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ApplyTransform(ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pTrackedDevicePose, ref HmdMatrix34_t pTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ApplyTransform ApplyTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceIndexForControllerRole GetTrackedDeviceIndexForControllerRole; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedControllerRole _GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerRoleForTrackedDeviceIndex GetControllerRoleForTrackedDeviceIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedDeviceClass _GetTrackedDeviceClass(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceClass GetTrackedDeviceClass; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsTrackedDeviceConnected(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsTrackedDeviceConnected IsTrackedDeviceConnected; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetBoolTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoolTrackedDeviceProperty GetBoolTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFloatTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFloatTrackedDeviceProperty GetFloatTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetInt32TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInt32TrackedDeviceProperty GetInt32TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetUint64TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetUint64TrackedDeviceProperty GetUint64TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetMatrix34TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMatrix34TrackedDeviceProperty GetMatrix34TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetArrayTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, uint propType, IntPtr pBuffer, uint unBufferSize, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetArrayTrackedDeviceProperty GetArrayTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetStringTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, System.Text.StringBuilder pchValue, uint unBufferSize, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetStringTrackedDeviceProperty GetStringTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetPropErrorNameFromEnum(ETrackedPropertyError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPropErrorNameFromEnum GetPropErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEvent(ref VREvent_t pEvent, uint uncbVREvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextEvent PollNextEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, ref VREvent_t pEvent, uint uncbVREvent, ref TrackedDevicePose_t pTrackedDevicePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextEventWithPose PollNextEventWithPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetEventTypeNameFromEnum(EVREventType eType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEventTypeNameFromEnum GetEventTypeNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HiddenAreaMesh_t _GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHiddenAreaMesh GetHiddenAreaMesh; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerState(uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerState GetControllerState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerStateWithPose GetControllerStateWithPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _TriggerHapticPulse(uint unControllerDeviceIndex, uint unAxisId, ushort usDurationMicroSec); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TriggerHapticPulse TriggerHapticPulse; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetButtonIdNameFromEnum(EVRButtonId eButtonId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetButtonIdNameFromEnum GetButtonIdNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerAxisTypeNameFromEnum GetControllerAxisTypeNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsInputAvailable(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsInputAvailable IsInputAvailable; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsSteamVRDrawingControllers(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsSteamVRDrawingControllers IsSteamVRDrawingControllers; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldApplicationPause(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldApplicationPause ShouldApplicationPause; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldApplicationReduceRenderingWork(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldApplicationReduceRenderingWork ShouldApplicationReduceRenderingWork; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRFirmwareError _PerformFirmwareUpdate(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PerformFirmwareUpdate PerformFirmwareUpdate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _AcknowledgeQuit_Exiting(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcknowledgeQuit_Exiting AcknowledgeQuit_Exiting; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _AcknowledgeQuit_UserPrompt(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcknowledgeQuit_UserPrompt AcknowledgeQuit_UserPrompt; + + [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; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRApplications +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _AddApplicationManifest(string pchApplicationManifestFullPath, bool bTemporary); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AddApplicationManifest AddApplicationManifest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _RemoveApplicationManifest(string pchApplicationManifestFullPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveApplicationManifest RemoveApplicationManifest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsApplicationInstalled(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsApplicationInstalled IsApplicationInstalled; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationCount GetApplicationCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetApplicationKeyByIndex(uint unApplicationIndex, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationKeyByIndex GetApplicationKeyByIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetApplicationKeyByProcessId(uint unProcessId, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationKeyByProcessId GetApplicationKeyByProcessId; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchApplication(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchApplication LaunchApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchTemplateApplication(string pchTemplateAppKey, string pchNewAppKey, [In, Out] AppOverrideKeys_t[] pKeys, uint unKeys); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchTemplateApplication LaunchTemplateApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchApplicationFromMimeType(string pchMimeType, string pchArgs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchApplicationFromMimeType LaunchApplicationFromMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchDashboardOverlay(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchDashboardOverlay LaunchDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CancelApplicationLaunch(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CancelApplicationLaunch CancelApplicationLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _IdentifyApplication(uint unProcessId, string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IdentifyApplication IdentifyApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationProcessId(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationProcessId GetApplicationProcessId; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetApplicationsErrorNameFromEnum(EVRApplicationError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsErrorNameFromEnum GetApplicationsErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationPropertyString(string pchAppKey, EVRApplicationProperty eProperty, System.Text.StringBuilder pchPropertyValueBuffer, uint unPropertyValueBufferLen, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyString GetApplicationPropertyString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationPropertyBool(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyBool GetApplicationPropertyBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetApplicationPropertyUint64(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyUint64 GetApplicationPropertyUint64; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _SetApplicationAutoLaunch(string pchAppKey, bool bAutoLaunch); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetApplicationAutoLaunch SetApplicationAutoLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationAutoLaunch(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationAutoLaunch GetApplicationAutoLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _SetDefaultApplicationForMimeType(string pchAppKey, string pchMimeType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDefaultApplicationForMimeType SetDefaultApplicationForMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetDefaultApplicationForMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDefaultApplicationForMimeType GetDefaultApplicationForMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationSupportedMimeTypes(string pchAppKey, System.Text.StringBuilder pchMimeTypesBuffer, uint unMimeTypesBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationSupportedMimeTypes GetApplicationSupportedMimeTypes; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationsThatSupportMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsThatSupportMimeType GetApplicationsThatSupportMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationLaunchArguments(uint unHandle, System.Text.StringBuilder pchArgs, uint unArgs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationLaunchArguments GetApplicationLaunchArguments; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetStartingApplication GetStartingApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationTransitionState _GetTransitionState(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTransitionState GetTransitionState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _PerformApplicationPrelaunchCheck(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PerformApplicationPrelaunchCheck PerformApplicationPrelaunchCheck; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsTransitionStateNameFromEnum GetApplicationsTransitionStateNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsQuitUserPromptRequested(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsQuitUserPromptRequested IsQuitUserPromptRequested; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchInternalProcess(string pchBinaryPath, string pchArguments, string pchWorkingDirectory); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchInternalProcess LaunchInternalProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetCurrentSceneProcessId(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentSceneProcessId GetCurrentSceneProcessId; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRChaperone +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ChaperoneCalibrationState _GetCalibrationState(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCalibrationState GetCalibrationState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetPlayAreaSize(ref float pSizeX, ref float pSizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPlayAreaSize GetPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetPlayAreaRect(ref HmdQuad_t rect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPlayAreaRect GetPlayAreaRect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReloadInfo(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReloadInfo ReloadInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetSceneColor(HmdColor_t color); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetSceneColor SetSceneColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetBoundsColor(ref HmdColor_t pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, ref HmdColor_t pOutputCameraColor); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoundsColor GetBoundsColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _AreBoundsVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AreBoundsVisible AreBoundsVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceBoundsVisible(bool bForce); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceBoundsVisible ForceBoundsVisible; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRChaperoneSetup +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CommitWorkingCopy(EChaperoneConfigFile configFile); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CommitWorkingCopy CommitWorkingCopy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RevertWorkingCopy(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RevertWorkingCopy RevertWorkingCopy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingPlayAreaSize(ref float pSizeX, ref float pSizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingPlayAreaSize GetWorkingPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingPlayAreaRect(ref HmdQuad_t rect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingPlayAreaRect GetWorkingPlayAreaRect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingCollisionBoundsInfo GetWorkingCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetLiveCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLiveCollisionBoundsInfo GetLiveCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingSeatedZeroPoseToRawTrackingPose GetWorkingSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingStandingZeroPoseToRawTrackingPose GetWorkingStandingZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingPlayAreaSize(float sizeX, float sizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingPlayAreaSize SetWorkingPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, uint unQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingCollisionBoundsInfo SetWorkingCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingPerimeter([In, Out] HmdVector2_t[] pPointBuffer, uint unPointCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingPerimeter SetWorkingPerimeter; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingSeatedZeroPoseToRawTrackingPose SetWorkingSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingStandingZeroPoseToRawTrackingPose SetWorkingStandingZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReloadFromDisk(EChaperoneConfigFile configFile); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReloadFromDisk ReloadFromDisk; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLiveSeatedZeroPoseToRawTrackingPose GetLiveSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ExportLiveToBuffer(System.Text.StringBuilder pBuffer, ref uint pnBufferLength); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ExportLiveToBuffer ExportLiveToBuffer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ImportFromBufferToWorking(string pBuffer, uint nImportFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ImportFromBufferToWorking ImportFromBufferToWorking; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowWorkingSetPreview(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowWorkingSetPreview ShowWorkingSetPreview; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideWorkingSetPreview(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideWorkingSetPreview HideWorkingSetPreview; + + [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 bFadeIn); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FadeGrid FadeGrid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetCurrentGridAlpha(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentGridAlpha GetCurrentGridAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SetSkyboxOverride([In, Out] Texture_t[] pTextures, uint unTextureCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetSkyboxOverride SetSkyboxOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ClearSkyboxOverride(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearSkyboxOverride ClearSkyboxOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorBringToFront(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorBringToFront CompositorBringToFront; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorGoToBack(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorGoToBack CompositorGoToBack; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorQuit(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorQuit CompositorQuit; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsFullscreen(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsFullscreen IsFullscreen; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetCurrentSceneFocusProcess(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentSceneFocusProcess GetCurrentSceneFocusProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetLastFrameRenderer(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastFrameRenderer GetLastFrameRenderer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CanRenderScene(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CanRenderScene CanRenderScene; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowMirrorWindow(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMirrorWindow ShowMirrorWindow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideMirrorWindow(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideMirrorWindow HideMirrorWindow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMirrorWindowVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMirrorWindowVisible IsMirrorWindowVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorDumpImages(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorDumpImages CompositorDumpImages; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldAppRenderWithLowResources(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldAppRenderWithLowResources ShouldAppRenderWithLowResources; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceInterleavedReprojectionOn(bool bOverride); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceInterleavedReprojectionOn ForceInterleavedReprojectionOn; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceReconnectProcess(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceReconnectProcess ForceReconnectProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SuspendRendering(bool bSuspend); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SuspendRendering SuspendRendering; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetMirrorTextureD3D11(EVREye eEye, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMirrorTextureD3D11 GetMirrorTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseMirrorTextureD3D11 ReleaseMirrorTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetMirrorTextureGL(EVREye eEye, ref uint pglTextureId, IntPtr pglSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMirrorTextureGL GetMirrorTextureGL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ReleaseSharedGLTexture(uint glTextureId, IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseSharedGLTexture ReleaseSharedGLTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LockGLSharedTextureForAccess LockGLSharedTextureForAccess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UnlockGLSharedTextureForAccess UnlockGLSharedTextureForAccess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanInstanceExtensionsRequired GetVulkanInstanceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanDeviceExtensionsRequired GetVulkanDeviceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetExplicitTimingMode SetExplicitTimingMode; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SubmitExplicitTimingData(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SubmitExplicitTimingData SubmitExplicitTimingData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMotionSmoothingEnabled(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMotionSmoothingEnabled IsMotionSmoothingEnabled; + + [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; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVROverlay +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _FindOverlay(string pchOverlayKey, ref ulong pOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FindOverlay FindOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _CreateOverlay(string pchOverlayKey, string pchOverlayName, ref ulong pOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateOverlay CreateOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _DestroyOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DestroyOverlay DestroyOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetHighQualityOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetHighQualityOverlay SetHighQualityOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetHighQualityOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHighQualityOverlay GetHighQualityOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayKey(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayKey GetOverlayKey; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayName(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayName GetOverlayName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayName(ulong ulOverlayHandle, string pchName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayName SetOverlayName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayImageData(ulong ulOverlayHandle, IntPtr pvBuffer, uint unBufferSize, ref uint punWidth, ref uint punHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayImageData GetOverlayImageData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetOverlayErrorNameFromEnum(EVROverlayError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayErrorNameFromEnum GetOverlayErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRenderingPid(ulong ulOverlayHandle, uint unPID); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRenderingPid SetOverlayRenderingPid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayRenderingPid(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayRenderingPid GetOverlayRenderingPid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayFlag SetOverlayFlag; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, ref bool pbEnabled); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlag GetOverlayFlag; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayColor(ulong ulOverlayHandle, float fRed, float fGreen, float fBlue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayColor SetOverlayColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayColor(ulong ulOverlayHandle, ref float pfRed, ref float pfGreen, ref float pfBlue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayColor GetOverlayColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayAlpha(ulong ulOverlayHandle, float fAlpha); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayAlpha SetOverlayAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayAlpha(ulong ulOverlayHandle, ref float pfAlpha); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayAlpha GetOverlayAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTexelAspect(ulong ulOverlayHandle, float fTexelAspect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTexelAspect SetOverlayTexelAspect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTexelAspect(ulong ulOverlayHandle, ref float pfTexelAspect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTexelAspect GetOverlayTexelAspect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlaySortOrder(ulong ulOverlayHandle, uint unSortOrder); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlaySortOrder SetOverlaySortOrder; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlaySortOrder(ulong ulOverlayHandle, ref uint punSortOrder); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlaySortOrder GetOverlaySortOrder; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayWidthInMeters(ulong ulOverlayHandle, float fWidthInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayWidthInMeters SetOverlayWidthInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayWidthInMeters(ulong ulOverlayHandle, ref float pfWidthInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayWidthInMeters GetOverlayWidthInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayAutoCurveDistanceRangeInMeters SetOverlayAutoCurveDistanceRangeInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, ref float pfMinDistanceInMeters, ref float pfMaxDistanceInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayAutoCurveDistanceRangeInMeters GetOverlayAutoCurveDistanceRangeInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTextureColorSpace(ulong ulOverlayHandle, EColorSpace eTextureColorSpace); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTextureColorSpace SetOverlayTextureColorSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureColorSpace(ulong ulOverlayHandle, ref EColorSpace peTextureColorSpace); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureColorSpace GetOverlayTextureColorSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTextureBounds SetOverlayTextureBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureBounds GetOverlayTextureBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayRenderModel(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref HmdColor_t pColor, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayRenderModel GetOverlayRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRenderModel(ulong ulOverlayHandle, string pchRenderModel, ref HmdColor_t pColor); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRenderModel SetOverlayRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformType(ulong ulOverlayHandle, ref VROverlayTransformType peTransformType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformType GetOverlayTransformType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformAbsolute(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformAbsolute SetOverlayTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformAbsolute GetOverlayTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, uint unTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformTrackedDeviceRelative SetOverlayTransformTrackedDeviceRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, ref uint punTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformTrackedDeviceRelative GetOverlayTransformTrackedDeviceRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, string pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformTrackedDeviceComponent SetOverlayTransformTrackedDeviceComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, ref uint punDeviceIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformTrackedDeviceComponent GetOverlayTransformTrackedDeviceComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ref ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformOverlayRelative GetOverlayTransformOverlayRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformOverlayRelative SetOverlayTransformOverlayRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowOverlay ShowOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _HideOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideOverlay HideOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsOverlayVisible(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsOverlayVisible IsOverlayVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTransformForOverlayCoordinates GetTransformForOverlayCoordinates; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pEvent, uint uncbVREvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextOverlayEvent PollNextOverlayEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayInputMethod(ulong ulOverlayHandle, ref VROverlayInputMethod peInputMethod); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayInputMethod GetOverlayInputMethod; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayInputMethod(ulong ulOverlayHandle, VROverlayInputMethod eInputMethod); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayInputMethod SetOverlayInputMethod; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayMouseScale GetOverlayMouseScale; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayMouseScale SetOverlayMouseScale; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ComputeOverlayIntersection(ulong ulOverlayHandle, ref VROverlayIntersectionParams_t pParams, ref VROverlayIntersectionResults_t pResults); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ComputeOverlayIntersection ComputeOverlayIntersection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsHoverTargetOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsHoverTargetOverlay IsHoverTargetOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetGamepadFocusOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetGamepadFocusOverlay GetGamepadFocusOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetGamepadFocusOverlay(ulong ulNewFocusOverlay); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetGamepadFocusOverlay SetGamepadFocusOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayNeighbor(EOverlayDirection eDirection, ulong ulFrom, ulong ulTo); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayNeighbor SetOverlayNeighbor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _MoveGamepadFocusToNeighbor(EOverlayDirection eDirection, ulong ulFrom); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _MoveGamepadFocusToNeighbor MoveGamepadFocusToNeighbor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayDualAnalogTransform(ulong ulOverlay, EDualAnalogWhich eWhich, ref HmdVector2_t pvCenter, float fRadius); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayDualAnalogTransform SetOverlayDualAnalogTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayDualAnalogTransform(ulong ulOverlay, EDualAnalogWhich eWhich, ref HmdVector2_t pvCenter, ref float pfRadius); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayDualAnalogTransform GetOverlayDualAnalogTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTexture(ulong ulOverlayHandle, ref Texture_t pTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTexture SetOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ClearOverlayTexture(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearOverlayTexture ClearOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRaw(ulong ulOverlayHandle, IntPtr pvBuffer, uint unWidth, uint unHeight, uint unDepth); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRaw SetOverlayRaw; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayFromFile(ulong ulOverlayHandle, string pchFilePath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayFromFile SetOverlayFromFile; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref ETextureType pAPIType, ref EColorSpace pColorSpace, ref VRTextureBounds_t pTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTexture GetOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ReleaseNativeOverlayHandle(ulong ulOverlayHandle, IntPtr pNativeTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseNativeOverlayHandle ReleaseNativeOverlayHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureSize(ulong ulOverlayHandle, ref uint pWidth, ref uint pHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureSize GetOverlayTextureSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _CreateDashboardOverlay(string pchOverlayKey, string pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateDashboardOverlay CreateDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsDashboardVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsDashboardVisible IsDashboardVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsActiveDashboardOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsActiveDashboardOverlay IsActiveDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetDashboardOverlaySceneProcess(ulong ulOverlayHandle, uint unProcessId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDashboardOverlaySceneProcess SetDashboardOverlaySceneProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetDashboardOverlaySceneProcess(ulong ulOverlayHandle, ref uint punProcessId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDashboardOverlaySceneProcess GetDashboardOverlaySceneProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowDashboard(string pchOverlayToShow); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowDashboard ShowDashboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetPrimaryDashboardDevice(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPrimaryDashboardDevice GetPrimaryDashboardDevice; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowKeyboard(int eInputMode, int eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText, bool bUseMinimalMode, ulong uUserValue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowKeyboard ShowKeyboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowKeyboardForOverlay(ulong ulOverlayHandle, int eInputMode, int eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText, bool bUseMinimalMode, ulong uUserValue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowKeyboardForOverlay ShowKeyboardForOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetKeyboardText(System.Text.StringBuilder pchText, uint cchText); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetKeyboardText GetKeyboardText; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideKeyboard(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideKeyboard HideKeyboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetKeyboardTransformAbsolute SetKeyboardTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetKeyboardPositionForOverlay(ulong ulOverlayHandle, HmdRect2_t avoidRect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetKeyboardPositionForOverlay SetKeyboardPositionForOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayIntersectionMask(ulong ulOverlayHandle, ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives, uint unNumMaskPrimitives, uint unPrimitiveSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayIntersectionMask SetOverlayIntersectionMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlags(ulong ulOverlayHandle, ref uint pFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlags GetOverlayFlags; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate VRMessageOverlayResponse _ShowMessageOverlay(string pchText, string pchCaption, string pchButton0Text, string pchButton1Text, string pchButton2Text, string pchButton3Text); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMessageOverlay ShowMessageOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CloseMessageOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CloseMessageOverlay CloseMessageOverlay; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRRenderModels +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadRenderModel_Async(string pchRenderModelName, ref IntPtr ppRenderModel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadRenderModel_Async LoadRenderModel_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeRenderModel(IntPtr pRenderModel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeRenderModel FreeRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadTexture_Async(int textureId, ref IntPtr ppTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadTexture_Async LoadTexture_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeTexture(IntPtr pTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeTexture FreeTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadTextureD3D11_Async LoadTextureD3D11_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadIntoTextureD3D11_Async LoadIntoTextureD3D11_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeTextureD3D11(IntPtr pD3D11Texture2D); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeTextureD3D11 FreeTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelName GetRenderModelName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelCount GetRenderModelCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentCount(string pchRenderModelName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentCount GetComponentCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentName(string pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentName GetComponentName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetComponentButtonMask(string pchRenderModelName, string pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentButtonMask GetComponentButtonMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentRenderModelName(string pchRenderModelName, string pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentRenderModelName GetComponentRenderModelName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentStateForDevicePath(string pchRenderModelName, string pchComponentName, ulong devicePath, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentStateForDevicePath GetComponentStateForDevicePath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentState(string pchRenderModelName, string pchComponentName, ref VRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentState GetComponentState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _RenderModelHasComponent(string pchRenderModelName, string pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RenderModelHasComponent RenderModelHasComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelThumbnailURL(string pchRenderModelName, System.Text.StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelThumbnailURL GetRenderModelThumbnailURL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelOriginalPath(string pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelOriginalPath GetRenderModelOriginalPath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetRenderModelErrorNameFromEnum(EVRRenderModelError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelErrorNameFromEnum GetRenderModelErrorNameFromEnum; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRNotifications +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRNotificationError _CreateNotification(ulong ulOverlayHandle, ulong ulUserValue, EVRNotificationType type, string pchText, EVRNotificationStyle style, ref NotificationBitmap_t pImage, ref uint pNotificationId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateNotification CreateNotification; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRNotificationError _RemoveNotification(uint notificationId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveNotification RemoveNotification; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRSettings +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetSettingsErrorNameFromEnum(EVRSettingsError eError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSettingsErrorNameFromEnum GetSettingsErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _Sync(bool bForce, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Sync Sync; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetBool(string pchSection, string pchSettingsKey, bool bValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetBool SetBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetInt32(string pchSection, string pchSettingsKey, int nValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetInt32 SetInt32; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetFloat(string pchSection, string pchSettingsKey, float flValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetFloat SetFloat; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetString(string pchSection, string pchSettingsKey, string pchValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetString SetString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetBool(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBool GetBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetInt32(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInt32 GetInt32; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFloat(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFloat GetFloat; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetString(string pchSection, string pchSettingsKey, System.Text.StringBuilder pchValue, uint unValueLen, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetString GetString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RemoveSection(string pchSection, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveSection RemoveSection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RemoveKeyInSection(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveKeyInSection RemoveKeyInSection; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRScreenshots +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, string pchPreviewFilename, string pchVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RequestScreenshot RequestScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _HookScreenshot([In, Out] EVRScreenshotType[] pSupportedTypes, int numTypes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HookScreenshot HookScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotType _GetScreenshotPropertyType(uint screenshotHandle, ref EVRScreenshotError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetScreenshotPropertyType GetScreenshotPropertyType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetScreenshotPropertyFilename(uint screenshotHandle, EVRScreenshotPropertyFilenames filenameType, System.Text.StringBuilder pchFilename, uint cchFilename, ref EVRScreenshotError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetScreenshotPropertyFilename GetScreenshotPropertyFilename; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _UpdateScreenshotProgress(uint screenshotHandle, float flProgress); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UpdateScreenshotProgress UpdateScreenshotProgress; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _TakeStereoScreenshot(ref uint pOutScreenshotHandle, string pchPreviewFilename, string pchVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TakeStereoScreenshot TakeStereoScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _SubmitScreenshot(uint screenshotHandle, EVRScreenshotType type, string pchSourcePreviewFilename, string pchSourceVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SubmitScreenshot SubmitScreenshot; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRResources +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _LoadSharedResource(string pchResourceName, string pchBuffer, uint unBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadSharedResource LoadSharedResource; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetResourceFullPath(string pchResourceName, string pchResourceTypeDirectory, System.Text.StringBuilder pchPathBuffer, uint unBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetResourceFullPath GetResourceFullPath; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRDriverManager +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetDriverCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverCount GetDriverCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetDriverName(uint nDriver, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverName GetDriverName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetDriverHandle(string pchDriverName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverHandle GetDriverHandle; + + [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(string pchActionManifestPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetActionManifestPath SetActionManifestPath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionSetHandle(string pchActionSetName, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionSetHandle GetActionSetHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionHandle(string pchActionName, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionHandle GetActionHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetInputSourceHandle(string pchInputSourcePath, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInputSourceHandle GetInputSourceHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _UpdateActionState([In, Out] VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, uint unSetCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UpdateActionState UpdateActionState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetDigitalActionData(ulong action, ref InputDigitalActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDigitalActionData GetDigitalActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetAnalogActionData(ulong action, ref InputAnalogActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetAnalogActionData GetAnalogActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _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 _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 bool _IsUsingLegacyInput(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsUsingLegacyInput IsUsingLegacyInput; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRIOBuffer +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Open(string pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Open Open; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Close(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Close Close; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Read(ulong ulBuffer, IntPtr pDst, uint unBytes, ref uint punRead); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Read Read; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Write(ulong ulBuffer, IntPtr pSrc, uint unBytes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Write Write; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _PropertyContainer(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PropertyContainer PropertyContainer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _HasReaders(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HasReaders HasReaders; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRSpatialAnchors +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromDescriptor(string pchDescriptor, ref uint pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateSpatialAnchorFromDescriptor CreateSpatialAnchorFromDescriptor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromPose(uint unDeviceIndex, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPose, ref uint pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateSpatialAnchorFromPose CreateSpatialAnchorFromPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _GetSpatialAnchorPose(uint unHandle, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPoseOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSpatialAnchorPose GetSpatialAnchorPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _GetSpatialAnchorDescriptor(uint unHandle, System.Text.StringBuilder pchDescriptorOut, ref uint punDescriptorBufferLenInOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSpatialAnchorDescriptor GetSpatialAnchorDescriptor; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRDebug +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRDebugError _EmitVrProfilerEvent(string 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, string pchMessage); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FinishVrProfilerEvent FinishVrProfilerEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _DriverDebugRequest(uint unDeviceIndex, string pchRequest, System.Text.StringBuilder pchResponseBuffer, uint unResponseBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DriverDebugRequest DriverDebugRequest; + +} + + +public class CVRSystem +{ + IVRSystem FnTable; + internal CVRSystem(IntPtr pInterface) + { + FnTable = (IVRSystem)Marshal.PtrToStructure(pInterface, typeof(IVRSystem)); + } + public void GetRecommendedRenderTargetSize(ref uint pnWidth,ref uint pnHeight) + { + pnWidth = 0; + pnHeight = 0; + FnTable.GetRecommendedRenderTargetSize(ref pnWidth,ref pnHeight); + } + public HmdMatrix44_t GetProjectionMatrix(EVREye eEye,float fNearZ,float fFarZ) + { + HmdMatrix44_t result = FnTable.GetProjectionMatrix(eEye,fNearZ,fFarZ); + return result; + } + public void GetProjectionRaw(EVREye eEye,ref float pfLeft,ref float pfRight,ref float pfTop,ref float pfBottom) + { + pfLeft = 0; + pfRight = 0; + pfTop = 0; + pfBottom = 0; + FnTable.GetProjectionRaw(eEye,ref pfLeft,ref pfRight,ref pfTop,ref pfBottom); + } + public bool ComputeDistortion(EVREye eEye,float fU,float fV,ref DistortionCoordinates_t pDistortionCoordinates) + { + bool result = FnTable.ComputeDistortion(eEye,fU,fV,ref pDistortionCoordinates); + return result; + } + public HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) + { + HmdMatrix34_t result = FnTable.GetEyeToHeadTransform(eEye); + return result; + } + public bool GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync,ref ulong pulFrameCounter) + { + pfSecondsSinceLastVsync = 0; + pulFrameCounter = 0; + bool result = FnTable.GetTimeSinceLastVsync(ref pfSecondsSinceLastVsync,ref pulFrameCounter); + return result; + } + public int GetD3D9AdapterIndex() + { + int result = FnTable.GetD3D9AdapterIndex(); + return result; + } + public void GetDXGIOutputInfo(ref int pnAdapterIndex) + { + pnAdapterIndex = 0; + FnTable.GetDXGIOutputInfo(ref pnAdapterIndex); + } + public void GetOutputDevice(ref ulong pnDevice,ETextureType textureType,IntPtr pInstance) + { + pnDevice = 0; + FnTable.GetOutputDevice(ref pnDevice,textureType,pInstance); + } + public bool IsDisplayOnDesktop() + { + bool result = FnTable.IsDisplayOnDesktop(); + return result; + } + public bool SetDisplayVisibility(bool bIsVisibleOnDesktop) + { + bool result = FnTable.SetDisplayVisibility(bIsVisibleOnDesktop); + return result; + } + public void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin,float fPredictedSecondsToPhotonsFromNow,TrackedDevicePose_t [] pTrackedDevicePoseArray) + { + FnTable.GetDeviceToAbsoluteTrackingPose(eOrigin,fPredictedSecondsToPhotonsFromNow,pTrackedDevicePoseArray,(uint) pTrackedDevicePoseArray.Length); + } + public void ResetSeatedZeroPose() + { + FnTable.ResetSeatedZeroPose(); + } + public HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() + { + HmdMatrix34_t result = FnTable.GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + return result; + } + public HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() + { + HmdMatrix34_t result = FnTable.GetRawZeroPoseToStandingAbsoluteTrackingPose(); + return result; + } + public uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass,uint [] punTrackedDeviceIndexArray,uint unRelativeToTrackedDeviceIndex) + { + uint result = FnTable.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass,punTrackedDeviceIndexArray,(uint) punTrackedDeviceIndexArray.Length,unRelativeToTrackedDeviceIndex); + return result; + } + public EDeviceActivityLevel GetTrackedDeviceActivityLevel(uint unDeviceId) + { + EDeviceActivityLevel result = FnTable.GetTrackedDeviceActivityLevel(unDeviceId); + return result; + } + public void ApplyTransform(ref TrackedDevicePose_t pOutputPose,ref TrackedDevicePose_t pTrackedDevicePose,ref HmdMatrix34_t pTransform) + { + FnTable.ApplyTransform(ref pOutputPose,ref pTrackedDevicePose,ref pTransform); + } + public uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType) + { + uint result = FnTable.GetTrackedDeviceIndexForControllerRole(unDeviceType); + return result; + } + public ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex) + { + ETrackedControllerRole result = FnTable.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex); + return result; + } + public ETrackedDeviceClass GetTrackedDeviceClass(uint unDeviceIndex) + { + ETrackedDeviceClass result = FnTable.GetTrackedDeviceClass(unDeviceIndex); + return result; + } + public bool IsTrackedDeviceConnected(uint unDeviceIndex) + { + bool result = FnTable.IsTrackedDeviceConnected(unDeviceIndex); + return result; + } + public bool GetBoolTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + bool result = FnTable.GetBoolTrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public float GetFloatTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + float result = FnTable.GetFloatTrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public int GetInt32TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + int result = FnTable.GetInt32TrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public ulong GetUint64TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + ulong result = FnTable.GetUint64TrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public HmdMatrix34_t GetMatrix34TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + HmdMatrix34_t result = FnTable.GetMatrix34TrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public uint GetArrayTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,uint propType,IntPtr pBuffer,uint unBufferSize,ref ETrackedPropertyError pError) + { + uint result = FnTable.GetArrayTrackedDeviceProperty(unDeviceIndex,prop,propType,pBuffer,unBufferSize,ref pError); + return result; + } + public uint GetStringTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,System.Text.StringBuilder pchValue,uint unBufferSize,ref ETrackedPropertyError pError) + { + uint result = FnTable.GetStringTrackedDeviceProperty(unDeviceIndex,prop,pchValue,unBufferSize,ref pError); + return result; + } + public string GetPropErrorNameFromEnum(ETrackedPropertyError error) + { + IntPtr result = FnTable.GetPropErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEventPacked(ref VREvent_t_Packed pEvent,uint uncbVREvent); + [StructLayout(LayoutKind.Explicit)] + struct PollNextEventUnion + { + [FieldOffset(0)] + public IVRSystem._PollNextEvent pPollNextEvent; + [FieldOffset(0)] + public _PollNextEventPacked pPollNextEventPacked; + } + public bool PollNextEvent(ref VREvent_t pEvent,uint uncbVREvent) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + PollNextEventUnion u; + VREvent_t_Packed event_packed = new VREvent_t_Packed(); + u.pPollNextEventPacked = null; + u.pPollNextEvent = FnTable.PollNextEvent; + bool packed_result = u.pPollNextEventPacked(ref event_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed))); + + event_packed.Unpack(ref pEvent); + return packed_result; + } +#endif + bool result = FnTable.PollNextEvent(ref pEvent,uncbVREvent); + return result; + } + public bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,ref VREvent_t pEvent,uint uncbVREvent,ref TrackedDevicePose_t pTrackedDevicePose) + { + bool result = FnTable.PollNextEventWithPose(eOrigin,ref pEvent,uncbVREvent,ref pTrackedDevicePose); + return result; + } + public string GetEventTypeNameFromEnum(EVREventType eType) + { + IntPtr result = FnTable.GetEventTypeNameFromEnum(eType); + return Marshal.PtrToStringAnsi(result); + } + public HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye,EHiddenAreaMeshType type) + { + HiddenAreaMesh_t result = FnTable.GetHiddenAreaMesh(eEye,type); + return result; + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStatePacked(uint unControllerDeviceIndex,ref VRControllerState_t_Packed pControllerState,uint unControllerStateSize); + [StructLayout(LayoutKind.Explicit)] + struct GetControllerStateUnion + { + [FieldOffset(0)] + public IVRSystem._GetControllerState pGetControllerState; + [FieldOffset(0)] + public _GetControllerStatePacked pGetControllerStatePacked; + } + public bool GetControllerState(uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,uint unControllerStateSize) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetControllerStateUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetControllerStatePacked = null; + u.pGetControllerState = FnTable.GetControllerState; + bool packed_result = u.pGetControllerStatePacked(unControllerDeviceIndex,ref state_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed))); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetControllerState(unControllerDeviceIndex,ref pControllerState,unControllerStateSize); + return result; + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStateWithPosePacked(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t_Packed pControllerState,uint unControllerStateSize,ref TrackedDevicePose_t pTrackedDevicePose); + [StructLayout(LayoutKind.Explicit)] + struct GetControllerStateWithPoseUnion + { + [FieldOffset(0)] + public IVRSystem._GetControllerStateWithPose pGetControllerStateWithPose; + [FieldOffset(0)] + public _GetControllerStateWithPosePacked pGetControllerStateWithPosePacked; + } + public bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,uint unControllerStateSize,ref TrackedDevicePose_t pTrackedDevicePose) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetControllerStateWithPoseUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetControllerStateWithPosePacked = null; + u.pGetControllerStateWithPose = FnTable.GetControllerStateWithPose; + bool packed_result = u.pGetControllerStateWithPosePacked(eOrigin,unControllerDeviceIndex,ref state_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed)),ref pTrackedDevicePose); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetControllerStateWithPose(eOrigin,unControllerDeviceIndex,ref pControllerState,unControllerStateSize,ref pTrackedDevicePose); + return result; + } + public void TriggerHapticPulse(uint unControllerDeviceIndex,uint unAxisId,ushort usDurationMicroSec) + { + FnTable.TriggerHapticPulse(unControllerDeviceIndex,unAxisId,usDurationMicroSec); + } + public string GetButtonIdNameFromEnum(EVRButtonId eButtonId) + { + IntPtr result = FnTable.GetButtonIdNameFromEnum(eButtonId); + return Marshal.PtrToStringAnsi(result); + } + public string GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType) + { + IntPtr result = FnTable.GetControllerAxisTypeNameFromEnum(eAxisType); + return Marshal.PtrToStringAnsi(result); + } + public bool IsInputAvailable() + { + bool result = FnTable.IsInputAvailable(); + return result; + } + public bool IsSteamVRDrawingControllers() + { + bool result = FnTable.IsSteamVRDrawingControllers(); + return result; + } + public bool ShouldApplicationPause() + { + bool result = FnTable.ShouldApplicationPause(); + return result; + } + public bool ShouldApplicationReduceRenderingWork() + { + bool result = FnTable.ShouldApplicationReduceRenderingWork(); + return result; + } + public EVRFirmwareError PerformFirmwareUpdate(uint unDeviceIndex) + { + EVRFirmwareError result = FnTable.PerformFirmwareUpdate(unDeviceIndex); + return result; + } + public void AcknowledgeQuit_Exiting() + { + FnTable.AcknowledgeQuit_Exiting(); + } + public void AcknowledgeQuit_UserPrompt() + { + FnTable.AcknowledgeQuit_UserPrompt(); + } + public 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 class CVRApplications +{ + IVRApplications FnTable; + internal CVRApplications(IntPtr pInterface) + { + FnTable = (IVRApplications)Marshal.PtrToStructure(pInterface, typeof(IVRApplications)); + } + public EVRApplicationError AddApplicationManifest(string pchApplicationManifestFullPath,bool bTemporary) + { + EVRApplicationError result = FnTable.AddApplicationManifest(pchApplicationManifestFullPath,bTemporary); + return result; + } + public EVRApplicationError RemoveApplicationManifest(string pchApplicationManifestFullPath) + { + EVRApplicationError result = FnTable.RemoveApplicationManifest(pchApplicationManifestFullPath); + return result; + } + public bool IsApplicationInstalled(string pchAppKey) + { + bool result = FnTable.IsApplicationInstalled(pchAppKey); + return result; + } + public uint GetApplicationCount() + { + uint result = FnTable.GetApplicationCount(); + return result; + } + public EVRApplicationError GetApplicationKeyByIndex(uint unApplicationIndex,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetApplicationKeyByIndex(unApplicationIndex,pchAppKeyBuffer,unAppKeyBufferLen); + return result; + } + public EVRApplicationError GetApplicationKeyByProcessId(uint unProcessId,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetApplicationKeyByProcessId(unProcessId,pchAppKeyBuffer,unAppKeyBufferLen); + return result; + } + public EVRApplicationError LaunchApplication(string pchAppKey) + { + EVRApplicationError result = FnTable.LaunchApplication(pchAppKey); + return result; + } + public EVRApplicationError LaunchTemplateApplication(string pchTemplateAppKey,string pchNewAppKey,AppOverrideKeys_t [] pKeys) + { + EVRApplicationError result = FnTable.LaunchTemplateApplication(pchTemplateAppKey,pchNewAppKey,pKeys,(uint) pKeys.Length); + return result; + } + public EVRApplicationError LaunchApplicationFromMimeType(string pchMimeType,string pchArgs) + { + EVRApplicationError result = FnTable.LaunchApplicationFromMimeType(pchMimeType,pchArgs); + return result; + } + public EVRApplicationError LaunchDashboardOverlay(string pchAppKey) + { + EVRApplicationError result = FnTable.LaunchDashboardOverlay(pchAppKey); + return result; + } + public bool CancelApplicationLaunch(string pchAppKey) + { + bool result = FnTable.CancelApplicationLaunch(pchAppKey); + return result; + } + public EVRApplicationError IdentifyApplication(uint unProcessId,string pchAppKey) + { + EVRApplicationError result = FnTable.IdentifyApplication(unProcessId,pchAppKey); + return result; + } + public uint GetApplicationProcessId(string pchAppKey) + { + uint result = FnTable.GetApplicationProcessId(pchAppKey); + return result; + } + public string GetApplicationsErrorNameFromEnum(EVRApplicationError error) + { + IntPtr result = FnTable.GetApplicationsErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public uint GetApplicationPropertyString(string pchAppKey,EVRApplicationProperty eProperty,System.Text.StringBuilder pchPropertyValueBuffer,uint unPropertyValueBufferLen,ref EVRApplicationError peError) + { + uint result = FnTable.GetApplicationPropertyString(pchAppKey,eProperty,pchPropertyValueBuffer,unPropertyValueBufferLen,ref peError); + return result; + } + public bool GetApplicationPropertyBool(string pchAppKey,EVRApplicationProperty eProperty,ref EVRApplicationError peError) + { + bool result = FnTable.GetApplicationPropertyBool(pchAppKey,eProperty,ref peError); + return result; + } + public ulong GetApplicationPropertyUint64(string pchAppKey,EVRApplicationProperty eProperty,ref EVRApplicationError peError) + { + ulong result = FnTable.GetApplicationPropertyUint64(pchAppKey,eProperty,ref peError); + return result; + } + public EVRApplicationError SetApplicationAutoLaunch(string pchAppKey,bool bAutoLaunch) + { + EVRApplicationError result = FnTable.SetApplicationAutoLaunch(pchAppKey,bAutoLaunch); + return result; + } + public bool GetApplicationAutoLaunch(string pchAppKey) + { + bool result = FnTable.GetApplicationAutoLaunch(pchAppKey); + return result; + } + public EVRApplicationError SetDefaultApplicationForMimeType(string pchAppKey,string pchMimeType) + { + EVRApplicationError result = FnTable.SetDefaultApplicationForMimeType(pchAppKey,pchMimeType); + return result; + } + public bool GetDefaultApplicationForMimeType(string pchMimeType,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen) + { + bool result = FnTable.GetDefaultApplicationForMimeType(pchMimeType,pchAppKeyBuffer,unAppKeyBufferLen); + return result; + } + public bool GetApplicationSupportedMimeTypes(string pchAppKey,System.Text.StringBuilder pchMimeTypesBuffer,uint unMimeTypesBuffer) + { + bool result = FnTable.GetApplicationSupportedMimeTypes(pchAppKey,pchMimeTypesBuffer,unMimeTypesBuffer); + return result; + } + public uint GetApplicationsThatSupportMimeType(string pchMimeType,System.Text.StringBuilder pchAppKeysThatSupportBuffer,uint unAppKeysThatSupportBuffer) + { + uint result = FnTable.GetApplicationsThatSupportMimeType(pchMimeType,pchAppKeysThatSupportBuffer,unAppKeysThatSupportBuffer); + return result; + } + public uint GetApplicationLaunchArguments(uint unHandle,System.Text.StringBuilder pchArgs,uint unArgs) + { + uint result = FnTable.GetApplicationLaunchArguments(unHandle,pchArgs,unArgs); + return result; + } + public EVRApplicationError GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetStartingApplication(pchAppKeyBuffer,unAppKeyBufferLen); + return result; + } + public EVRApplicationTransitionState GetTransitionState() + { + EVRApplicationTransitionState result = FnTable.GetTransitionState(); + return result; + } + public EVRApplicationError PerformApplicationPrelaunchCheck(string pchAppKey) + { + EVRApplicationError result = FnTable.PerformApplicationPrelaunchCheck(pchAppKey); + return result; + } + public string GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state) + { + IntPtr result = FnTable.GetApplicationsTransitionStateNameFromEnum(state); + return Marshal.PtrToStringAnsi(result); + } + public bool IsQuitUserPromptRequested() + { + bool result = FnTable.IsQuitUserPromptRequested(); + return result; + } + public EVRApplicationError LaunchInternalProcess(string pchBinaryPath,string pchArguments,string pchWorkingDirectory) + { + EVRApplicationError result = FnTable.LaunchInternalProcess(pchBinaryPath,pchArguments,pchWorkingDirectory); + return result; + } + public uint GetCurrentSceneProcessId() + { + uint result = FnTable.GetCurrentSceneProcessId(); + return result; + } +} + + +public class CVRChaperone +{ + IVRChaperone FnTable; + internal CVRChaperone(IntPtr pInterface) + { + FnTable = (IVRChaperone)Marshal.PtrToStructure(pInterface, typeof(IVRChaperone)); + } + public ChaperoneCalibrationState GetCalibrationState() + { + ChaperoneCalibrationState result = FnTable.GetCalibrationState(); + return result; + } + public bool GetPlayAreaSize(ref float pSizeX,ref float pSizeZ) + { + pSizeX = 0; + pSizeZ = 0; + bool result = FnTable.GetPlayAreaSize(ref pSizeX,ref pSizeZ); + return result; + } + public bool GetPlayAreaRect(ref HmdQuad_t rect) + { + bool result = FnTable.GetPlayAreaRect(ref rect); + return result; + } + public void ReloadInfo() + { + FnTable.ReloadInfo(); + } + public void SetSceneColor(HmdColor_t color) + { + FnTable.SetSceneColor(color); + } + public void GetBoundsColor(ref HmdColor_t pOutputColorArray,int nNumOutputColors,float flCollisionBoundsFadeDistance,ref HmdColor_t pOutputCameraColor) + { + FnTable.GetBoundsColor(ref pOutputColorArray,nNumOutputColors,flCollisionBoundsFadeDistance,ref pOutputCameraColor); + } + public bool AreBoundsVisible() + { + bool result = FnTable.AreBoundsVisible(); + return result; + } + public void ForceBoundsVisible(bool bForce) + { + FnTable.ForceBoundsVisible(bForce); + } +} + + +public class CVRChaperoneSetup +{ + IVRChaperoneSetup FnTable; + internal CVRChaperoneSetup(IntPtr pInterface) + { + FnTable = (IVRChaperoneSetup)Marshal.PtrToStructure(pInterface, typeof(IVRChaperoneSetup)); + } + public bool CommitWorkingCopy(EChaperoneConfigFile configFile) + { + bool result = FnTable.CommitWorkingCopy(configFile); + return result; + } + public void RevertWorkingCopy() + { + FnTable.RevertWorkingCopy(); + } + public bool GetWorkingPlayAreaSize(ref float pSizeX,ref float pSizeZ) + { + pSizeX = 0; + pSizeZ = 0; + bool result = FnTable.GetWorkingPlayAreaSize(ref pSizeX,ref pSizeZ); + return result; + } + public bool GetWorkingPlayAreaRect(ref HmdQuad_t rect) + { + bool result = FnTable.GetWorkingPlayAreaRect(ref rect); + return result; + } + public bool GetWorkingCollisionBoundsInfo(out HmdQuad_t [] pQuadsBuffer) + { + uint punQuadsCount = 0; + bool result = FnTable.GetWorkingCollisionBoundsInfo(null,ref punQuadsCount); + pQuadsBuffer= new HmdQuad_t[punQuadsCount]; + result = FnTable.GetWorkingCollisionBoundsInfo(pQuadsBuffer,ref punQuadsCount); + return result; + } + public bool GetLiveCollisionBoundsInfo(out HmdQuad_t [] pQuadsBuffer) + { + uint punQuadsCount = 0; + bool result = FnTable.GetLiveCollisionBoundsInfo(null,ref punQuadsCount); + pQuadsBuffer= new HmdQuad_t[punQuadsCount]; + result = FnTable.GetLiveCollisionBoundsInfo(pQuadsBuffer,ref punQuadsCount); + return result; + } + public bool GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetWorkingSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); + return result; + } + public bool GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetWorkingStandingZeroPoseToRawTrackingPose(ref pmatStandingZeroPoseToRawTrackingPose); + return result; + } + public void SetWorkingPlayAreaSize(float sizeX,float sizeZ) + { + FnTable.SetWorkingPlayAreaSize(sizeX,sizeZ); + } + public void SetWorkingCollisionBoundsInfo(HmdQuad_t [] pQuadsBuffer) + { + FnTable.SetWorkingCollisionBoundsInfo(pQuadsBuffer,(uint) pQuadsBuffer.Length); + } + public void SetWorkingPerimeter(HmdVector2_t [] pPointBuffer) + { + FnTable.SetWorkingPerimeter(pPointBuffer,(uint) pPointBuffer.Length); + } + public void SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose) + { + FnTable.SetWorkingSeatedZeroPoseToRawTrackingPose(ref pMatSeatedZeroPoseToRawTrackingPose); + } + public void SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose) + { + FnTable.SetWorkingStandingZeroPoseToRawTrackingPose(ref pMatStandingZeroPoseToRawTrackingPose); + } + public void ReloadFromDisk(EChaperoneConfigFile configFile) + { + FnTable.ReloadFromDisk(configFile); + } + public bool GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetLiveSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); + return result; + } + public bool ExportLiveToBuffer(System.Text.StringBuilder pBuffer,ref uint pnBufferLength) + { + pnBufferLength = 0; + bool result = FnTable.ExportLiveToBuffer(pBuffer,ref pnBufferLength); + return result; + } + public bool ImportFromBufferToWorking(string pBuffer,uint nImportFlags) + { + bool result = FnTable.ImportFromBufferToWorking(pBuffer,nImportFlags); + return result; + } + public void ShowWorkingSetPreview() + { + FnTable.ShowWorkingSetPreview(); + } + public void HideWorkingSetPreview() + { + FnTable.HideWorkingSetPreview(); + } + public 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 bFadeIn) + { + FnTable.FadeGrid(fSeconds,bFadeIn); + } + public float GetCurrentGridAlpha() + { + float result = FnTable.GetCurrentGridAlpha(); + return result; + } + public EVRCompositorError SetSkyboxOverride(Texture_t [] pTextures) + { + EVRCompositorError result = FnTable.SetSkyboxOverride(pTextures,(uint) pTextures.Length); + return result; + } + public void ClearSkyboxOverride() + { + FnTable.ClearSkyboxOverride(); + } + public void CompositorBringToFront() + { + FnTable.CompositorBringToFront(); + } + public void CompositorGoToBack() + { + FnTable.CompositorGoToBack(); + } + public void CompositorQuit() + { + FnTable.CompositorQuit(); + } + public bool IsFullscreen() + { + bool result = FnTable.IsFullscreen(); + return result; + } + public uint GetCurrentSceneFocusProcess() + { + uint result = FnTable.GetCurrentSceneFocusProcess(); + return result; + } + public uint GetLastFrameRenderer() + { + uint result = FnTable.GetLastFrameRenderer(); + return result; + } + public bool CanRenderScene() + { + bool result = FnTable.CanRenderScene(); + return result; + } + public void ShowMirrorWindow() + { + FnTable.ShowMirrorWindow(); + } + public void HideMirrorWindow() + { + FnTable.HideMirrorWindow(); + } + public bool IsMirrorWindowVisible() + { + bool result = FnTable.IsMirrorWindowVisible(); + return result; + } + public void CompositorDumpImages() + { + FnTable.CompositorDumpImages(); + } + public bool ShouldAppRenderWithLowResources() + { + bool result = FnTable.ShouldAppRenderWithLowResources(); + return result; + } + public void ForceInterleavedReprojectionOn(bool bOverride) + { + FnTable.ForceInterleavedReprojectionOn(bOverride); + } + public void ForceReconnectProcess() + { + FnTable.ForceReconnectProcess(); + } + public void SuspendRendering(bool bSuspend) + { + FnTable.SuspendRendering(bSuspend); + } + public EVRCompositorError GetMirrorTextureD3D11(EVREye eEye,IntPtr pD3D11DeviceOrResource,ref IntPtr ppD3D11ShaderResourceView) + { + EVRCompositorError result = FnTable.GetMirrorTextureD3D11(eEye,pD3D11DeviceOrResource,ref ppD3D11ShaderResourceView); + return result; + } + public void ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView) + { + FnTable.ReleaseMirrorTextureD3D11(pD3D11ShaderResourceView); + } + public EVRCompositorError GetMirrorTextureGL(EVREye eEye,ref uint pglTextureId,IntPtr pglSharedTextureHandle) + { + pglTextureId = 0; + EVRCompositorError result = FnTable.GetMirrorTextureGL(eEye,ref pglTextureId,pglSharedTextureHandle); + return result; + } + public bool ReleaseSharedGLTexture(uint glTextureId,IntPtr glSharedTextureHandle) + { + bool result = FnTable.ReleaseSharedGLTexture(glTextureId,glSharedTextureHandle); + return result; + } + public void LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle) + { + FnTable.LockGLSharedTextureForAccess(glSharedTextureHandle); + } + public void UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle) + { + FnTable.UnlockGLSharedTextureForAccess(glSharedTextureHandle); + } + public uint GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue,uint unBufferSize) + { + uint result = FnTable.GetVulkanInstanceExtensionsRequired(pchValue,unBufferSize); + return result; + } + public uint GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice,System.Text.StringBuilder pchValue,uint unBufferSize) + { + uint result = FnTable.GetVulkanDeviceExtensionsRequired(pPhysicalDevice,pchValue,unBufferSize); + return result; + } + public void SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode) + { + FnTable.SetExplicitTimingMode(eTimingMode); + } + public EVRCompositorError SubmitExplicitTimingData() + { + EVRCompositorError result = FnTable.SubmitExplicitTimingData(); + return result; + } + public bool IsMotionSmoothingEnabled() + { + bool result = FnTable.IsMotionSmoothingEnabled(); + return result; + } + public bool IsMotionSmoothingSupported() + { + bool result = FnTable.IsMotionSmoothingSupported(); + return result; + } + public bool IsCurrentSceneFocusAppLoading() + { + bool result = FnTable.IsCurrentSceneFocusAppLoading(); + return result; + } +} + + +public class CVROverlay +{ + IVROverlay FnTable; + internal CVROverlay(IntPtr pInterface) + { + FnTable = (IVROverlay)Marshal.PtrToStructure(pInterface, typeof(IVROverlay)); + } + public EVROverlayError FindOverlay(string pchOverlayKey,ref ulong pOverlayHandle) + { + pOverlayHandle = 0; + EVROverlayError result = FnTable.FindOverlay(pchOverlayKey,ref pOverlayHandle); + return result; + } + public EVROverlayError CreateOverlay(string pchOverlayKey,string pchOverlayName,ref ulong pOverlayHandle) + { + pOverlayHandle = 0; + EVROverlayError result = FnTable.CreateOverlay(pchOverlayKey,pchOverlayName,ref pOverlayHandle); + return result; + } + public EVROverlayError DestroyOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.DestroyOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError SetHighQualityOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.SetHighQualityOverlay(ulOverlayHandle); + return result; + } + public ulong GetHighQualityOverlay() + { + ulong result = FnTable.GetHighQualityOverlay(); + return result; + } + public uint GetOverlayKey(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayKey(ulOverlayHandle,pchValue,unBufferSize,ref pError); + return result; + } + public uint GetOverlayName(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayName(ulOverlayHandle,pchValue,unBufferSize,ref pError); + return result; + } + public EVROverlayError SetOverlayName(ulong ulOverlayHandle,string pchName) + { + EVROverlayError result = FnTable.SetOverlayName(ulOverlayHandle,pchName); + return result; + } + public EVROverlayError GetOverlayImageData(ulong ulOverlayHandle,IntPtr pvBuffer,uint unBufferSize,ref uint punWidth,ref uint punHeight) + { + punWidth = 0; + punHeight = 0; + EVROverlayError result = FnTable.GetOverlayImageData(ulOverlayHandle,pvBuffer,unBufferSize,ref punWidth,ref punHeight); + return result; + } + public string GetOverlayErrorNameFromEnum(EVROverlayError error) + { + IntPtr result = FnTable.GetOverlayErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public EVROverlayError SetOverlayRenderingPid(ulong ulOverlayHandle,uint unPID) + { + EVROverlayError result = FnTable.SetOverlayRenderingPid(ulOverlayHandle,unPID); + return result; + } + public uint GetOverlayRenderingPid(ulong ulOverlayHandle) + { + uint result = FnTable.GetOverlayRenderingPid(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayFlag(ulong ulOverlayHandle,VROverlayFlags eOverlayFlag,bool bEnabled) + { + EVROverlayError result = FnTable.SetOverlayFlag(ulOverlayHandle,eOverlayFlag,bEnabled); + return result; + } + public EVROverlayError GetOverlayFlag(ulong ulOverlayHandle,VROverlayFlags eOverlayFlag,ref bool pbEnabled) + { + pbEnabled = false; + EVROverlayError result = FnTable.GetOverlayFlag(ulOverlayHandle,eOverlayFlag,ref pbEnabled); + return result; + } + public EVROverlayError SetOverlayColor(ulong ulOverlayHandle,float fRed,float fGreen,float fBlue) + { + EVROverlayError result = FnTable.SetOverlayColor(ulOverlayHandle,fRed,fGreen,fBlue); + return result; + } + public EVROverlayError GetOverlayColor(ulong ulOverlayHandle,ref float pfRed,ref float pfGreen,ref float pfBlue) + { + pfRed = 0; + pfGreen = 0; + pfBlue = 0; + EVROverlayError result = FnTable.GetOverlayColor(ulOverlayHandle,ref pfRed,ref pfGreen,ref pfBlue); + return result; + } + public EVROverlayError SetOverlayAlpha(ulong ulOverlayHandle,float fAlpha) + { + EVROverlayError result = FnTable.SetOverlayAlpha(ulOverlayHandle,fAlpha); + return result; + } + public EVROverlayError GetOverlayAlpha(ulong ulOverlayHandle,ref float pfAlpha) + { + pfAlpha = 0; + EVROverlayError result = FnTable.GetOverlayAlpha(ulOverlayHandle,ref pfAlpha); + return result; + } + public EVROverlayError SetOverlayTexelAspect(ulong ulOverlayHandle,float fTexelAspect) + { + EVROverlayError result = FnTable.SetOverlayTexelAspect(ulOverlayHandle,fTexelAspect); + return result; + } + public EVROverlayError GetOverlayTexelAspect(ulong ulOverlayHandle,ref float pfTexelAspect) + { + pfTexelAspect = 0; + EVROverlayError result = FnTable.GetOverlayTexelAspect(ulOverlayHandle,ref pfTexelAspect); + return result; + } + public EVROverlayError SetOverlaySortOrder(ulong ulOverlayHandle,uint unSortOrder) + { + EVROverlayError result = FnTable.SetOverlaySortOrder(ulOverlayHandle,unSortOrder); + return result; + } + public EVROverlayError GetOverlaySortOrder(ulong ulOverlayHandle,ref uint punSortOrder) + { + punSortOrder = 0; + EVROverlayError result = FnTable.GetOverlaySortOrder(ulOverlayHandle,ref punSortOrder); + return result; + } + public EVROverlayError SetOverlayWidthInMeters(ulong ulOverlayHandle,float fWidthInMeters) + { + EVROverlayError result = FnTable.SetOverlayWidthInMeters(ulOverlayHandle,fWidthInMeters); + return result; + } + public EVROverlayError GetOverlayWidthInMeters(ulong ulOverlayHandle,ref float pfWidthInMeters) + { + pfWidthInMeters = 0; + EVROverlayError result = FnTable.GetOverlayWidthInMeters(ulOverlayHandle,ref pfWidthInMeters); + return result; + } + public EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle,float fMinDistanceInMeters,float fMaxDistanceInMeters) + { + EVROverlayError result = FnTable.SetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle,fMinDistanceInMeters,fMaxDistanceInMeters); + return result; + } + public EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle,ref float pfMinDistanceInMeters,ref float pfMaxDistanceInMeters) + { + pfMinDistanceInMeters = 0; + pfMaxDistanceInMeters = 0; + EVROverlayError result = FnTable.GetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle,ref pfMinDistanceInMeters,ref pfMaxDistanceInMeters); + return result; + } + public EVROverlayError SetOverlayTextureColorSpace(ulong ulOverlayHandle,EColorSpace eTextureColorSpace) + { + EVROverlayError result = FnTable.SetOverlayTextureColorSpace(ulOverlayHandle,eTextureColorSpace); + return result; + } + public EVROverlayError GetOverlayTextureColorSpace(ulong ulOverlayHandle,ref EColorSpace peTextureColorSpace) + { + EVROverlayError result = FnTable.GetOverlayTextureColorSpace(ulOverlayHandle,ref peTextureColorSpace); + return result; + } + public EVROverlayError SetOverlayTextureBounds(ulong ulOverlayHandle,ref VRTextureBounds_t pOverlayTextureBounds) + { + EVROverlayError result = FnTable.SetOverlayTextureBounds(ulOverlayHandle,ref pOverlayTextureBounds); + return result; + } + public EVROverlayError GetOverlayTextureBounds(ulong ulOverlayHandle,ref VRTextureBounds_t pOverlayTextureBounds) + { + EVROverlayError result = FnTable.GetOverlayTextureBounds(ulOverlayHandle,ref pOverlayTextureBounds); + return result; + } + public uint GetOverlayRenderModel(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref HmdColor_t pColor,ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayRenderModel(ulOverlayHandle,pchValue,unBufferSize,ref pColor,ref pError); + return result; + } + public EVROverlayError SetOverlayRenderModel(ulong ulOverlayHandle,string pchRenderModel,ref HmdColor_t pColor) + { + EVROverlayError result = FnTable.SetOverlayRenderModel(ulOverlayHandle,pchRenderModel,ref pColor); + return result; + } + public EVROverlayError GetOverlayTransformType(ulong ulOverlayHandle,ref VROverlayTransformType peTransformType) + { + EVROverlayError result = FnTable.GetOverlayTransformType(ulOverlayHandle,ref peTransformType); + return result; + } + public EVROverlayError SetOverlayTransformAbsolute(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformAbsolute(ulOverlayHandle,eTrackingOrigin,ref pmatTrackingOriginToOverlayTransform); + return result; + } + public EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle,ref ETrackingUniverseOrigin peTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) + { + EVROverlayError result = FnTable.GetOverlayTransformAbsolute(ulOverlayHandle,ref peTrackingOrigin,ref pmatTrackingOriginToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle,uint unTrackedDevice,ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceRelative(ulOverlayHandle,unTrackedDevice,ref pmatTrackedDeviceToOverlayTransform); + return result; + } + public EVROverlayError GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle,ref uint punTrackedDevice,ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform) + { + punTrackedDevice = 0; + EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceRelative(ulOverlayHandle,ref punTrackedDevice,ref pmatTrackedDeviceToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,uint unDeviceIndex,string pchComponentName) + { + EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,unDeviceIndex,pchComponentName); + return result; + } + public EVROverlayError GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,ref uint punDeviceIndex,System.Text.StringBuilder pchComponentName,uint unComponentNameSize) + { + punDeviceIndex = 0; + EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,ref punDeviceIndex,pchComponentName,unComponentNameSize); + return result; + } + public EVROverlayError GetOverlayTransformOverlayRelative(ulong ulOverlayHandle,ref ulong ulOverlayHandleParent,ref HmdMatrix34_t pmatParentOverlayToOverlayTransform) + { + ulOverlayHandleParent = 0; + EVROverlayError result = FnTable.GetOverlayTransformOverlayRelative(ulOverlayHandle,ref ulOverlayHandleParent,ref pmatParentOverlayToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformOverlayRelative(ulong ulOverlayHandle,ulong ulOverlayHandleParent,ref HmdMatrix34_t pmatParentOverlayToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformOverlayRelative(ulOverlayHandle,ulOverlayHandleParent,ref pmatParentOverlayToOverlayTransform); + return result; + } + public EVROverlayError ShowOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ShowOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError HideOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.HideOverlay(ulOverlayHandle); + return result; + } + public bool IsOverlayVisible(ulong ulOverlayHandle) + { + bool result = FnTable.IsOverlayVisible(ulOverlayHandle); + return result; + } + public EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,HmdVector2_t coordinatesInOverlay,ref HmdMatrix34_t pmatTransform) + { + EVROverlayError result = FnTable.GetTransformForOverlayCoordinates(ulOverlayHandle,eTrackingOrigin,coordinatesInOverlay,ref pmatTransform); + return result; + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextOverlayEventPacked(ulong ulOverlayHandle,ref VREvent_t_Packed pEvent,uint uncbVREvent); + [StructLayout(LayoutKind.Explicit)] + struct PollNextOverlayEventUnion + { + [FieldOffset(0)] + public IVROverlay._PollNextOverlayEvent pPollNextOverlayEvent; + [FieldOffset(0)] + public _PollNextOverlayEventPacked pPollNextOverlayEventPacked; + } + public bool PollNextOverlayEvent(ulong ulOverlayHandle,ref VREvent_t pEvent,uint uncbVREvent) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + PollNextOverlayEventUnion u; + VREvent_t_Packed event_packed = new VREvent_t_Packed(); + u.pPollNextOverlayEventPacked = null; + u.pPollNextOverlayEvent = FnTable.PollNextOverlayEvent; + bool packed_result = u.pPollNextOverlayEventPacked(ulOverlayHandle,ref event_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed))); + + event_packed.Unpack(ref pEvent); + return packed_result; + } +#endif + bool result = FnTable.PollNextOverlayEvent(ulOverlayHandle,ref pEvent,uncbVREvent); + return result; + } + public EVROverlayError GetOverlayInputMethod(ulong ulOverlayHandle,ref VROverlayInputMethod peInputMethod) + { + EVROverlayError result = FnTable.GetOverlayInputMethod(ulOverlayHandle,ref peInputMethod); + return result; + } + public EVROverlayError SetOverlayInputMethod(ulong ulOverlayHandle,VROverlayInputMethod eInputMethod) + { + EVROverlayError result = FnTable.SetOverlayInputMethod(ulOverlayHandle,eInputMethod); + return result; + } + public EVROverlayError GetOverlayMouseScale(ulong ulOverlayHandle,ref HmdVector2_t pvecMouseScale) + { + EVROverlayError result = FnTable.GetOverlayMouseScale(ulOverlayHandle,ref pvecMouseScale); + return result; + } + public EVROverlayError SetOverlayMouseScale(ulong ulOverlayHandle,ref HmdVector2_t pvecMouseScale) + { + EVROverlayError result = FnTable.SetOverlayMouseScale(ulOverlayHandle,ref pvecMouseScale); + return result; + } + public bool ComputeOverlayIntersection(ulong ulOverlayHandle,ref VROverlayIntersectionParams_t pParams,ref VROverlayIntersectionResults_t pResults) + { + bool result = FnTable.ComputeOverlayIntersection(ulOverlayHandle,ref pParams,ref pResults); + return result; + } + public bool IsHoverTargetOverlay(ulong ulOverlayHandle) + { + bool result = FnTable.IsHoverTargetOverlay(ulOverlayHandle); + return result; + } + public ulong GetGamepadFocusOverlay() + { + ulong result = FnTable.GetGamepadFocusOverlay(); + return result; + } + public EVROverlayError SetGamepadFocusOverlay(ulong ulNewFocusOverlay) + { + EVROverlayError result = FnTable.SetGamepadFocusOverlay(ulNewFocusOverlay); + return result; + } + public EVROverlayError SetOverlayNeighbor(EOverlayDirection eDirection,ulong ulFrom,ulong ulTo) + { + EVROverlayError result = FnTable.SetOverlayNeighbor(eDirection,ulFrom,ulTo); + return result; + } + public EVROverlayError MoveGamepadFocusToNeighbor(EOverlayDirection eDirection,ulong ulFrom) + { + EVROverlayError result = FnTable.MoveGamepadFocusToNeighbor(eDirection,ulFrom); + return result; + } + public EVROverlayError SetOverlayDualAnalogTransform(ulong ulOverlay,EDualAnalogWhich eWhich,ref HmdVector2_t pvCenter,float fRadius) + { + EVROverlayError result = FnTable.SetOverlayDualAnalogTransform(ulOverlay,eWhich,ref pvCenter,fRadius); + return result; + } + public EVROverlayError GetOverlayDualAnalogTransform(ulong ulOverlay,EDualAnalogWhich eWhich,ref HmdVector2_t pvCenter,ref float pfRadius) + { + pfRadius = 0; + EVROverlayError result = FnTable.GetOverlayDualAnalogTransform(ulOverlay,eWhich,ref pvCenter,ref pfRadius); + return result; + } + public EVROverlayError SetOverlayTexture(ulong ulOverlayHandle,ref Texture_t pTexture) + { + EVROverlayError result = FnTable.SetOverlayTexture(ulOverlayHandle,ref pTexture); + return result; + } + public EVROverlayError ClearOverlayTexture(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ClearOverlayTexture(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayRaw(ulong ulOverlayHandle,IntPtr pvBuffer,uint unWidth,uint unHeight,uint unDepth) + { + EVROverlayError result = FnTable.SetOverlayRaw(ulOverlayHandle,pvBuffer,unWidth,unHeight,unDepth); + return result; + } + public EVROverlayError SetOverlayFromFile(ulong ulOverlayHandle,string pchFilePath) + { + EVROverlayError result = FnTable.SetOverlayFromFile(ulOverlayHandle,pchFilePath); + return result; + } + public EVROverlayError GetOverlayTexture(ulong ulOverlayHandle,ref IntPtr pNativeTextureHandle,IntPtr pNativeTextureRef,ref uint pWidth,ref uint pHeight,ref uint pNativeFormat,ref ETextureType pAPIType,ref EColorSpace pColorSpace,ref VRTextureBounds_t pTextureBounds) + { + pWidth = 0; + pHeight = 0; + pNativeFormat = 0; + EVROverlayError result = FnTable.GetOverlayTexture(ulOverlayHandle,ref pNativeTextureHandle,pNativeTextureRef,ref pWidth,ref pHeight,ref pNativeFormat,ref pAPIType,ref pColorSpace,ref pTextureBounds); + return result; + } + public EVROverlayError ReleaseNativeOverlayHandle(ulong ulOverlayHandle,IntPtr pNativeTextureHandle) + { + EVROverlayError result = FnTable.ReleaseNativeOverlayHandle(ulOverlayHandle,pNativeTextureHandle); + return result; + } + public EVROverlayError GetOverlayTextureSize(ulong ulOverlayHandle,ref uint pWidth,ref uint pHeight) + { + pWidth = 0; + pHeight = 0; + EVROverlayError result = FnTable.GetOverlayTextureSize(ulOverlayHandle,ref pWidth,ref pHeight); + return result; + } + public EVROverlayError CreateDashboardOverlay(string pchOverlayKey,string pchOverlayFriendlyName,ref ulong pMainHandle,ref ulong pThumbnailHandle) + { + pMainHandle = 0; + pThumbnailHandle = 0; + EVROverlayError result = FnTable.CreateDashboardOverlay(pchOverlayKey,pchOverlayFriendlyName,ref pMainHandle,ref pThumbnailHandle); + return result; + } + public bool IsDashboardVisible() + { + bool result = FnTable.IsDashboardVisible(); + return result; + } + public bool IsActiveDashboardOverlay(ulong ulOverlayHandle) + { + bool result = FnTable.IsActiveDashboardOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError SetDashboardOverlaySceneProcess(ulong ulOverlayHandle,uint unProcessId) + { + EVROverlayError result = FnTable.SetDashboardOverlaySceneProcess(ulOverlayHandle,unProcessId); + return result; + } + public EVROverlayError GetDashboardOverlaySceneProcess(ulong ulOverlayHandle,ref uint punProcessId) + { + punProcessId = 0; + EVROverlayError result = FnTable.GetDashboardOverlaySceneProcess(ulOverlayHandle,ref punProcessId); + return result; + } + public void ShowDashboard(string pchOverlayToShow) + { + FnTable.ShowDashboard(pchOverlayToShow); + } + public uint GetPrimaryDashboardDevice() + { + uint result = FnTable.GetPrimaryDashboardDevice(); + return result; + } + public EVROverlayError ShowKeyboard(int eInputMode,int eLineInputMode,string pchDescription,uint unCharMax,string pchExistingText,bool bUseMinimalMode,ulong uUserValue) + { + EVROverlayError result = FnTable.ShowKeyboard(eInputMode,eLineInputMode,pchDescription,unCharMax,pchExistingText,bUseMinimalMode,uUserValue); + return result; + } + public EVROverlayError ShowKeyboardForOverlay(ulong ulOverlayHandle,int eInputMode,int eLineInputMode,string pchDescription,uint unCharMax,string pchExistingText,bool bUseMinimalMode,ulong uUserValue) + { + EVROverlayError result = FnTable.ShowKeyboardForOverlay(ulOverlayHandle,eInputMode,eLineInputMode,pchDescription,unCharMax,pchExistingText,bUseMinimalMode,uUserValue); + return result; + } + public uint GetKeyboardText(System.Text.StringBuilder pchText,uint cchText) + { + uint result = FnTable.GetKeyboardText(pchText,cchText); + return result; + } + public void HideKeyboard() + { + FnTable.HideKeyboard(); + } + public void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform) + { + FnTable.SetKeyboardTransformAbsolute(eTrackingOrigin,ref pmatTrackingOriginToKeyboardTransform); + } + public void SetKeyboardPositionForOverlay(ulong ulOverlayHandle,HmdRect2_t avoidRect) + { + FnTable.SetKeyboardPositionForOverlay(ulOverlayHandle,avoidRect); + } + public EVROverlayError SetOverlayIntersectionMask(ulong ulOverlayHandle,ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives,uint unNumMaskPrimitives,uint unPrimitiveSize) + { + EVROverlayError result = FnTable.SetOverlayIntersectionMask(ulOverlayHandle,ref pMaskPrimitives,unNumMaskPrimitives,unPrimitiveSize); + return result; + } + public EVROverlayError GetOverlayFlags(ulong ulOverlayHandle,ref uint pFlags) + { + pFlags = 0; + EVROverlayError result = FnTable.GetOverlayFlags(ulOverlayHandle,ref pFlags); + return result; + } + public VRMessageOverlayResponse ShowMessageOverlay(string pchText,string pchCaption,string pchButton0Text,string pchButton1Text,string pchButton2Text,string pchButton3Text) + { + VRMessageOverlayResponse result = FnTable.ShowMessageOverlay(pchText,pchCaption,pchButton0Text,pchButton1Text,pchButton2Text,pchButton3Text); + return result; + } + public void CloseMessageOverlay() + { + FnTable.CloseMessageOverlay(); + } +} + + +public class CVRRenderModels +{ + IVRRenderModels FnTable; + internal CVRRenderModels(IntPtr pInterface) + { + FnTable = (IVRRenderModels)Marshal.PtrToStructure(pInterface, typeof(IVRRenderModels)); + } + public EVRRenderModelError LoadRenderModel_Async(string pchRenderModelName,ref IntPtr ppRenderModel) + { + EVRRenderModelError result = FnTable.LoadRenderModel_Async(pchRenderModelName,ref ppRenderModel); + return result; + } + public void FreeRenderModel(IntPtr pRenderModel) + { + FnTable.FreeRenderModel(pRenderModel); + } + public EVRRenderModelError LoadTexture_Async(int textureId,ref IntPtr ppTexture) + { + EVRRenderModelError result = FnTable.LoadTexture_Async(textureId,ref ppTexture); + return result; + } + public void FreeTexture(IntPtr pTexture) + { + FnTable.FreeTexture(pTexture); + } + public EVRRenderModelError LoadTextureD3D11_Async(int textureId,IntPtr pD3D11Device,ref IntPtr ppD3D11Texture2D) + { + EVRRenderModelError result = FnTable.LoadTextureD3D11_Async(textureId,pD3D11Device,ref ppD3D11Texture2D); + return result; + } + public EVRRenderModelError LoadIntoTextureD3D11_Async(int textureId,IntPtr pDstTexture) + { + EVRRenderModelError result = FnTable.LoadIntoTextureD3D11_Async(textureId,pDstTexture); + return result; + } + public void FreeTextureD3D11(IntPtr pD3D11Texture2D) + { + FnTable.FreeTextureD3D11(pD3D11Texture2D); + } + public uint GetRenderModelName(uint unRenderModelIndex,System.Text.StringBuilder pchRenderModelName,uint unRenderModelNameLen) + { + uint result = FnTable.GetRenderModelName(unRenderModelIndex,pchRenderModelName,unRenderModelNameLen); + return result; + } + public uint GetRenderModelCount() + { + uint result = FnTable.GetRenderModelCount(); + return result; + } + public uint GetComponentCount(string pchRenderModelName) + { + uint result = FnTable.GetComponentCount(pchRenderModelName); + return result; + } + public uint GetComponentName(string pchRenderModelName,uint unComponentIndex,System.Text.StringBuilder pchComponentName,uint unComponentNameLen) + { + uint result = FnTable.GetComponentName(pchRenderModelName,unComponentIndex,pchComponentName,unComponentNameLen); + return result; + } + public ulong GetComponentButtonMask(string pchRenderModelName,string pchComponentName) + { + ulong result = FnTable.GetComponentButtonMask(pchRenderModelName,pchComponentName); + return result; + } + public uint GetComponentRenderModelName(string pchRenderModelName,string pchComponentName,System.Text.StringBuilder pchComponentRenderModelName,uint unComponentRenderModelNameLen) + { + uint result = FnTable.GetComponentRenderModelName(pchRenderModelName,pchComponentName,pchComponentRenderModelName,unComponentRenderModelNameLen); + return result; + } + public bool GetComponentStateForDevicePath(string pchRenderModelName,string pchComponentName,ulong devicePath,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState) + { + bool result = FnTable.GetComponentStateForDevicePath(pchRenderModelName,pchComponentName,devicePath,ref pState,ref pComponentState); + return result; + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentStatePacked(string pchRenderModelName,string pchComponentName,ref VRControllerState_t_Packed pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState); + [StructLayout(LayoutKind.Explicit)] + struct GetComponentStateUnion + { + [FieldOffset(0)] + public IVRRenderModels._GetComponentState pGetComponentState; + [FieldOffset(0)] + public _GetComponentStatePacked pGetComponentStatePacked; + } + public bool GetComponentState(string pchRenderModelName,string pchComponentName,ref VRControllerState_t pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetComponentStateUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetComponentStatePacked = null; + u.pGetComponentState = FnTable.GetComponentState; + bool packed_result = u.pGetComponentStatePacked(pchRenderModelName,pchComponentName,ref state_packed,ref pState,ref pComponentState); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetComponentState(pchRenderModelName,pchComponentName,ref pControllerState,ref pState,ref pComponentState); + return result; + } + public bool RenderModelHasComponent(string pchRenderModelName,string pchComponentName) + { + bool result = FnTable.RenderModelHasComponent(pchRenderModelName,pchComponentName); + return result; + } + public uint GetRenderModelThumbnailURL(string pchRenderModelName,System.Text.StringBuilder pchThumbnailURL,uint unThumbnailURLLen,ref EVRRenderModelError peError) + { + uint result = FnTable.GetRenderModelThumbnailURL(pchRenderModelName,pchThumbnailURL,unThumbnailURLLen,ref peError); + return result; + } + public uint GetRenderModelOriginalPath(string pchRenderModelName,System.Text.StringBuilder pchOriginalPath,uint unOriginalPathLen,ref EVRRenderModelError peError) + { + uint result = FnTable.GetRenderModelOriginalPath(pchRenderModelName,pchOriginalPath,unOriginalPathLen,ref peError); + return result; + } + public string GetRenderModelErrorNameFromEnum(EVRRenderModelError error) + { + IntPtr result = FnTable.GetRenderModelErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } +} + + +public class CVRNotifications +{ + IVRNotifications FnTable; + internal CVRNotifications(IntPtr pInterface) + { + FnTable = (IVRNotifications)Marshal.PtrToStructure(pInterface, typeof(IVRNotifications)); + } + public EVRNotificationError CreateNotification(ulong ulOverlayHandle,ulong ulUserValue,EVRNotificationType type,string pchText,EVRNotificationStyle style,ref NotificationBitmap_t pImage,ref uint pNotificationId) + { + pNotificationId = 0; + EVRNotificationError result = FnTable.CreateNotification(ulOverlayHandle,ulUserValue,type,pchText,style,ref pImage,ref pNotificationId); + return result; + } + public EVRNotificationError RemoveNotification(uint notificationId) + { + EVRNotificationError result = FnTable.RemoveNotification(notificationId); + return result; + } +} + + +public class CVRSettings +{ + IVRSettings FnTable; + internal CVRSettings(IntPtr pInterface) + { + FnTable = (IVRSettings)Marshal.PtrToStructure(pInterface, typeof(IVRSettings)); + } + public string GetSettingsErrorNameFromEnum(EVRSettingsError eError) + { + IntPtr result = FnTable.GetSettingsErrorNameFromEnum(eError); + return Marshal.PtrToStringAnsi(result); + } + public bool Sync(bool bForce,ref EVRSettingsError peError) + { + bool result = FnTable.Sync(bForce,ref peError); + return result; + } + public void SetBool(string pchSection,string pchSettingsKey,bool bValue,ref EVRSettingsError peError) + { + FnTable.SetBool(pchSection,pchSettingsKey,bValue,ref peError); + } + public void SetInt32(string pchSection,string pchSettingsKey,int nValue,ref EVRSettingsError peError) + { + FnTable.SetInt32(pchSection,pchSettingsKey,nValue,ref peError); + } + public void SetFloat(string pchSection,string pchSettingsKey,float flValue,ref EVRSettingsError peError) + { + FnTable.SetFloat(pchSection,pchSettingsKey,flValue,ref peError); + } + public void SetString(string pchSection,string pchSettingsKey,string pchValue,ref EVRSettingsError peError) + { + FnTable.SetString(pchSection,pchSettingsKey,pchValue,ref peError); + } + public bool GetBool(string pchSection,string pchSettingsKey,ref EVRSettingsError peError) + { + bool result = FnTable.GetBool(pchSection,pchSettingsKey,ref peError); + return result; + } + public int GetInt32(string pchSection,string pchSettingsKey,ref EVRSettingsError peError) + { + int result = FnTable.GetInt32(pchSection,pchSettingsKey,ref peError); + return result; + } + public float GetFloat(string pchSection,string pchSettingsKey,ref EVRSettingsError peError) + { + float result = FnTable.GetFloat(pchSection,pchSettingsKey,ref peError); + return result; + } + public void GetString(string pchSection,string pchSettingsKey,System.Text.StringBuilder pchValue,uint unValueLen,ref EVRSettingsError peError) + { + FnTable.GetString(pchSection,pchSettingsKey,pchValue,unValueLen,ref peError); + } + public void RemoveSection(string pchSection,ref EVRSettingsError peError) + { + FnTable.RemoveSection(pchSection,ref peError); + } + public void RemoveKeyInSection(string pchSection,string pchSettingsKey,ref EVRSettingsError peError) + { + FnTable.RemoveKeyInSection(pchSection,pchSettingsKey,ref peError); + } +} + + +public class CVRScreenshots +{ + IVRScreenshots FnTable; + internal CVRScreenshots(IntPtr pInterface) + { + FnTable = (IVRScreenshots)Marshal.PtrToStructure(pInterface, typeof(IVRScreenshots)); + } + public EVRScreenshotError RequestScreenshot(ref uint pOutScreenshotHandle,EVRScreenshotType type,string pchPreviewFilename,string pchVRFilename) + { + pOutScreenshotHandle = 0; + EVRScreenshotError result = FnTable.RequestScreenshot(ref pOutScreenshotHandle,type,pchPreviewFilename,pchVRFilename); + return result; + } + public EVRScreenshotError HookScreenshot(EVRScreenshotType [] pSupportedTypes) + { + EVRScreenshotError result = FnTable.HookScreenshot(pSupportedTypes,(int) pSupportedTypes.Length); + return result; + } + public EVRScreenshotType GetScreenshotPropertyType(uint screenshotHandle,ref EVRScreenshotError pError) + { + EVRScreenshotType result = FnTable.GetScreenshotPropertyType(screenshotHandle,ref pError); + return result; + } + public uint GetScreenshotPropertyFilename(uint screenshotHandle,EVRScreenshotPropertyFilenames filenameType,System.Text.StringBuilder pchFilename,uint cchFilename,ref EVRScreenshotError pError) + { + uint result = FnTable.GetScreenshotPropertyFilename(screenshotHandle,filenameType,pchFilename,cchFilename,ref pError); + return result; + } + public EVRScreenshotError UpdateScreenshotProgress(uint screenshotHandle,float flProgress) + { + EVRScreenshotError result = FnTable.UpdateScreenshotProgress(screenshotHandle,flProgress); + return result; + } + public EVRScreenshotError TakeStereoScreenshot(ref uint pOutScreenshotHandle,string pchPreviewFilename,string pchVRFilename) + { + pOutScreenshotHandle = 0; + EVRScreenshotError result = FnTable.TakeStereoScreenshot(ref pOutScreenshotHandle,pchPreviewFilename,pchVRFilename); + return result; + } + public EVRScreenshotError SubmitScreenshot(uint screenshotHandle,EVRScreenshotType type,string pchSourcePreviewFilename,string pchSourceVRFilename) + { + EVRScreenshotError result = FnTable.SubmitScreenshot(screenshotHandle,type,pchSourcePreviewFilename,pchSourceVRFilename); + return result; + } +} + + +public class CVRResources +{ + IVRResources FnTable; + internal CVRResources(IntPtr pInterface) + { + FnTable = (IVRResources)Marshal.PtrToStructure(pInterface, typeof(IVRResources)); + } + public uint LoadSharedResource(string pchResourceName,string pchBuffer,uint unBufferLen) + { + uint result = FnTable.LoadSharedResource(pchResourceName,pchBuffer,unBufferLen); + return result; + } + public uint GetResourceFullPath(string pchResourceName,string pchResourceTypeDirectory,System.Text.StringBuilder pchPathBuffer,uint unBufferLen) + { + uint result = FnTable.GetResourceFullPath(pchResourceName,pchResourceTypeDirectory,pchPathBuffer,unBufferLen); + return result; + } +} + + +public class CVRDriverManager +{ + IVRDriverManager FnTable; + internal CVRDriverManager(IntPtr pInterface) + { + FnTable = (IVRDriverManager)Marshal.PtrToStructure(pInterface, typeof(IVRDriverManager)); + } + public uint GetDriverCount() + { + uint result = FnTable.GetDriverCount(); + return result; + } + public uint GetDriverName(uint nDriver,System.Text.StringBuilder pchValue,uint unBufferSize) + { + uint result = FnTable.GetDriverName(nDriver,pchValue,unBufferSize); + return result; + } + public ulong GetDriverHandle(string pchDriverName) + { + ulong result = FnTable.GetDriverHandle(pchDriverName); + return result; + } + public 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) + { + EVRInputError result = FnTable.SetActionManifestPath(pchActionManifestPath); + return result; + } + public EVRInputError GetActionSetHandle(string pchActionSetName,ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetActionSetHandle(pchActionSetName,ref pHandle); + return result; + } + public EVRInputError GetActionHandle(string pchActionName,ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetActionHandle(pchActionName,ref pHandle); + return result; + } + public EVRInputError GetInputSourceHandle(string pchInputSourcePath,ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetInputSourceHandle(pchInputSourcePath,ref pHandle); + return result; + } + public EVRInputError UpdateActionState(VRActiveActionSet_t [] pSets,uint unSizeOfVRSelectedActionSet_t) + { + EVRInputError result = FnTable.UpdateActionState(pSets,unSizeOfVRSelectedActionSet_t,(uint) pSets.Length); + return result; + } + public EVRInputError GetDigitalActionData(ulong action,ref InputDigitalActionData_t pActionData,uint unActionDataSize,ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetDigitalActionData(action,ref pActionData,unActionDataSize,ulRestrictToDevice); + return result; + } + public EVRInputError GetAnalogActionData(ulong action,ref InputAnalogActionData_t pActionData,uint unActionDataSize,ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetAnalogActionData(action,ref pActionData,unActionDataSize,ulRestrictToDevice); + return result; + } + public EVRInputError 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 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 bool IsUsingLegacyInput() + { + bool result = FnTable.IsUsingLegacyInput(); + return result; + } +} + + +public class CVRIOBuffer +{ + IVRIOBuffer FnTable; + internal CVRIOBuffer(IntPtr pInterface) + { + FnTable = (IVRIOBuffer)Marshal.PtrToStructure(pInterface, typeof(IVRIOBuffer)); + } + public EIOBufferError Open(string pchPath,EIOBufferMode mode,uint unElementSize,uint unElements,ref ulong pulBuffer) + { + pulBuffer = 0; + EIOBufferError result = FnTable.Open(pchPath,mode,unElementSize,unElements,ref pulBuffer); + return result; + } + public EIOBufferError Close(ulong ulBuffer) + { + EIOBufferError result = FnTable.Close(ulBuffer); + return result; + } + public EIOBufferError Read(ulong ulBuffer,IntPtr pDst,uint unBytes,ref uint punRead) + { + punRead = 0; + EIOBufferError result = FnTable.Read(ulBuffer,pDst,unBytes,ref punRead); + return result; + } + public EIOBufferError Write(ulong ulBuffer,IntPtr pSrc,uint unBytes) + { + EIOBufferError result = FnTable.Write(ulBuffer,pSrc,unBytes); + return result; + } + public ulong PropertyContainer(ulong ulBuffer) + { + ulong result = FnTable.PropertyContainer(ulBuffer); + return result; + } + public bool HasReaders(ulong ulBuffer) + { + bool result = FnTable.HasReaders(ulBuffer); + return result; + } +} + + +public class CVRSpatialAnchors +{ + IVRSpatialAnchors FnTable; + internal CVRSpatialAnchors(IntPtr pInterface) + { + FnTable = (IVRSpatialAnchors)Marshal.PtrToStructure(pInterface, typeof(IVRSpatialAnchors)); + } + public EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor(string pchDescriptor,ref uint pHandleOut) + { + pHandleOut = 0; + EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromDescriptor(pchDescriptor,ref pHandleOut); + return result; + } + public EVRSpatialAnchorError CreateSpatialAnchorFromPose(uint unDeviceIndex,ETrackingUniverseOrigin eOrigin,ref SpatialAnchorPose_t pPose,ref uint pHandleOut) + { + pHandleOut = 0; + EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromPose(unDeviceIndex,eOrigin,ref pPose,ref pHandleOut); + return result; + } + public EVRSpatialAnchorError GetSpatialAnchorPose(uint unHandle,ETrackingUniverseOrigin eOrigin,ref SpatialAnchorPose_t pPoseOut) + { + EVRSpatialAnchorError result = FnTable.GetSpatialAnchorPose(unHandle,eOrigin,ref pPoseOut); + return result; + } + public EVRSpatialAnchorError GetSpatialAnchorDescriptor(uint unHandle,System.Text.StringBuilder pchDescriptorOut,ref uint punDescriptorBufferLenInOut) + { + punDescriptorBufferLenInOut = 0; + EVRSpatialAnchorError result = FnTable.GetSpatialAnchorDescriptor(unHandle,pchDescriptorOut,ref punDescriptorBufferLenInOut); + return result; + } +} + + +public class CVRDebug +{ + IVRDebug FnTable; + internal CVRDebug(IntPtr pInterface) + { + FnTable = (IVRDebug)Marshal.PtrToStructure(pInterface, typeof(IVRDebug)); + } + public EVRDebugError EmitVrProfilerEvent(string pchMessage) + { + EVRDebugError result = FnTable.EmitVrProfilerEvent(pchMessage); + 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) + { + EVRDebugError result = FnTable.FinishVrProfilerEvent(hHandle,pchMessage); + return result; + } + public uint DriverDebugRequest(uint unDeviceIndex,string pchRequest,System.Text.StringBuilder pchResponseBuffer,uint unResponseBufferSize) + { + uint result = FnTable.DriverDebugRequest(unDeviceIndex,pchRequest,pchResponseBuffer,unResponseBufferSize); + return result; + } +} + + +public class OpenVRInterop +{ + [DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType); + [DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal2", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType,[In, MarshalAs(UnmanagedType.LPStr)] string pStartupInfo); + [DllImportAttribute("openvr_api", EntryPoint = "VR_ShutdownInternal", CallingConvention = CallingConvention.Cdecl)] + internal static extern void ShutdownInternal(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsHmdPresent", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsHmdPresent(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsRuntimeInstalled", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsRuntimeInstalled(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_RuntimePath", CallingConvention = CallingConvention.Cdecl)] + internal static extern string RuntimePath(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetStringForHmdError", CallingConvention = CallingConvention.Cdecl)] + internal static extern IntPtr GetStringForHmdError(EVRInitError error); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetGenericInterface", CallingConvention = CallingConvention.Cdecl)] + internal static extern IntPtr GetGenericInterface([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion, ref EVRInitError peError); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsInterfaceVersionValid", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsInterfaceVersionValid([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetInitToken", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint GetInitToken(); +} + + +public enum EVREye +{ + Eye_Left = 0, + Eye_Right = 1, +} +public enum ETextureType +{ + Invalid = -1, + DirectX = 0, + OpenGL = 1, + Vulkan = 2, + IOSurface = 3, + DirectX12 = 4, + DXGISharedHandle = 5, + Metal = 6, +} +public enum EColorSpace +{ + Auto = 0, + Gamma = 1, + Linear = 2, +} +public enum ETrackingResult +{ + Uninitialized = 1, + Calibrating_InProgress = 100, + Calibrating_OutOfRange = 101, + Running_OK = 200, + Running_OutOfRange = 201, + Fallback_RotationOnly = 300, +} +public enum ETrackedDeviceClass +{ + Invalid = 0, + HMD = 1, + Controller = 2, + GenericTracker = 3, + TrackingReference = 4, + DisplayRedirect = 5, + Max = 6, +} +public enum ETrackedControllerRole +{ + Invalid = 0, + LeftHand = 1, + RightHand = 2, + OptOut = 3, + Treadmill = 4, + Max = 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_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_DisplayAvailableFrameRates_Float_Array = 2080, + Prop_DisplaySupportsMultipleFramerates_Bool = 2081, + Prop_DisplayColorMultLeft_Vector3 = 2082, + Prop_DisplayColorMultRight_Vector3 = 2083, + Prop_DashboardLayoutPathName_String = 2090, + Prop_DriverRequestedMuraCorrectionMode_Int32 = 2200, + Prop_DriverRequestedMuraFeather_InnerLeft_Int32 = 2201, + Prop_DriverRequestedMuraFeather_InnerRight_Int32 = 2202, + Prop_DriverRequestedMuraFeather_InnerTop_Int32 = 2203, + Prop_DriverRequestedMuraFeather_InnerBottom_Int32 = 2204, + Prop_DriverRequestedMuraFeather_OuterLeft_Int32 = 2205, + Prop_DriverRequestedMuraFeather_OuterRight_Int32 = 2206, + Prop_DriverRequestedMuraFeather_OuterTop_Int32 = 2207, + Prop_DriverRequestedMuraFeather_OuterBottom_Int32 = 2208, + Prop_AttachedDeviceId_String = 3000, + Prop_SupportedButtons_Uint64 = 3001, + Prop_Axis0Type_Int32 = 3002, + Prop_Axis1Type_Int32 = 3003, + Prop_Axis2Type_Int32 = 3004, + Prop_Axis3Type_Int32 = 3005, + Prop_Axis4Type_Int32 = 3006, + Prop_ControllerRoleHint_Int32 = 3007, + Prop_FieldOfViewLeftDegrees_Float = 4000, + Prop_FieldOfViewRightDegrees_Float = 4001, + Prop_FieldOfViewTopDegrees_Float = 4002, + Prop_FieldOfViewBottomDegrees_Float = 4003, + Prop_TrackingRangeMinimumMeters_Float = 4004, + Prop_TrackingRangeMaximumMeters_Float = 4005, + Prop_ModeLabel_String = 4006, + Prop_CanWirelessIdentify_Bool = 4007, + Prop_Nonce_Int32 = 4008, + Prop_IconPathName_String = 5000, + Prop_NamedIconPathDeviceOff_String = 5001, + Prop_NamedIconPathDeviceSearching_String = 5002, + Prop_NamedIconPathDeviceSearchingAlert_String = 5003, + Prop_NamedIconPathDeviceReady_String = 5004, + Prop_NamedIconPathDeviceReadyAlert_String = 5005, + Prop_NamedIconPathDeviceNotReady_String = 5006, + Prop_NamedIconPathDeviceStandby_String = 5007, + Prop_NamedIconPathDeviceAlertLow_String = 5008, + Prop_DisplayHiddenArea_Binary_Start = 5100, + Prop_DisplayHiddenArea_Binary_End = 5150, + Prop_ParentContainer = 5151, + Prop_UserConfigPath_String = 6000, + Prop_InstallPath_String = 6001, + Prop_HasDisplayComponent_Bool = 6002, + Prop_HasControllerComponent_Bool = 6003, + Prop_HasCameraComponent_Bool = 6004, + Prop_HasDriverDirectModeComponent_Bool = 6005, + Prop_HasVirtualDisplayComponent_Bool = 6006, + Prop_HasSpatialAnchorsSupport_Bool = 6007, + Prop_ControllerType_String = 7000, + Prop_ControllerHandSelectionPriority_Int32 = 7002, + Prop_VendorSpecific_Reserved_Start = 10000, + Prop_VendorSpecific_Reserved_End = 10999, + Prop_TrackedDeviceProperty_Max = 1000000, +} +public enum ETrackedPropertyError +{ + TrackedProp_Success = 0, + TrackedProp_WrongDataType = 1, + TrackedProp_WrongDeviceClass = 2, + TrackedProp_BufferTooSmall = 3, + TrackedProp_UnknownProperty = 4, + TrackedProp_InvalidDevice = 5, + TrackedProp_CouldNotContactServer = 6, + TrackedProp_ValueNotProvidedByDevice = 7, + TrackedProp_StringExceedsMaximumLength = 8, + TrackedProp_NotYetAvailable = 9, + TrackedProp_PermissionDenied = 10, + TrackedProp_InvalidOperation = 11, + TrackedProp_CannotWriteToWildcards = 12, + TrackedProp_IPCReadFailure = 13, +} +public enum 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, +} +public enum EVRState +{ + Undefined = -1, + Off = 0, + Searching = 1, + Searching_Alert = 2, + Ready = 3, + Ready_Alert = 4, + NotReady = 5, + Standby = 6, + Ready_Alert_Low = 7, +} +public enum EVREventType +{ + VREvent_None = 0, + VREvent_TrackedDeviceActivated = 100, + VREvent_TrackedDeviceDeactivated = 101, + VREvent_TrackedDeviceUpdated = 102, + VREvent_TrackedDeviceUserInteractionStarted = 103, + VREvent_TrackedDeviceUserInteractionEnded = 104, + VREvent_IpdChanged = 105, + VREvent_EnterStandbyMode = 106, + VREvent_LeaveStandbyMode = 107, + VREvent_TrackedDeviceRoleChanged = 108, + VREvent_WatchdogWakeUpRequested = 109, + VREvent_LensDistortionChanged = 110, + VREvent_PropertyChanged = 111, + VREvent_WirelessDisconnect = 112, + VREvent_WirelessReconnect = 113, + VREvent_ButtonPress = 200, + VREvent_ButtonUnpress = 201, + VREvent_ButtonTouch = 202, + VREvent_ButtonUntouch = 203, + VREvent_DualAnalog_Press = 250, + VREvent_DualAnalog_Unpress = 251, + VREvent_DualAnalog_Touch = 252, + VREvent_DualAnalog_Untouch = 253, + VREvent_DualAnalog_Move = 254, + VREvent_DualAnalog_ModeSwitch1 = 255, + VREvent_DualAnalog_ModeSwitch2 = 256, + VREvent_DualAnalog_Cancel = 257, + VREvent_MouseMove = 300, + VREvent_MouseButtonDown = 301, + VREvent_MouseButtonUp = 302, + VREvent_FocusEnter = 303, + VREvent_FocusLeave = 304, + VREvent_ScrollDiscrete = 305, + VREvent_TouchPadMove = 306, + VREvent_OverlayFocusChanged = 307, + VREvent_ReloadOverlays = 308, + VREvent_ScrollSmooth = 309, + VREvent_InputFocusCaptured = 400, + VREvent_InputFocusReleased = 401, + VREvent_SceneFocusLost = 402, + VREvent_SceneFocusGained = 403, + VREvent_SceneApplicationChanged = 404, + VREvent_SceneFocusChanged = 405, + VREvent_InputFocusChanged = 406, + VREvent_SceneApplicationSecondaryRenderingStarted = 407, + VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, + VREvent_ActionBindingReloaded = 409, + VREvent_HideRenderModels = 410, + VREvent_ShowRenderModels = 411, + VREvent_ConsoleOpened = 420, + VREvent_ConsoleClosed = 421, + VREvent_OverlayShown = 500, + VREvent_OverlayHidden = 501, + VREvent_DashboardActivated = 502, + VREvent_DashboardDeactivated = 503, + VREvent_DashboardRequested = 505, + VREvent_ResetDashboard = 506, + VREvent_RenderToast = 507, + VREvent_ImageLoaded = 508, + VREvent_ShowKeyboard = 509, + VREvent_HideKeyboard = 510, + VREvent_OverlayGamepadFocusGained = 511, + VREvent_OverlayGamepadFocusLost = 512, + VREvent_OverlaySharedTextureChanged = 513, + VREvent_ScreenshotTriggered = 516, + VREvent_ImageFailed = 517, + VREvent_DashboardOverlayCreated = 518, + VREvent_SwitchGamepadFocus = 519, + VREvent_RequestScreenshot = 520, + VREvent_ScreenshotTaken = 521, + VREvent_ScreenshotFailed = 522, + VREvent_SubmitScreenshotToDashboard = 523, + VREvent_ScreenshotProgressToDashboard = 524, + VREvent_PrimaryDashboardDeviceChanged = 525, + VREvent_RoomViewShown = 526, + VREvent_RoomViewHidden = 527, + VREvent_ShowUI = 528, + VREvent_ShowDevTools = 529, + VREvent_Notification_Shown = 600, + VREvent_Notification_Hidden = 601, + VREvent_Notification_BeginInteraction = 602, + VREvent_Notification_Destroyed = 603, + VREvent_Quit = 700, + VREvent_ProcessQuit = 701, + VREvent_QuitAborted_UserPrompt = 702, + VREvent_QuitAcknowledged = 703, + VREvent_DriverRequestedQuit = 704, + VREvent_RestartRequested = 705, + VREvent_ChaperoneDataHasChanged = 800, + VREvent_ChaperoneUniverseHasChanged = 801, + VREvent_ChaperoneTempDataHasChanged = 802, + VREvent_ChaperoneSettingsHaveChanged = 803, + VREvent_SeatedZeroPoseReset = 804, + VREvent_ChaperoneFlushCache = 805, + VREvent_ChaperoneRoomSetupStarting = 806, + VREvent_ChaperoneRoomSetupFinished = 807, + VREvent_AudioSettingsHaveChanged = 820, + VREvent_BackgroundSettingHasChanged = 850, + VREvent_CameraSettingsHaveChanged = 851, + VREvent_ReprojectionSettingHasChanged = 852, + VREvent_ModelSkinSettingsHaveChanged = 853, + VREvent_EnvironmentSettingsHaveChanged = 854, + VREvent_PowerSettingsHaveChanged = 855, + VREvent_EnableHomeAppSettingsHaveChanged = 856, + VREvent_SteamVRSectionSettingChanged = 857, + VREvent_LighthouseSectionSettingChanged = 858, + VREvent_NullSectionSettingChanged = 859, + VREvent_UserInterfaceSectionSettingChanged = 860, + VREvent_NotificationsSectionSettingChanged = 861, + VREvent_KeyboardSectionSettingChanged = 862, + VREvent_PerfSectionSettingChanged = 863, + VREvent_DashboardSectionSettingChanged = 864, + VREvent_WebInterfaceSectionSettingChanged = 865, + VREvent_TrackersSectionSettingChanged = 866, + VREvent_LastKnownSectionSettingChanged = 867, + VREvent_DismissedWarningsSectionSettingChanged = 868, + VREvent_StatusUpdate = 900, + VREvent_WebInterface_InstallDriverCompleted = 950, + VREvent_MCImageUpdated = 1000, + VREvent_FirmwareUpdateStarted = 1100, + VREvent_FirmwareUpdateFinished = 1101, + VREvent_KeyboardClosed = 1200, + VREvent_KeyboardCharInput = 1201, + VREvent_KeyboardDone = 1202, + VREvent_ApplicationTransitionStarted = 1300, + VREvent_ApplicationTransitionAborted = 1301, + VREvent_ApplicationTransitionNewAppStarted = 1302, + VREvent_ApplicationListUpdated = 1303, + VREvent_ApplicationMimeTypeLoad = 1304, + VREvent_ApplicationTransitionNewAppLaunchComplete = 1305, + VREvent_ProcessConnected = 1306, + VREvent_ProcessDisconnected = 1307, + VREvent_Compositor_MirrorWindowShown = 1400, + VREvent_Compositor_MirrorWindowHidden = 1401, + VREvent_Compositor_ChaperoneBoundsShown = 1410, + VREvent_Compositor_ChaperoneBoundsHidden = 1411, + VREvent_Compositor_DisplayDisconnected = 1412, + VREvent_Compositor_DisplayReconnected = 1413, + VREvent_Compositor_HDCPError = 1414, + VREvent_Compositor_ApplicationNotResponding = 1415, + VREvent_Compositor_ApplicationResumed = 1416, + VREvent_Compositor_OutOfVideoMemory = 1417, + VREvent_TrackedCamera_StartVideoStream = 1500, + VREvent_TrackedCamera_StopVideoStream = 1501, + VREvent_TrackedCamera_PauseVideoStream = 1502, + VREvent_TrackedCamera_ResumeVideoStream = 1503, + VREvent_TrackedCamera_EditingSurface = 1550, + VREvent_PerformanceTest_EnableCapture = 1600, + VREvent_PerformanceTest_DisableCapture = 1601, + VREvent_PerformanceTest_FidelityLevel = 1602, + VREvent_MessageOverlay_Closed = 1650, + VREvent_MessageOverlayCloseRequested = 1651, + VREvent_Input_HapticVibration = 1700, + VREvent_Input_BindingLoadFailed = 1701, + VREvent_Input_BindingLoadSuccessful = 1702, + VREvent_Input_ActionManifestReloaded = 1703, + VREvent_Input_ActionManifestLoadFailed = 1704, + VREvent_Input_ProgressUpdate = 1705, + VREvent_Input_TrackerActivated = 1706, + VREvent_Input_BindingsUpdated = 1707, + VREvent_SpatialAnchors_PoseUpdated = 1800, + VREvent_SpatialAnchors_DescriptorUpdated = 1801, + VREvent_SpatialAnchors_RequestPoseUpdate = 1802, + VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, + VREvent_SystemReport_Started = 1900, + VREvent_VendorSpecific_Reserved_Start = 10000, + VREvent_VendorSpecific_Reserved_End = 19999, +} +public enum EDeviceActivityLevel +{ + k_EDeviceActivityLevel_Unknown = -1, + k_EDeviceActivityLevel_Idle = 0, + k_EDeviceActivityLevel_UserInteraction = 1, + k_EDeviceActivityLevel_UserInteraction_Timeout = 2, + k_EDeviceActivityLevel_Standby = 3, +} +public enum EVRButtonId +{ + k_EButton_System = 0, + k_EButton_ApplicationMenu = 1, + k_EButton_Grip = 2, + k_EButton_DPad_Left = 3, + k_EButton_DPad_Up = 4, + k_EButton_DPad_Right = 5, + k_EButton_DPad_Down = 6, + k_EButton_A = 7, + k_EButton_ProximitySensor = 31, + k_EButton_Axis0 = 32, + k_EButton_Axis1 = 33, + k_EButton_Axis2 = 34, + k_EButton_Axis3 = 35, + k_EButton_Axis4 = 36, + k_EButton_SteamVR_Touchpad = 32, + k_EButton_SteamVR_Trigger = 33, + k_EButton_Dashboard_Back = 2, + k_EButton_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 EDualAnalogWhich +{ + k_EDualAnalog_Left = 0, + k_EDualAnalog_Right = 1, +} +public enum EShowUIType +{ + ShowUI_ControllerBinding = 0, + ShowUI_ManageTrackers = 1, + ShowUI_Pairing = 3, + ShowUI_Settings = 4, + ShowUI_DebugCommands = 5, +} +public enum EHDCPError +{ + None = 0, + LinkLost = 1, + Tampered = 2, + DeviceRevoked = 3, + Unknown = 4, +} +public enum EVRInputError +{ + None = 0, + NameNotFound = 1, + WrongType = 2, + InvalidHandle = 3, + InvalidParam = 4, + NoSteam = 5, + MaxCapacityReached = 6, + IPCError = 7, + NoActiveActionSet = 8, + InvalidDevice = 9, + InvalidSkeleton = 10, + InvalidBoneCount = 11, + InvalidCompressedData = 12, + NoData = 13, + BufferTooSmall = 14, + MismatchedActionManifest = 15, + MissingSkeletonData = 16, + InvalidBoneIndex = 17, +} +public enum EVRSpatialAnchorError +{ + Success = 0, + Internal = 1, + UnknownHandle = 2, + ArrayTooSmall = 3, + InvalidDescriptorChar = 4, + NotYetAvailable = 5, + NotAvailableInThisUniverse = 6, + PermanentlyUnavailable = 7, + WrongDriver = 8, + DescriptorTooLong = 9, + Unknown = 10, + NoRoomCalibration = 11, + InvalidArgument = 12, + UnknownDriver = 13, +} +public enum EHiddenAreaMeshType +{ + k_eHiddenAreaMesh_Standard = 0, + k_eHiddenAreaMesh_Inverse = 1, + k_eHiddenAreaMesh_LineLoop = 2, + k_eHiddenAreaMesh_Max = 3, +} +public enum EVRControllerAxisType +{ + k_eControllerAxis_None = 0, + k_eControllerAxis_TrackPad = 1, + k_eControllerAxis_Joystick = 2, + k_eControllerAxis_Trigger = 3, +} +public enum EVRControllerEventOutputType +{ + ControllerEventOutput_OSEvents = 0, + ControllerEventOutput_VREvents = 1, +} +public enum ECollisionBoundsStyle +{ + COLLISION_BOUNDS_STYLE_BEGINNER = 0, + COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1, + COLLISION_BOUNDS_STYLE_SQUARES = 2, + COLLISION_BOUNDS_STYLE_ADVANCED = 3, + COLLISION_BOUNDS_STYLE_NONE = 4, + COLLISION_BOUNDS_STYLE_COUNT = 5, +} +public enum EVROverlayError +{ + None = 0, + UnknownOverlay = 10, + InvalidHandle = 11, + PermissionDenied = 12, + OverlayLimitExceeded = 13, + WrongVisibilityType = 14, + KeyTooLong = 15, + NameTooLong = 16, + KeyInUse = 17, + WrongTransformType = 18, + InvalidTrackedDevice = 19, + InvalidParameter = 20, + ThumbnailCantBeDestroyed = 21, + ArrayTooSmall = 22, + RequestFailed = 23, + InvalidTexture = 24, + UnableToLoadFile = 25, + KeyboardAlreadyInUse = 26, + NoNeighbor = 27, + TooManyMaskPrimitives = 29, + BadMaskPrimitive = 30, + TextureAlreadyLocked = 31, + TextureLockCapacityReached = 32, + TextureNotLocked = 33, +} +public enum EVRApplicationType +{ + VRApplication_Other = 0, + VRApplication_Scene = 1, + VRApplication_Overlay = 2, + VRApplication_Background = 3, + VRApplication_Utility = 4, + VRApplication_VRMonitor = 5, + VRApplication_SteamWatchdog = 6, + VRApplication_Bootstrapper = 7, + VRApplication_WebHelper = 8, + VRApplication_Max = 9, +} +public enum EVRFirmwareError +{ + None = 0, + Success = 1, + Fail = 2, +} +public enum EVRNotificationError +{ + OK = 0, + InvalidNotificationId = 100, + NotificationQueueFull = 101, + InvalidOverlayHandle = 102, + SystemWithUserValueAlreadyExists = 103, +} +public enum EVRSkeletalMotionRange +{ + WithController = 0, + WithoutController = 1, +} +public enum EVRSkeletalTrackingLevel +{ + VRSkeletalTracking_Estimated = 0, + VRSkeletalTracking_Partial = 1, + VRSkeletalTracking_Full = 2, + Count = 3, + Max = 2, +} +public enum EVRInitError +{ + None = 0, + Unknown = 1, + Init_InstallationNotFound = 100, + Init_InstallationCorrupt = 101, + Init_VRClientDLLNotFound = 102, + Init_FileNotFound = 103, + Init_FactoryNotFound = 104, + Init_InterfaceNotFound = 105, + Init_InvalidInterface = 106, + Init_UserConfigDirectoryInvalid = 107, + Init_HmdNotFound = 108, + Init_NotInitialized = 109, + Init_PathRegistryNotFound = 110, + Init_NoConfigPath = 111, + Init_NoLogPath = 112, + Init_PathRegistryNotWritable = 113, + Init_AppInfoInitFailed = 114, + Init_Retry = 115, + Init_InitCanceledByUser = 116, + Init_AnotherAppLaunching = 117, + Init_SettingsInitFailed = 118, + Init_ShuttingDown = 119, + Init_TooManyObjects = 120, + Init_NoServerForBackgroundApp = 121, + Init_NotSupportedWithCompositor = 122, + Init_NotAvailableToUtilityApps = 123, + Init_Internal = 124, + Init_HmdDriverIdIsNone = 125, + Init_HmdNotFoundPresenceFailed = 126, + Init_VRMonitorNotFound = 127, + Init_VRMonitorStartupFailed = 128, + Init_LowPowerWatchdogNotSupported = 129, + Init_InvalidApplicationType = 130, + Init_NotAvailableToWatchdogApps = 131, + Init_WatchdogDisabledInSettings = 132, + Init_VRDashboardNotFound = 133, + Init_VRDashboardStartupFailed = 134, + Init_VRHomeNotFound = 135, + Init_VRHomeStartupFailed = 136, + Init_RebootingBusy = 137, + Init_FirmwareUpdateBusy = 138, + Init_FirmwareRecoveryBusy = 139, + Init_USBServiceBusy = 140, + Init_VRWebHelperStartupFailed = 141, + Init_TrackerManagerInitFailed = 142, + Init_AlreadyRunning = 143, + Init_FailedForVrMonitor = 144, + Init_PropertyManagerInitFailed = 145, + 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_CreateOverlayVertextBuffer = 480, + Compositor_CreateTextVertexBuffer = 481, + Compositor_CreateTextIndexBuffer = 482, + Compositor_CreateMirrorTextures = 483, + Compositor_CreateLastFrameRenderTexture = 484, + Compositor_CreateMirrorOverlay = 485, + Compositor_FailedToCreateVirtualDisplayBackbuffer = 486, + 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, +} +public enum EVRApplicationProperty +{ + Name_String = 0, + LaunchType_String = 11, + WorkingDirectory_String = 12, + BinaryPath_String = 13, + Arguments_String = 14, + URL_String = 15, + Description_String = 50, + NewsURL_String = 51, + ImagePath_String = 52, + Source_String = 53, + ActionManifestURL_String = 54, + IsDashboardOverlay_Bool = 60, + IsTemplate_Bool = 61, + IsInstanced_Bool = 62, + IsInternal_Bool = 63, + WantsCompositorPauseInStandby_Bool = 64, + LastLaunchTime_Uint64 = 70, +} +public enum EVRApplicationTransitionState +{ + VRApplicationTransition_None = 0, + VRApplicationTransition_OldAppQuitSent = 10, + VRApplicationTransition_WaitingForExternalLaunch = 11, + VRApplicationTransition_NewAppLaunched = 20, +} +public enum ChaperoneCalibrationState +{ + OK = 1, + Warning = 100, + Warning_BaseStationMayHaveMoved = 101, + Warning_BaseStationRemoved = 102, + Warning_SeatedBoundsInvalid = 103, + Error = 200, + Error_BaseStationUninitialized = 201, + Error_BaseStationConflict = 202, + Error_PlayAreaInvalid = 203, + Error_CollisionBoundsInvalid = 204, +} +public enum EChaperoneConfigFile +{ + Live = 1, + Temp = 2, +} +public enum EChaperoneImportFlags +{ + EChaperoneImport_BoundsOnly = 1, +} +public enum EVRCompositorError +{ + None = 0, + RequestFailed = 1, + IncompatibleVersion = 100, + DoNotHaveFocus = 101, + InvalidTexture = 102, + IsNotSceneApplication = 103, + TextureIsOnWrongDevice = 104, + TextureUsesUnsupportedFormat = 105, + SharedTexturesNotSupported = 106, + IndexOutOfRange = 107, + AlreadySubmitted = 108, + InvalidBounds = 109, +} +public enum EVRCompositorTimingMode +{ + Implicit = 0, + Explicit_RuntimePerformsPostPresentHandoff = 1, + Explicit_ApplicationPerformsPostPresentHandoff = 2, +} +public enum VROverlayInputMethod +{ + None = 0, + Mouse = 1, + DualAnalog = 2, +} +public enum VROverlayTransformType +{ + VROverlayTransform_Absolute = 0, + VROverlayTransform_TrackedDeviceRelative = 1, + VROverlayTransform_SystemOverlay = 2, + VROverlayTransform_TrackedComponent = 3, +} +public enum VROverlayFlags +{ + None = 0, + Curved = 1, + RGSS4X = 2, + NoDashboardTab = 3, + AcceptsGamepadEvents = 4, + ShowGamepadFocus = 5, + SendVRDiscreteScrollEvents = 6, + SendVRTouchpadEvents = 7, + ShowTouchPadScrollWheel = 8, + TransferOwnershipToInternalProcess = 9, + SideBySide_Parallel = 10, + SideBySide_Crossed = 11, + Panorama = 12, + StereoPanorama = 13, + SortWithNonSceneOverlays = 14, + VisibleInDashboard = 15, + MakeOverlaysInteractiveIfVisible = 16, + SendVRSmoothScrollEvents = 17, + ProtectedContent = 18, +} +public enum VRMessageOverlayResponse +{ + ButtonPress_0 = 0, + ButtonPress_1 = 1, + ButtonPress_2 = 2, + ButtonPress_3 = 3, + CouldntFindSystemOverlay = 4, + CouldntFindOrCreateClientOverlay = 5, + ApplicationQuit = 6, +} +public enum EGamepadTextInputMode +{ + k_EGamepadTextInputModeNormal = 0, + k_EGamepadTextInputModePassword = 1, + k_EGamepadTextInputModeSubmit = 2, +} +public enum EGamepadTextInputLineMode +{ + k_EGamepadTextInputLineModeSingleLine = 0, + k_EGamepadTextInputLineModeMultipleLines = 1, +} +public enum EOverlayDirection +{ + Up = 0, + Down = 1, + Left = 2, + Right = 3, + Count = 4, +} +public enum EVROverlayIntersectionMaskPrimitiveType +{ + OverlayIntersectionPrimitiveType_Rectangle = 0, + OverlayIntersectionPrimitiveType_Circle = 1, +} +public enum EVRRenderModelError +{ + None = 0, + Loading = 100, + NotSupported = 200, + InvalidArg = 300, + InvalidModel = 301, + NoShapes = 302, + MultipleShapes = 303, + TooManyVertices = 304, + MultipleTextures = 305, + BufferTooSmall = 306, + NotEnoughNormals = 307, + NotEnoughTexCoords = 308, + InvalidTexture = 400, +} +public enum EVRComponentProperty +{ + IsStatic = 1, + IsVisible = 2, + IsTouched = 4, + IsPressed = 8, + IsScrolled = 16, +} +public enum EVRNotificationType +{ + Transient = 0, + Persistent = 1, + Transient_SystemWithUserValue = 2, +} +public enum EVRNotificationStyle +{ + None = 0, + Application = 100, + Contact_Disabled = 200, + Contact_Enabled = 201, + Contact_Active = 202, +} +public enum EVRSettingsError +{ + None = 0, + IPCFailed = 1, + WriteFailed = 2, + ReadFailed = 3, + JsonParseFailed = 4, + UnsetSettingHasNoDefault = 5, +} +public enum EVRScreenshotError +{ + None = 0, + RequestFailed = 1, + IncompatibleVersion = 100, + NotFound = 101, + BufferTooSmall = 102, + ScreenshotAlreadyInProgress = 108, +} +public enum EVRSkeletalTransformSpace +{ + Model = 0, + Parent = 1, +} +public enum EVRSkeletalReferencePose +{ + BindPose = 0, + OpenHand = 1, + Fist = 2, + GripLimit = 3, +} +public enum EVRFinger +{ + Thumb = 0, + Index = 1, + Middle = 2, + Ring = 3, + Pinky = 4, + Count = 5, +} +public enum EVRFingerSplay +{ + Thumb_Index = 0, + Index_Middle = 1, + Middle_Ring = 2, + Ring_Pinky = 3, + Count = 4, +} +public enum 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, +} + +[StructLayout(LayoutKind.Explicit)] public struct VREvent_Data_t +{ + [FieldOffset(0)] public VREvent_Reserved_t reserved; + [FieldOffset(0)] public VREvent_Controller_t controller; + [FieldOffset(0)] public VREvent_Mouse_t mouse; + [FieldOffset(0)] public VREvent_Scroll_t scroll; + [FieldOffset(0)] public VREvent_Process_t process; + [FieldOffset(0)] public VREvent_Notification_t notification; + [FieldOffset(0)] public VREvent_Overlay_t overlay; + [FieldOffset(0)] public VREvent_Status_t status; + [FieldOffset(0)] public VREvent_Ipd_t ipd; + [FieldOffset(0)] public VREvent_Chaperone_t chaperone; + [FieldOffset(0)] public VREvent_PerformanceTest_t performanceTest; + [FieldOffset(0)] public VREvent_TouchPadMove_t touchPadMove; + [FieldOffset(0)] public VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + [FieldOffset(0)] public VREvent_Screenshot_t screenshot; + [FieldOffset(0)] public VREvent_ScreenshotProgress_t screenshotProgress; + [FieldOffset(0)] public VREvent_ApplicationLaunch_t applicationLaunch; + [FieldOffset(0)] public VREvent_EditingCameraSurface_t cameraSurface; + [FieldOffset(0)] public VREvent_MessageOverlay_t messageOverlay; + [FieldOffset(0)] public VREvent_Property_t property; + [FieldOffset(0)] public VREvent_DualAnalog_t dualAnalog; + [FieldOffset(0)] public VREvent_HapticVibration_t hapticVibration; + [FieldOffset(0)] public VREvent_WebConsole_t webConsole; + [FieldOffset(0)] public VREvent_InputBindingLoad_t inputBinding; + [FieldOffset(0)] public VREvent_SpatialAnchor_t spatialAnchor; + [FieldOffset(0)] public VREvent_InputActionManifestLoad_t actionManifest; + [FieldOffset(0)] public VREvent_ProgressUpdate_t progressUpdate; + [FieldOffset(0)] public VREvent_ShowUI_t showUi; + [FieldOffset(0)] public VREvent_ShowDevTools_t showDevTools; + [FieldOffset(0)] public VREvent_HDCPError_t hdcpError; + [FieldOffset(0)] public VREvent_Keyboard_t keyboard; // This has to be at the end due to a mono bug +} + + +[StructLayout(LayoutKind.Explicit)] public struct VROverlayIntersectionMaskPrimitive_Data_t +{ + [FieldOffset(0)] public IntersectionMaskRectangle_t m_Rectangle; + [FieldOffset(0)] public IntersectionMaskCircle_t m_Circle; +} + +[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix34_t +{ + public float m0; //float[3][4] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + public float m9; + public float m10; + public float m11; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix33_t +{ + public float m0; //float[3][3] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix44_t +{ + public float m0; //float[4][4] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + public float m9; + public float m10; + public float m11; + public float m12; + public float m13; + public float m14; + public float m15; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdVector3_t +{ + public float v0; //float[3] + public float v1; + public float v2; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdVector4_t +{ + public float v0; //float[4] + public float v1; + public float v2; + public float v3; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdVector3d_t +{ + public double v0; //double[3] + public double v1; + public double v2; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdVector2_t +{ + public float v0; //float[2] + public float v1; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdQuaternion_t +{ + public double w; + public double x; + public double y; + public double z; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdQuaternionf_t +{ + public float w; + public float x; + public float y; + public float z; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdColor_t +{ + public float r; + public float g; + public float b; + public float a; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdQuad_t +{ + public HmdVector3_t vCorners0; //HmdVector3_t[4] + public HmdVector3_t vCorners1; + public HmdVector3_t vCorners2; + public HmdVector3_t vCorners3; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdRect2_t +{ + public HmdVector2_t vTopLeft; + public HmdVector2_t vBottomRight; +} +[StructLayout(LayoutKind.Sequential)] public struct DistortionCoordinates_t +{ + public float rfRed0; //float[2] + public float rfRed1; + public float rfGreen0; //float[2] + public float rfGreen1; + public float rfBlue0; //float[2] + public float rfBlue1; +} +[StructLayout(LayoutKind.Sequential)] public struct Texture_t +{ + public IntPtr handle; // void * + public ETextureType eType; + public EColorSpace eColorSpace; +} +[StructLayout(LayoutKind.Sequential)] public struct TrackedDevicePose_t +{ + public HmdMatrix34_t mDeviceToAbsoluteTracking; + public HmdVector3_t vVelocity; + public HmdVector3_t vAngularVelocity; + public ETrackingResult eTrackingResult; + [MarshalAs(UnmanagedType.I1)] + public bool bPoseIsValid; + [MarshalAs(UnmanagedType.I1)] + public bool bDeviceIsConnected; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureBounds_t +{ + public float uMin; + public float vMin; + public float uMax; + public float vMax; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithPose_t +{ + public HmdMatrix34_t mDeviceToAbsoluteTracking; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureDepthInfo_t +{ + public IntPtr handle; // void * + public HmdMatrix44_t mProjection; + public HmdVector2_t vRange; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithDepth_t +{ + public VRTextureDepthInfo_t depth; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithPoseAndDepth_t +{ + public VRTextureDepthInfo_t depth; +} +[StructLayout(LayoutKind.Sequential)] public struct VRVulkanTextureData_t +{ + public ulong m_nImage; + public IntPtr m_pDevice; // struct VkDevice_T * + public IntPtr m_pPhysicalDevice; // struct VkPhysicalDevice_T * + public IntPtr m_pInstance; // struct VkInstance_T * + public IntPtr m_pQueue; // struct VkQueue_T * + public uint m_nQueueFamilyIndex; + public uint m_nWidth; + public uint m_nHeight; + public uint m_nFormat; + public uint m_nSampleCount; +} +[StructLayout(LayoutKind.Sequential)] public struct D3D12TextureData_t +{ + public IntPtr m_pResource; // struct ID3D12Resource * + public IntPtr m_pCommandQueue; // struct ID3D12CommandQueue * + public uint m_nNodeMask; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Controller_t +{ + public uint button; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Mouse_t +{ + public float x; + public float y; + public uint button; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Scroll_t +{ + public float xdelta; + public float ydelta; + public uint unused; + public float viewportscale; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_TouchPadMove_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bFingerDown; + public float flSecondsFingerDown; + public float fValueXFirst; + public float fValueYFirst; + public float fValueXRaw; + public float fValueYRaw; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Notification_t +{ + public ulong ulUserValue; + public uint notificationId; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Process_t +{ + public uint pid; + public uint oldPid; + [MarshalAs(UnmanagedType.I1)] + public bool bForced; + [MarshalAs(UnmanagedType.I1)] + public bool bConnectionLost; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Overlay_t +{ + public ulong overlayHandle; + public ulong devicePath; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Status_t +{ + public uint statusState; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Keyboard_t +{ + public byte cNewInput0,cNewInput1,cNewInput2,cNewInput3,cNewInput4,cNewInput5,cNewInput6,cNewInput7; + public string cNewInput + { + get + { + return new string(new char[] { + (char)cNewInput0, + (char)cNewInput1, + (char)cNewInput2, + (char)cNewInput3, + (char)cNewInput4, + (char)cNewInput5, + (char)cNewInput6, + (char)cNewInput7 + }).TrimEnd('\0'); + } + } + public ulong uUserValue; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Ipd_t +{ + public float ipdMeters; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Chaperone_t +{ + public ulong m_nPreviousUniverse; + public ulong m_nCurrentUniverse; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Reserved_t +{ + public ulong reserved0; + public ulong reserved1; + public ulong reserved2; + public ulong reserved3; + public ulong reserved4; + public ulong reserved5; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_PerformanceTest_t +{ + public uint m_nFidelityLevel; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_SeatedZeroPoseReset_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bResetBySystemMenu; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Screenshot_t +{ + public uint handle; + public uint type; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ScreenshotProgress_t +{ + public float progress; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ApplicationLaunch_t +{ + public uint pid; + public uint unArgsHandle; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_EditingCameraSurface_t +{ + public ulong overlayHandle; + public uint nVisualMode; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_MessageOverlay_t +{ + public uint unVRMessageOverlayResponse; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Property_t +{ + public ulong container; + public ETrackedDeviceProperty prop; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_DualAnalog_t +{ + public float x; + public float y; + public float transformedX; + public float transformedY; + public EDualAnalogWhich which; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_HapticVibration_t +{ + public ulong containerHandle; + public ulong componentHandle; + public float fDurationSeconds; + public float fFrequency; + public float fAmplitude; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_WebConsole_t +{ + public ulong webConsoleHandle; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_InputBindingLoad_t +{ + public ulong ulAppContainer; + public ulong pathMessage; + public ulong pathUrl; + public ulong pathControllerType; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_InputActionManifestLoad_t +{ + public ulong pathAppKey; + public ulong pathMessage; + public ulong pathMessageParam; + public ulong pathManifestPath; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_SpatialAnchor_t +{ + public uint unHandle; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ProgressUpdate_t +{ + public ulong ulApplicationPropertyContainer; + public ulong pathDevice; + public ulong pathInputSource; + public ulong pathProgressAction; + public ulong pathIcon; + public float fProgress; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ShowUI_t +{ + public EShowUIType eType; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ShowDevTools_t +{ + public int nBrowserIdentifier; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_HDCPError_t +{ + public EHDCPError eCode; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_t +{ + public uint eventType; + public uint trackedDeviceIndex; + public float eventAgeSeconds; + public VREvent_Data_t data; +} +// This structure is for backwards binary compatibility on Linux and OSX only +[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct VREvent_t_Packed +{ + public uint eventType; + public uint trackedDeviceIndex; + public float eventAgeSeconds; + public VREvent_Data_t data; + public VREvent_t_Packed(VREvent_t unpacked) + { + this.eventType = unpacked.eventType; + this.trackedDeviceIndex = unpacked.trackedDeviceIndex; + this.eventAgeSeconds = unpacked.eventAgeSeconds; + this.data = unpacked.data; + } + public void Unpack(ref VREvent_t unpacked) + { + unpacked.eventType = this.eventType; + unpacked.trackedDeviceIndex = this.trackedDeviceIndex; + unpacked.eventAgeSeconds = this.eventAgeSeconds; + unpacked.data = this.data; + } +} +[StructLayout(LayoutKind.Sequential)] public struct HiddenAreaMesh_t +{ + public IntPtr pVertexData; // const struct vr::HmdVector2_t * + public uint unTriangleCount; +} +[StructLayout(LayoutKind.Sequential)] public struct VRControllerAxis_t +{ + public float x; + public float y; +} +[StructLayout(LayoutKind.Sequential)] public struct VRControllerState_t +{ + public uint unPacketNum; + public ulong ulButtonPressed; + public ulong ulButtonTouched; + public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5] + public VRControllerAxis_t rAxis1; + public VRControllerAxis_t rAxis2; + public VRControllerAxis_t rAxis3; + public VRControllerAxis_t rAxis4; +} +// This structure is for backwards binary compatibility on Linux and OSX only +[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct VRControllerState_t_Packed +{ + public uint unPacketNum; + public ulong ulButtonPressed; + public ulong ulButtonTouched; + public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5] + public VRControllerAxis_t rAxis1; + public VRControllerAxis_t rAxis2; + public VRControllerAxis_t rAxis3; + public VRControllerAxis_t rAxis4; + public VRControllerState_t_Packed(VRControllerState_t unpacked) + { + this.unPacketNum = unpacked.unPacketNum; + this.ulButtonPressed = unpacked.ulButtonPressed; + this.ulButtonTouched = unpacked.ulButtonTouched; + this.rAxis0 = unpacked.rAxis0; + this.rAxis1 = unpacked.rAxis1; + this.rAxis2 = unpacked.rAxis2; + this.rAxis3 = unpacked.rAxis3; + this.rAxis4 = unpacked.rAxis4; + } + public void Unpack(ref VRControllerState_t unpacked) + { + unpacked.unPacketNum = this.unPacketNum; + unpacked.ulButtonPressed = this.ulButtonPressed; + unpacked.ulButtonTouched = this.ulButtonTouched; + unpacked.rAxis0 = this.rAxis0; + unpacked.rAxis1 = this.rAxis1; + unpacked.rAxis2 = this.rAxis2; + unpacked.rAxis3 = this.rAxis3; + unpacked.rAxis4 = this.rAxis4; + } +} +[StructLayout(LayoutKind.Sequential)] public struct Compositor_OverlaySettings +{ + public uint size; + [MarshalAs(UnmanagedType.I1)] + public bool curved; + [MarshalAs(UnmanagedType.I1)] + public bool antialias; + public float scale; + public float distance; + public float alpha; + public float uOffset; + public float vOffset; + public float uScale; + public float vScale; + public float gridDivs; + public float gridWidth; + public float gridScale; + public HmdMatrix44_t transform; +} +[StructLayout(LayoutKind.Sequential)] public struct VRBoneTransform_t +{ + public HmdVector4_t position; + public HmdQuaternionf_t orientation; +} +[StructLayout(LayoutKind.Sequential)] public struct CameraVideoStreamFrameHeader_t +{ + public EVRTrackedCameraFrameType eFrameType; + public uint nWidth; + public uint nHeight; + public uint nBytesPerPixel; + public uint nFrameSequence; + public TrackedDevicePose_t standingTrackedDevicePose; + public ulong ulFrameExposureTime; +} +[StructLayout(LayoutKind.Sequential)] public struct 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 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 VROverlayIntersectionParams_t +{ + public HmdVector3_t vSource; + public HmdVector3_t vDirection; + public ETrackingUniverseOrigin eOrigin; +} +[StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionResults_t +{ + public HmdVector3_t vPoint; + public HmdVector3_t vNormal; + public HmdVector2_t vUVs; + public float fDistance; +} +[StructLayout(LayoutKind.Sequential)] public struct IntersectionMaskRectangle_t +{ + public float m_flTopLeftX; + public float m_flTopLeftY; + public float m_flWidth; + public float m_flHeight; +} +[StructLayout(LayoutKind.Sequential)] public struct IntersectionMaskCircle_t +{ + public float m_flCenterX; + public float m_flCenterY; + public float m_flRadius; +} +[StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionMaskPrimitive_t +{ + public EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType; + public VROverlayIntersectionMaskPrimitive_Data_t m_Primitive; +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_ComponentState_t +{ + public HmdMatrix34_t mTrackingToComponentRenderModel; + public HmdMatrix34_t mTrackingToComponentLocal; + public uint uProperties; +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_Vertex_t +{ + public HmdVector3_t vPosition; + public HmdVector3_t vNormal; + public float rfTextureCoord0; //float[2] + public float rfTextureCoord1; +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_TextureMap_t +{ + public ushort unWidth; + public ushort unHeight; + public IntPtr rubTextureMapData; // const uint8_t * +} +// This structure is for backwards binary compatibility on Linux and OSX only +[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct RenderModel_TextureMap_t_Packed +{ + public ushort unWidth; + public ushort unHeight; + public IntPtr rubTextureMapData; // const uint8_t * + public RenderModel_TextureMap_t_Packed(RenderModel_TextureMap_t unpacked) + { + this.unWidth = unpacked.unWidth; + this.unHeight = unpacked.unHeight; + this.rubTextureMapData = unpacked.rubTextureMapData; + } + public void Unpack(ref RenderModel_TextureMap_t unpacked) + { + unpacked.unWidth = this.unWidth; + unpacked.unHeight = this.unHeight; + unpacked.rubTextureMapData = this.rubTextureMapData; + } +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_t +{ + public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t * + public uint unVertexCount; + public IntPtr rIndexData; // const uint16_t * + public uint unTriangleCount; + public int diffuseTextureId; +} +// This structure is for backwards binary compatibility on Linux and OSX only +[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct RenderModel_t_Packed +{ + public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t * + public uint unVertexCount; + public IntPtr rIndexData; // const uint16_t * + public uint unTriangleCount; + public int diffuseTextureId; + public RenderModel_t_Packed(RenderModel_t unpacked) + { + this.rVertexData = unpacked.rVertexData; + this.unVertexCount = unpacked.unVertexCount; + this.rIndexData = unpacked.rIndexData; + this.unTriangleCount = unpacked.unTriangleCount; + this.diffuseTextureId = unpacked.diffuseTextureId; + } + public void Unpack(ref RenderModel_t unpacked) + { + unpacked.rVertexData = this.rVertexData; + unpacked.unVertexCount = this.unVertexCount; + unpacked.rIndexData = this.rIndexData; + unpacked.unTriangleCount = this.unTriangleCount; + unpacked.diffuseTextureId = this.diffuseTextureId; + } +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_ControllerMode_State_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bScrollWheelVisible; +} +[StructLayout(LayoutKind.Sequential)] public struct NotificationBitmap_t +{ + public IntPtr m_pImageData; // void * + public int m_nWidth; + public int m_nHeight; + public int m_nBytesPerPixel; +} +[StructLayout(LayoutKind.Sequential)] public struct CVRSettingHelper +{ + public IntPtr m_pSettings; // class vr::IVRSettings * +} +[StructLayout(LayoutKind.Sequential)] public struct InputAnalogActionData_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + public float x; + public float y; + public float z; + public float deltaX; + public float deltaY; + public float deltaZ; + public float fUpdateTime; +} +[StructLayout(LayoutKind.Sequential)] public struct InputDigitalActionData_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + [MarshalAs(UnmanagedType.I1)] + public bool bState; + [MarshalAs(UnmanagedType.I1)] + public bool bChanged; + public float fUpdateTime; +} +[StructLayout(LayoutKind.Sequential)] public struct InputPoseActionData_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + public TrackedDevicePose_t pose; +} +[StructLayout(LayoutKind.Sequential)] public struct InputSkeletalActionData_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; +} +[StructLayout(LayoutKind.Sequential)] public struct InputOriginInfo_t +{ + public ulong devicePath; + public uint trackedDeviceIndex; + public byte rchRenderModelComponentName0,rchRenderModelComponentName1,rchRenderModelComponentName2,rchRenderModelComponentName3,rchRenderModelComponentName4,rchRenderModelComponentName5,rchRenderModelComponentName6,rchRenderModelComponentName7,rchRenderModelComponentName8,rchRenderModelComponentName9,rchRenderModelComponentName10,rchRenderModelComponentName11,rchRenderModelComponentName12,rchRenderModelComponentName13,rchRenderModelComponentName14,rchRenderModelComponentName15,rchRenderModelComponentName16,rchRenderModelComponentName17,rchRenderModelComponentName18,rchRenderModelComponentName19,rchRenderModelComponentName20,rchRenderModelComponentName21,rchRenderModelComponentName22,rchRenderModelComponentName23,rchRenderModelComponentName24,rchRenderModelComponentName25,rchRenderModelComponentName26,rchRenderModelComponentName27,rchRenderModelComponentName28,rchRenderModelComponentName29,rchRenderModelComponentName30,rchRenderModelComponentName31,rchRenderModelComponentName32,rchRenderModelComponentName33,rchRenderModelComponentName34,rchRenderModelComponentName35,rchRenderModelComponentName36,rchRenderModelComponentName37,rchRenderModelComponentName38,rchRenderModelComponentName39,rchRenderModelComponentName40,rchRenderModelComponentName41,rchRenderModelComponentName42,rchRenderModelComponentName43,rchRenderModelComponentName44,rchRenderModelComponentName45,rchRenderModelComponentName46,rchRenderModelComponentName47,rchRenderModelComponentName48,rchRenderModelComponentName49,rchRenderModelComponentName50,rchRenderModelComponentName51,rchRenderModelComponentName52,rchRenderModelComponentName53,rchRenderModelComponentName54,rchRenderModelComponentName55,rchRenderModelComponentName56,rchRenderModelComponentName57,rchRenderModelComponentName58,rchRenderModelComponentName59,rchRenderModelComponentName60,rchRenderModelComponentName61,rchRenderModelComponentName62,rchRenderModelComponentName63,rchRenderModelComponentName64,rchRenderModelComponentName65,rchRenderModelComponentName66,rchRenderModelComponentName67,rchRenderModelComponentName68,rchRenderModelComponentName69,rchRenderModelComponentName70,rchRenderModelComponentName71,rchRenderModelComponentName72,rchRenderModelComponentName73,rchRenderModelComponentName74,rchRenderModelComponentName75,rchRenderModelComponentName76,rchRenderModelComponentName77,rchRenderModelComponentName78,rchRenderModelComponentName79,rchRenderModelComponentName80,rchRenderModelComponentName81,rchRenderModelComponentName82,rchRenderModelComponentName83,rchRenderModelComponentName84,rchRenderModelComponentName85,rchRenderModelComponentName86,rchRenderModelComponentName87,rchRenderModelComponentName88,rchRenderModelComponentName89,rchRenderModelComponentName90,rchRenderModelComponentName91,rchRenderModelComponentName92,rchRenderModelComponentName93,rchRenderModelComponentName94,rchRenderModelComponentName95,rchRenderModelComponentName96,rchRenderModelComponentName97,rchRenderModelComponentName98,rchRenderModelComponentName99,rchRenderModelComponentName100,rchRenderModelComponentName101,rchRenderModelComponentName102,rchRenderModelComponentName103,rchRenderModelComponentName104,rchRenderModelComponentName105,rchRenderModelComponentName106,rchRenderModelComponentName107,rchRenderModelComponentName108,rchRenderModelComponentName109,rchRenderModelComponentName110,rchRenderModelComponentName111,rchRenderModelComponentName112,rchRenderModelComponentName113,rchRenderModelComponentName114,rchRenderModelComponentName115,rchRenderModelComponentName116,rchRenderModelComponentName117,rchRenderModelComponentName118,rchRenderModelComponentName119,rchRenderModelComponentName120,rchRenderModelComponentName121,rchRenderModelComponentName122,rchRenderModelComponentName123,rchRenderModelComponentName124,rchRenderModelComponentName125,rchRenderModelComponentName126,rchRenderModelComponentName127; + public string rchRenderModelComponentName + { + get + { + return new string(new char[] { + (char)rchRenderModelComponentName0, + (char)rchRenderModelComponentName1, + (char)rchRenderModelComponentName2, + (char)rchRenderModelComponentName3, + (char)rchRenderModelComponentName4, + (char)rchRenderModelComponentName5, + (char)rchRenderModelComponentName6, + (char)rchRenderModelComponentName7, + (char)rchRenderModelComponentName8, + (char)rchRenderModelComponentName9, + (char)rchRenderModelComponentName10, + (char)rchRenderModelComponentName11, + (char)rchRenderModelComponentName12, + (char)rchRenderModelComponentName13, + (char)rchRenderModelComponentName14, + (char)rchRenderModelComponentName15, + (char)rchRenderModelComponentName16, + (char)rchRenderModelComponentName17, + (char)rchRenderModelComponentName18, + (char)rchRenderModelComponentName19, + (char)rchRenderModelComponentName20, + (char)rchRenderModelComponentName21, + (char)rchRenderModelComponentName22, + (char)rchRenderModelComponentName23, + (char)rchRenderModelComponentName24, + (char)rchRenderModelComponentName25, + (char)rchRenderModelComponentName26, + (char)rchRenderModelComponentName27, + (char)rchRenderModelComponentName28, + (char)rchRenderModelComponentName29, + (char)rchRenderModelComponentName30, + (char)rchRenderModelComponentName31, + (char)rchRenderModelComponentName32, + (char)rchRenderModelComponentName33, + (char)rchRenderModelComponentName34, + (char)rchRenderModelComponentName35, + (char)rchRenderModelComponentName36, + (char)rchRenderModelComponentName37, + (char)rchRenderModelComponentName38, + (char)rchRenderModelComponentName39, + (char)rchRenderModelComponentName40, + (char)rchRenderModelComponentName41, + (char)rchRenderModelComponentName42, + (char)rchRenderModelComponentName43, + (char)rchRenderModelComponentName44, + (char)rchRenderModelComponentName45, + (char)rchRenderModelComponentName46, + (char)rchRenderModelComponentName47, + (char)rchRenderModelComponentName48, + (char)rchRenderModelComponentName49, + (char)rchRenderModelComponentName50, + (char)rchRenderModelComponentName51, + (char)rchRenderModelComponentName52, + (char)rchRenderModelComponentName53, + (char)rchRenderModelComponentName54, + (char)rchRenderModelComponentName55, + (char)rchRenderModelComponentName56, + (char)rchRenderModelComponentName57, + (char)rchRenderModelComponentName58, + (char)rchRenderModelComponentName59, + (char)rchRenderModelComponentName60, + (char)rchRenderModelComponentName61, + (char)rchRenderModelComponentName62, + (char)rchRenderModelComponentName63, + (char)rchRenderModelComponentName64, + (char)rchRenderModelComponentName65, + (char)rchRenderModelComponentName66, + (char)rchRenderModelComponentName67, + (char)rchRenderModelComponentName68, + (char)rchRenderModelComponentName69, + (char)rchRenderModelComponentName70, + (char)rchRenderModelComponentName71, + (char)rchRenderModelComponentName72, + (char)rchRenderModelComponentName73, + (char)rchRenderModelComponentName74, + (char)rchRenderModelComponentName75, + (char)rchRenderModelComponentName76, + (char)rchRenderModelComponentName77, + (char)rchRenderModelComponentName78, + (char)rchRenderModelComponentName79, + (char)rchRenderModelComponentName80, + (char)rchRenderModelComponentName81, + (char)rchRenderModelComponentName82, + (char)rchRenderModelComponentName83, + (char)rchRenderModelComponentName84, + (char)rchRenderModelComponentName85, + (char)rchRenderModelComponentName86, + (char)rchRenderModelComponentName87, + (char)rchRenderModelComponentName88, + (char)rchRenderModelComponentName89, + (char)rchRenderModelComponentName90, + (char)rchRenderModelComponentName91, + (char)rchRenderModelComponentName92, + (char)rchRenderModelComponentName93, + (char)rchRenderModelComponentName94, + (char)rchRenderModelComponentName95, + (char)rchRenderModelComponentName96, + (char)rchRenderModelComponentName97, + (char)rchRenderModelComponentName98, + (char)rchRenderModelComponentName99, + (char)rchRenderModelComponentName100, + (char)rchRenderModelComponentName101, + (char)rchRenderModelComponentName102, + (char)rchRenderModelComponentName103, + (char)rchRenderModelComponentName104, + (char)rchRenderModelComponentName105, + (char)rchRenderModelComponentName106, + (char)rchRenderModelComponentName107, + (char)rchRenderModelComponentName108, + (char)rchRenderModelComponentName109, + (char)rchRenderModelComponentName110, + (char)rchRenderModelComponentName111, + (char)rchRenderModelComponentName112, + (char)rchRenderModelComponentName113, + (char)rchRenderModelComponentName114, + (char)rchRenderModelComponentName115, + (char)rchRenderModelComponentName116, + (char)rchRenderModelComponentName117, + (char)rchRenderModelComponentName118, + (char)rchRenderModelComponentName119, + (char)rchRenderModelComponentName120, + (char)rchRenderModelComponentName121, + (char)rchRenderModelComponentName122, + (char)rchRenderModelComponentName123, + (char)rchRenderModelComponentName124, + (char)rchRenderModelComponentName125, + (char)rchRenderModelComponentName126, + (char)rchRenderModelComponentName127 + }).TrimEnd('\0'); + } + } +} +[StructLayout(LayoutKind.Sequential)] public struct 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'); + } + } +} +[StructLayout(LayoutKind.Sequential)] public struct VRActiveActionSet_t +{ + public ulong ulActionSet; + public ulong ulRestrictedToDevice; + public ulong ulSecondaryActionSet; + public uint unPadding; + public int nPriority; +} +[StructLayout(LayoutKind.Sequential)] public struct VRSkeletalSummaryData_t +{ + public float flFingerCurl0; //float[5] + public float flFingerCurl1; + public float flFingerCurl2; + public float flFingerCurl3; + public float flFingerCurl4; + public float flFingerSplay0; //float[4] + public float flFingerSplay1; + public float flFingerSplay2; + public float flFingerSplay3; +} +[StructLayout(LayoutKind.Sequential)] public struct SpatialAnchorPose_t +{ + public HmdMatrix34_t mAnchorToAbsoluteTracking; +} +[StructLayout(LayoutKind.Sequential)] public struct COpenVRContext +{ + public IntPtr m_pVRSystem; // class vr::IVRSystem * + public IntPtr m_pVRChaperone; // class vr::IVRChaperone * + public IntPtr m_pVRChaperoneSetup; // class vr::IVRChaperoneSetup * + public IntPtr m_pVRCompositor; // class vr::IVRCompositor * + public IntPtr m_pVROverlay; // class vr::IVROverlay * + public IntPtr m_pVRResources; // class vr::IVRResources * + public IntPtr m_pVRRenderModels; // class vr::IVRRenderModels * + public IntPtr m_pVRExtendedDisplay; // class vr::IVRExtendedDisplay * + public IntPtr m_pVRSettings; // class vr::IVRSettings * + public IntPtr m_pVRApplications; // class vr::IVRApplications * + public IntPtr m_pVRTrackedCamera; // class vr::IVRTrackedCamera * + public IntPtr m_pVRScreenshots; // class vr::IVRScreenshots * + public IntPtr m_pVRDriverManager; // class vr::IVRDriverManager * + public IntPtr m_pVRInput; // class vr::IVRInput * + public IntPtr m_pVRIOBuffer; // class vr::IVRIOBuffer * + public IntPtr m_pVRSpatialAnchors; // class vr::IVRSpatialAnchors * + public IntPtr m_pVRDebug; // class vr::IVRDebug * + public IntPtr m_pVRNotifications; // class vr::IVRNotifications * +} + +public class OpenVR +{ + + public static uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType) + { + return OpenVRInterop.InitInternal(ref peError, eApplicationType); + } + + public static uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType, string pchStartupInfo) + { + return OpenVRInterop.InitInternal2(ref peError, eApplicationType, pchStartupInfo); + } + + public static void ShutdownInternal() + { + OpenVRInterop.ShutdownInternal(); + } + + public static bool IsHmdPresent() + { + return OpenVRInterop.IsHmdPresent(); + } + + public static bool IsRuntimeInstalled() + { + return OpenVRInterop.IsRuntimeInstalled(); + } + + public static string RuntimePath() + { + return OpenVRInterop.RuntimePath(); + } + + public static string GetStringForHmdError(EVRInitError error) + { + return Marshal.PtrToStringAnsi(OpenVRInterop.GetStringForHmdError(error)); + } + + public static IntPtr GetGenericInterface(string pchInterfaceVersion, ref EVRInitError peError) + { + return OpenVRInterop.GetGenericInterface(pchInterfaceVersion, ref peError); + } + + public static bool IsInterfaceVersionValid(string pchInterfaceVersion) + { + return OpenVRInterop.IsInterfaceVersionValid(pchInterfaceVersion); + } + + public static uint GetInitToken() + { + return OpenVRInterop.GetInitToken(); + } + + public const uint k_nDriverNone = 4294967295; + public const uint k_unMaxDriverDebugResponseSize = 32768; + public const uint k_unTrackedDeviceIndex_Hmd = 0; + public const uint k_unMaxTrackedDeviceCount = 64; + public const uint k_unTrackedDeviceIndexOther = 4294967294; + public const uint k_unTrackedDeviceIndexInvalid = 4294967295; + public const ulong k_ulInvalidPropertyContainer = 0; + public const uint k_unInvalidPropertyTag = 0; + public const ulong k_ulInvalidDriverHandle = 0; + public const uint k_unFloatPropertyTag = 1; + public const uint k_unInt32PropertyTag = 2; + public const uint k_unUint64PropertyTag = 3; + public const uint k_unBoolPropertyTag = 4; + public const uint k_unStringPropertyTag = 5; + public const uint k_unHmdMatrix34PropertyTag = 20; + public const uint k_unHmdMatrix44PropertyTag = 21; + public const uint k_unHmdVector3PropertyTag = 22; + public const uint k_unHmdVector4PropertyTag = 23; + public const uint k_unHmdVector2PropertyTag = 24; + public const uint k_unHmdQuadPropertyTag = 25; + public const uint k_unHiddenAreaPropertyTag = 30; + public const uint k_unPathHandleInfoTag = 31; + public const uint k_unActionPropertyTag = 32; + public const uint k_unInputValuePropertyTag = 33; + public const uint k_unWildcardPropertyTag = 34; + public const uint k_unHapticVibrationPropertyTag = 35; + public const uint k_unSkeletonPropertyTag = 36; + public const uint k_unSpatialAnchorPosePropertyTag = 40; + public const uint k_unJsonPropertyTag = 41; + public const uint k_unActiveActionSetPropertyTag = 42; + public const uint k_unOpenVRInternalReserved_Start = 1000; + public const uint k_unOpenVRInternalReserved_End = 10000; + public const uint k_unMaxPropertyStringSize = 32768; + public const ulong k_ulInvalidActionHandle = 0; + public const ulong k_ulInvalidActionSetHandle = 0; + public const ulong k_ulInvalidInputValueHandle = 0; + public const uint k_unControllerStateAxisCount = 5; + public const ulong k_ulOverlayHandleInvalid = 0; + public const uint k_unMaxDistortionFunctionParameters = 8; + public const uint k_unScreenshotHandleInvalid = 0; + public const string IVRSystem_Version = "IVRSystem_020"; + public const string IVRExtendedDisplay_Version = "IVRExtendedDisplay_001"; + public const string IVRTrackedCamera_Version = "IVRTrackedCamera_005"; + public const uint k_unMaxApplicationKeyLength = 128; + public const string k_pch_MimeType_HomeApp = "vr/home"; + public const string k_pch_MimeType_GameTheater = "vr/game_theater"; + public const string IVRApplications_Version = "IVRApplications_006"; + public const string IVRChaperone_Version = "IVRChaperone_003"; + public const string IVRChaperoneSetup_Version = "IVRChaperoneSetup_006"; + public const string IVRCompositor_Version = "IVRCompositor_022"; + public const uint k_unVROverlayMaxKeyLength = 128; + public const uint k_unVROverlayMaxNameLength = 128; + public const uint k_unMaxOverlayCount = 64; + public const uint k_unMaxOverlayIntersectionMaskPrimitivesCount = 32; + public const string IVROverlay_Version = "IVROverlay_019"; + public const string k_pch_Controller_Component_GDC2015 = "gdc2015"; + public const string k_pch_Controller_Component_Base = "base"; + public const string k_pch_Controller_Component_Tip = "tip"; + public const string k_pch_Controller_Component_HandGrip = "handgrip"; + public const string k_pch_Controller_Component_Status = "status"; + public const string IVRRenderModels_Version = "IVRRenderModels_006"; + public const uint k_unNotificationTextMaxSize = 256; + public const string IVRNotifications_Version = "IVRNotifications_002"; + public const uint k_unMaxSettingsKeyLength = 128; + public const string IVRSettings_Version = "IVRSettings_002"; + public const string k_pch_SteamVR_Section = "steamvr"; + public const string k_pch_SteamVR_RequireHmd_String = "requireHmd"; + public const string k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver"; + public const string k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd"; + public const string k_pch_SteamVR_DisplayDebug_Bool = "displayDebug"; + public const string k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe"; + public const string k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX"; + public const string k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY"; + public const string k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps"; + public const string k_pch_SteamVR_LogLevel_Int32 = "loglevel"; + public const string k_pch_SteamVR_IPD_Float = "ipd"; + public const string k_pch_SteamVR_Background_String = "background"; + public const string k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection"; + public const string k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight"; + public const string k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius"; + public const string k_pch_SteamVR_GridColor_String = "gridColor"; + public const string k_pch_SteamVR_PlayAreaColor_String = "playAreaColor"; + public const string k_pch_SteamVR_ShowStage_Bool = "showStage"; + public const string k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers"; + public const string k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers"; + public const string k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees"; + public const string k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement"; + public const string k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses"; + public const string k_pch_SteamVR_SupersampleScale_Float = "supersampleScale"; + public const string k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution"; + public const string k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing"; + public const string k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride"; + public const string k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking"; + public const string k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView"; + public const string k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView"; + public const string k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry"; + public const string k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized"; + public const string k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch"; + public const string k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch"; + public const string k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch"; + public const string k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard"; + public const string k_pch_SteamVR_EnableHomeApp = "enableHomeApp"; + public const string k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec"; + public const string k_pch_SteamVR_RetailDemo_Bool = "retailDemo"; + public const string k_pch_SteamVR_IpdOffset_Float = "ipdOffset"; + public const string k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering"; + public const string k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride"; + public const string k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync"; + public const string k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode"; + public const string k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver"; + public const string k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor"; + public const string k_pch_SteamVR_DebugInput = "debugInput"; + public const string k_pch_SteamVR_DebugInputBinding = "debugInputBinding"; + public const string k_pch_SteamVR_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_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_Lighthouse_NewPairing_Bool = "newPairing"; + public const string k_pch_Null_Section = "driver_null"; + public const string k_pch_Null_SerialNumber_String = "serialNumber"; + public const string k_pch_Null_ModelNumber_String = "modelNumber"; + public const string k_pch_Null_WindowX_Int32 = "windowX"; + public const string k_pch_Null_WindowY_Int32 = "windowY"; + public const string k_pch_Null_WindowWidth_Int32 = "windowWidth"; + public const string k_pch_Null_WindowHeight_Int32 = "windowHeight"; + public const string k_pch_Null_RenderWidth_Int32 = "renderWidth"; + public const string k_pch_Null_RenderHeight_Int32 = "renderHeight"; + public const string k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons"; + public const string k_pch_Null_DisplayFrequency_Float = "displayFrequency"; + public const string k_pch_UserInterface_Section = "userinterface"; + public const string k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop"; + public const string k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray"; + public const string k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized"; + public const string k_pch_UserInterface_Screenshots_Bool = "screenshots"; + public const string k_pch_UserInterface_ScreenshotType_Int = "screenshotType"; + public const string k_pch_Notifications_Section = "notifications"; + public const string k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb"; + public const string k_pch_Keyboard_Section = "keyboard"; + public const string k_pch_Keyboard_TutorialCompletions = "TutorialCompletions"; + public const string k_pch_Keyboard_ScaleX = "ScaleX"; + public const string k_pch_Keyboard_ScaleY = "ScaleY"; + public const string k_pch_Keyboard_OffsetLeftX = "OffsetLeftX"; + public const string k_pch_Keyboard_OffsetRightX = "OffsetRightX"; + public const string k_pch_Keyboard_OffsetY = "OffsetY"; + public const string k_pch_Keyboard_Smoothing = "Smoothing"; + public const string k_pch_Perf_Section = "perfcheck"; + public const string k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD"; + public const string k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore"; + public const string k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit"; + public const string k_pch_Perf_TestData_Float = "perfTestData"; + public const string k_pch_Perf_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_ColorGammaR_Int32 = "CollisionBoundsColorGammaR"; + public const string k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG"; + public const string k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB"; + public const string k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA"; + public const string k_pch_Camera_Section = "camera"; + public const string k_pch_Camera_EnableCamera_Bool = "enableCamera"; + public const string k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard"; + public const string k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds"; + public const string k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView"; + public const string k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR"; + public const string k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG"; + public const string k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB"; + public const string k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA"; + public const string k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength"; + public const string k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode"; + public const string k_pch_audio_Section = "audio"; + public const string k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice"; + public const string k_pch_audio_OnRecordDevice_String = "onRecordDevice"; + public const string k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice"; + public const string k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice"; + public const string k_pch_audio_OffRecordDevice_String = "offRecordDevice"; + public const string k_pch_audio_VIVEHDMIGain = "viveHDMIGain"; + public const string k_pch_Power_Section = "power"; + public const string k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit"; + public const string k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout"; + public const string k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout"; + public const string k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout"; + public const string k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress"; + public const string k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby"; + public const string k_pch_Dashboard_Section = "dashboard"; + public const string k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard"; + public const string k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode"; + public const string k_pch_Dashboard_UseWebDashboard = "useWebDashboard"; + public const string k_pch_Dashboard_UseWebSettings = "useWebSettings"; + public const string k_pch_Dashboard_UseWebIPD = "useWebIPD"; + public const string k_pch_Dashboard_UseWebPowerMenu = "useWebPowerMenu"; + public const string k_pch_modelskin_Section = "modelskins"; + public const string k_pch_Driver_Enable_Bool = "enable"; + public const string k_pch_Driver_LoadPriority_Int32 = "loadPriority"; + public const string k_pch_WebInterface_Section = "WebInterface"; + public const string k_pch_WebInterface_WebEnable_Bool = "WebEnable"; + public const string k_pch_WebInterface_WebPort_String = "WebPort"; + public const string k_pch_VRWebHelper_Section = "VRWebHelper"; + public const string k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled"; + public const string k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort"; + public const string k_pch_TrackingOverride_Section = "TrackingOverrides"; + public const string k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL"; + public const string k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL"; + public const string k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave"; + public const string k_pch_Trackers_Section = "trackers"; + public const string k_pch_DesktopUI_Section = "DesktopUI"; + public const string k_pch_LastKnown_Section = "LastKnown"; + public const string k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer"; + public const string k_pch_LastKnown_HMDModel_String = "HMDModel"; + public const string k_pch_DismissedWarnings_Section = "DismissedWarnings"; + public const string 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 IVRScreenshots_Version = "IVRScreenshots_001"; + public const string IVRResources_Version = "IVRResources_001"; + public const string IVRDriverManager_Version = "IVRDriverManager_001"; + public const uint k_unMaxActionNameLength = 64; + public const uint k_unMaxActionSetNameLength = 64; + public const uint k_unMaxActionOriginCount = 16; + public const uint k_unMaxBoneNameLength = 32; + public const string IVRInput_Version = "IVRInput_007"; + 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"; + + static uint VRToken { get; set; } + + const string FnTable_Prefix = "FnTable:"; + + class COpenVRContext + { + public COpenVRContext() { Clear(); } + + public void Clear() + { + m_pVRSystem = null; + m_pVRChaperone = null; + m_pVRChaperoneSetup = null; + m_pVRCompositor = null; + m_pVROverlay = null; + m_pVRRenderModels = null; + m_pVRExtendedDisplay = null; + m_pVRSettings = null; + m_pVRApplications = null; + m_pVRScreenshots = null; + m_pVRTrackedCamera = null; + m_pVRInput = null; + m_pVRIOBuffer = null; + m_pVRSpatialAnchors = null; + m_pVRNotifications = null; + 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 CVROverlay VROverlay() + { + CheckClear(); + if (m_pVROverlay == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVROverlay_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVROverlay = new CVROverlay(pInterface); + } + return m_pVROverlay; + } + + public CVRRenderModels VRRenderModels() + { + CheckClear(); + if (m_pVRRenderModels == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRRenderModels_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRRenderModels = new CVRRenderModels(pInterface); + } + return m_pVRRenderModels; + } + + public CVRExtendedDisplay VRExtendedDisplay() + { + CheckClear(); + if (m_pVRExtendedDisplay == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRExtendedDisplay_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRExtendedDisplay = new CVRExtendedDisplay(pInterface); + } + return m_pVRExtendedDisplay; + } + + public CVRSettings VRSettings() + { + CheckClear(); + if (m_pVRSettings == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRSettings_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSettings = new CVRSettings(pInterface); + } + return m_pVRSettings; + } + + public CVRApplications VRApplications() + { + CheckClear(); + if (m_pVRApplications == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRApplications_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRApplications = new CVRApplications(pInterface); + } + return m_pVRApplications; + } + + public CVRScreenshots VRScreenshots() + { + CheckClear(); + if (m_pVRScreenshots == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRScreenshots_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRScreenshots = new CVRScreenshots(pInterface); + } + return m_pVRScreenshots; + } + + public CVRTrackedCamera VRTrackedCamera() + { + CheckClear(); + if (m_pVRTrackedCamera == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRTrackedCamera_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRTrackedCamera = new CVRTrackedCamera(pInterface); + } + return m_pVRTrackedCamera; + } + + public CVRInput VRInput() + { + CheckClear(); + if (m_pVRInput == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRInput_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRInput = new CVRInput(pInterface); + } + return m_pVRInput; + } + + public CVRIOBuffer VRIOBuffer() + { + CheckClear(); + if (m_pVRIOBuffer == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRIOBuffer_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRIOBuffer = new CVRIOBuffer(pInterface); + } + return m_pVRIOBuffer; + } + + public CVRSpatialAnchors VRSpatialAnchors() + { + CheckClear(); + if (m_pVRSpatialAnchors == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSpatialAnchors_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSpatialAnchors = new CVRSpatialAnchors(pInterface); + } + return m_pVRSpatialAnchors; + } + + public 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 CVROverlay m_pVROverlay; + private CVRRenderModels m_pVRRenderModels; + private CVRExtendedDisplay m_pVRExtendedDisplay; + private CVRSettings m_pVRSettings; + private CVRApplications m_pVRApplications; + private CVRScreenshots m_pVRScreenshots; + private CVRTrackedCamera m_pVRTrackedCamera; + private CVRInput m_pVRInput; + private CVRIOBuffer m_pVRIOBuffer; + private CVRSpatialAnchors m_pVRSpatialAnchors; + private CVRNotifications m_pVRNotifications; + private 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 CVROverlay Overlay { get { return OpenVRInternal_ModuleContext.VROverlay(); } } + public static CVRRenderModels RenderModels { get { return OpenVRInternal_ModuleContext.VRRenderModels(); } } + public static CVRExtendedDisplay ExtendedDisplay { get { return OpenVRInternal_ModuleContext.VRExtendedDisplay(); } } + public static CVRSettings Settings { get { return OpenVRInternal_ModuleContext.VRSettings(); } } + public static CVRApplications Applications { get { return OpenVRInternal_ModuleContext.VRApplications(); } } + public static CVRScreenshots Screenshots { get { return OpenVRInternal_ModuleContext.VRScreenshots(); } } + public static CVRTrackedCamera TrackedCamera { get { return OpenVRInternal_ModuleContext.VRTrackedCamera(); } } + public static CVRInput Input { get { return OpenVRInternal_ModuleContext.VRInput(); } } + public static CVRIOBuffer IOBuffer { get { return OpenVRInternal_ModuleContext.VRIOBuffer(); } } + public static CVRSpatialAnchors SpatialAnchors { get { return OpenVRInternal_ModuleContext.VRSpatialAnchors(); } } + public static CVRNotifications Notifications { get { return OpenVRInternal_ModuleContext.VRNotifications(); } } + public static CVRDebug Debug { get { return OpenVRInternal_ModuleContext.VRDebug(); } } + + + /** Finds the active installation of vrclient.dll and initializes it */ + public static CVRSystem Init(ref EVRInitError peError, EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene, string pchStartupInfo= "") + { + try + { + VRToken = InitInternal2(ref peError, eApplicationType, pchStartupInfo); + } + catch (EntryPointNotFoundException) + { + VRToken = InitInternal(ref peError, eApplicationType); + } + + OpenVRInternal_ModuleContext.Clear(); + + if (peError != EVRInitError.None) + return null; + + bool bInterfaceValid = IsInterfaceVersionValid(IVRSystem_Version); + if (!bInterfaceValid) + { + ShutdownInternal(); + peError = EVRInitError.Init_InterfaceNotFound; + return null; + } + + return OpenVR.System; + } + + /** unloads vrclient.dll. Any interface pointers from the interface are + * invalid after this point */ + public static void Shutdown() + { + ShutdownInternal(); + } + +} + + + +} + diff --git a/OpenVR/win32/openvr_api.dll b/OpenVR/win32/openvr_api.dll new file mode 100644 index 0000000000000000000000000000000000000000..4b06e42a7666643905f7c4e10562f1a1f88316d1 GIT binary patch literal 490784 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

9kv3?3HTM6Yma!Ou;H_z=qA|{pw&vI+-X%3v) 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 {K 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 literal 0 HcmV?d00001 diff --git a/OpenVR/win64/openvr_api.dll b/OpenVR/win64/openvr_api.dll new file mode 100644 index 0000000000000000000000000000000000000000..114a983c94811d3e7b675fdb926035b5980c526c GIT binary patch literal 598816 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 n^lGD@>kN)5xZ5. + +using CefSharp; +using CefSharp.WinForms; +using System; +using System.Windows.Forms; + +namespace VRCX +{ + public static class Program + { + [STAThread] + public static void Main() + { + var settings = new CefSettings + { + IgnoreCertificateErrors = true, + CachePath = "cache", + PersistUserPreferences = true, + PersistSessionCookies = true, + WindowlessRenderingEnabled = true + }; + settings.CefCommandLineArgs.Add("disable-web-security", "1"); + settings.CefCommandLineArgs.Add("no-proxy-server", "1"); + settings.CefCommandLineArgs.Add("disable-plugins-discovery", "1"); + settings.CefCommandLineArgs.Add("disable-extensions", "1"); + settings.CefCommandLineArgs.Add("disable-pdf-extension", "1"); + // settings.CefCommandLineArgs.Add("disable-gpu", "1"); + settings.CefCommandLineArgs.Add("disable-direct-write", "1"); + settings.LogSeverity = LogSeverity.Disable; + settings.DisableGpuAcceleration(); + /*settings.RegisterScheme(new CefCustomScheme + { + SchemeName = "vrcx", + DomainName = "app", + SchemeHandlerFactory = new FolderSchemeHandlerFactory(Application.StartupPath + "/../../../html") + });*/ + + // MUST TURN ON (Error when creating a browser on certain systems.) + CefSharpSettings.WcfEnabled = true; + + CefSharpSettings.ShutdownOnExit = false; + CefSharpSettings.SubprocessExitIfParentProcessClosed = true; + + // Cef.EnableHighDPISupport(); + + if (Cef.Initialize(settings, true, browserProcessHandler: null)) + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + CpuMonitor.Start(); + VRCXStorage.Load(); + VRCXVR.Setup(); + VRCX_LogWatcher.Start(); + Application.Run(new MainForm()); + VRCX_LogWatcher.Stop(); + VRCXVR.Stop(); + VRCXStorage.Save(); + CpuMonitor.Stop(); + Cef.Shutdown(); + } + } + } +} \ No newline at end of file diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..d3e1c8f4 --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 어셈블리에 대한 일반 정보는 다음 특성 집합을 통해 +// 제어됩니다. 어셈블리와 관련된 정보를 수정하려면 +// 이러한 특성 값을 변경하세요. +[assembly: AssemblyTitle("VRCX")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("VRCX")] +[assembly: AssemblyCopyright("pypy")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// ComVisible을 false로 설정하면 이 어셈블리의 형식이 COM 구성 요소에 +// 표시되지 않습니다. COM에서 이 어셈블리의 형식에 액세스하려면 +// 해당 형식에 대해 ComVisible 특성을 true로 설정하세요. +[assembly: ComVisible(false)] + +// 이 프로젝트가 COM에 노출되는 경우 다음 GUID는 typelib의 ID를 나타냅니다. +[assembly: Guid("d9f66f2e-3ed9-4d53-a6ac-adcc1513562a")] + +// 어셈블리의 버전 정보는 다음 네 가지 값으로 구성됩니다. +// +// 주 버전 +// 부 버전 +// 빌드 번호 +// 수정 버전 +// +// 모든 값을 지정하거나 아래와 같이 '*'를 사용하여 빌드 번호 및 수정 번호가 자동으로 +// 지정되도록 할 수 있습니다. +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs new file mode 100644 index 00000000..3b18c84d --- /dev/null +++ b/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// 이 코드는 도구를 사용하여 생성되었습니다. +// 런타임 버전:4.0.30319.42000 +// +// 파일 내용을 변경하면 잘못된 동작이 발생할 수 있으며, 코드를 다시 생성하면 +// 이러한 변경 내용이 손실됩니다. +// +//------------------------------------------------------------------------------ + +namespace VRCX.Properties +{ + + + ///

+ /// 지역화된 문자열 등을 찾기 위한 강력한 형식의 리소스 클래스입니다. + /// + // 이 클래스는 ResGen 또는 Visual Studio와 같은 도구를 통해 StronglyTypedResourceBuilder + // 클래스에서 자동으로 생성되었습니다. + // 멤버를 추가하거나 제거하려면 .ResX 파일을 편집한 다음 /str 옵션을 사용하여 + // ResGen을 다시 실행하거나 VS 프로젝트를 다시 빌드하십시오. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// 이 클래스에서 사용하는 캐시된 ResourceManager 인스턴스를 반환합니다. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("VRCX.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// 이 강력한 형식의 리소스 클래스를 사용하여 모든 리소스 조회에 대해 현재 스레드의 CurrentUICulture 속성을 + /// 재정의합니다. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/Properties/Resources.resx b/Properties/Resources.resx new file mode 100644 index 00000000..af7dbebb --- /dev/null +++ b/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Properties/Settings.Designer.cs b/Properties/Settings.Designer.cs new file mode 100644 index 00000000..4a0f300f --- /dev/null +++ b/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace VRCX.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/Properties/Settings.settings b/Properties/Settings.settings new file mode 100644 index 00000000..39645652 --- /dev/null +++ b/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/RenderHandler.cs b/RenderHandler.cs new file mode 100644 index 00000000..9051d063 --- /dev/null +++ b/RenderHandler.cs @@ -0,0 +1,116 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using System; +using System.Runtime.InteropServices; +using CefSharp; +using CefSharp.Enums; +using CefSharp.OffScreen; +using CefSharp.Structs; + +namespace VRCX +{ + public class RenderHandler : IRenderHandler + { + private ChromiumWebBrowser m_Browser; + public readonly object BufferLock = new object(); + public int BufferSize { get; private set; } + public GCHandle Buffer { get; private set; } + public int Width { get; private set; } + public int Height { get; private set; } + + public RenderHandler(ChromiumWebBrowser browser) + { + m_Browser = browser; + } + + public void Dispose() + { + lock (BufferLock) + { + if (Buffer.IsAllocated) + { + Buffer.Free(); + } + } + m_Browser = null; + } + + public virtual ScreenInfo? GetScreenInfo() + { + return new ScreenInfo { DeviceScaleFactor = 1f }; + } + + public virtual Rect GetViewRect() + { + return new Rect(0, 0, m_Browser.Size.Width, m_Browser.Size.Height); + } + + public virtual bool GetScreenPoint(int viewX, int viewY, out int screenX, out int screenY) + { + screenX = viewX; + screenY = viewY; + return false; + } + + public virtual void OnAcceleratedPaint(PaintElementType type, Rect dirtyRect, IntPtr sharedHandle) + { + // NOT USED + } + + public virtual void OnPaint(PaintElementType type, Rect dirtyRect, IntPtr buffer, int width, int height) + { + if (type == PaintElementType.View) + { + lock (BufferLock) + { + if (!Buffer.IsAllocated || + width != Width || + height != Height) + { + Width = width; + Height = height; + BufferSize = width * height * 4; + if (Buffer.IsAllocated) + { + Buffer.Free(); + } + Buffer = GCHandle.Alloc(new byte[BufferSize], GCHandleType.Pinned); + } + WinApi.CopyMemory(Buffer.AddrOfPinnedObject(), buffer, (uint)BufferSize); + } + } + } + + public virtual void OnCursorChange(IntPtr cursor, CursorType type, CursorInfo customCursorInfo) + { + } + + public virtual bool StartDragging(IDragData dragData, DragOperationsMask mask, int x, int y) + { + return false; + } + + public virtual void UpdateDragCursor(DragOperationsMask operation) + { + } + + public virtual void OnPopupShow(bool show) + { + } + + public virtual void OnPopupSize(Rect rect) + { + } + + public virtual void OnImeCompositionRangeChanged(Range selectedRange, Rect[] characterBounds) + { + } + + public virtual void OnVirtualKeyboardRequested(IBrowser browser, TextInputMode inputMode) + { + } + } +} \ No newline at end of file diff --git a/VRCX.cs b/VRCX.cs new file mode 100644 index 00000000..65e26f95 --- /dev/null +++ b/VRCX.cs @@ -0,0 +1,95 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using CefSharp; +using System; +using System.Windows.Forms; + +namespace VRCX +{ + public class VRCX + { + public void ShowDevTools() + { + try + { + MainForm.Browser.ShowDevTools(); + } + catch + { + } + } + + public void DeleteAllCookies() + { + Cef.GetGlobalCookieManager().DeleteCookies(); + } + + public string LoginWithSteam() + { + return VRChatRPC.Update() + ? VRChatRPC.GetAuthSessionTicket() + : string.Empty; + } + + public bool IsGameRunning() + { + return WinApi.FindWindow("UnityWndClass", "VRChat") != IntPtr.Zero; + } + + public void StartGame(string location) + { + try + { + System.Diagnostics.Process.Start("vrchat://launch?id=" + location); + } + catch + { + } + } + + public void ShowVRForm() + { + try + { + MainForm.Instance.BeginInvoke(new MethodInvoker(() => + { + if (VRForm.Instance==null) + { + new VRForm().Show(); + } + })); + } + catch + { + } + } + + public void StartVR() + { + VRCXVR.Start(); + } + + public void StopVR() + { + VRCXVR.Stop(); + } + + public void RefreshVR() + { + VRCXVR.Refresh(); + } + + public string[][] GetVRDevices() + { + return VRCXVR.GetDevices(); + } + + public float CpuUsage() + { + return CpuMonitor.CpuUsage; + } + } +} \ No newline at end of file diff --git a/VRCX.csproj b/VRCX.csproj new file mode 100644 index 00000000..4cf50a76 --- /dev/null +++ b/VRCX.csproj @@ -0,0 +1,211 @@ + + + + + + + + + + Debug + AnyCPU + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A} + WinExe + VRCX + VRCX + v4.5.2 + 512 + true + true + + + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + true + bin\x64\Debug\ + DEBUG;TRACE + full + x64 + prompt + MinimumRecommendedRules.ruleset + true + + + bin\x64\Release\ + TRACE + true + pdbonly + x64 + prompt + MinimumRecommendedRules.ruleset + true + + + vrchat.ico + + + + + + + packages\DiscordRichPresence.1.0.121\lib\net35\DiscordRPC.dll + + + packages\Newtonsoft.Json.12.0.2\lib\net45\Newtonsoft.Json.dll + + + packages\SharpDX.4.2.0\lib\net45\SharpDX.dll + + + packages\SharpDX.D3DCompiler.4.2.0\lib\net45\SharpDX.D3DCompiler.dll + + + packages\SharpDX.Desktop.4.2.0\lib\net45\SharpDX.Desktop.dll + + + packages\SharpDX.Direct2D1.4.2.0\lib\net45\SharpDX.Direct2D1.dll + + + packages\SharpDX.Direct3D11.4.2.0\lib\net45\SharpDX.Direct3D11.dll + + + packages\SharpDX.DXGI.4.2.0\lib\net45\SharpDX.DXGI.dll + + + packages\SharpDX.Mathematics.4.2.0\lib\net45\SharpDX.Mathematics.dll + + + + + + + + + + + + + + + + + + + + Form + + + VRForm.cs + + + Form + + + MainForm.cs + + + + + + + + + + + + + VRForm.cs + + + MainForm.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + + False + Microsoft .NET Framework 4.5.2%28x86 및 x64%29 + true + + + False + .NET Framework 3.5 SP1 + false + + + + + + 이 프로젝트는 이 컴퓨터에 없는 NuGet 패키지를 참조합니다. 해당 패키지를 다운로드하려면 NuGet 패키지 복원을 사용하십시오. 자세한 내용은 http://go.microsoft.com/fwlink/?LinkID=322105를 참조하십시오. 누락된 파일은 {0}입니다. + + + + + + + + + + + + + + \ No newline at end of file diff --git a/VRCX.sln b/VRCX.sln new file mode 100644 index 00000000..757a3160 --- /dev/null +++ b/VRCX.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.28307.168 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VRCX", "VRCX.csproj", "{D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}.Debug|x64.ActiveCfg = Debug|x64 + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}.Debug|x64.Build.0 = Debug|x64 + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}.Release|Any CPU.Build.0 = Release|Any CPU + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}.Release|x64.ActiveCfg = Release|x64 + {D9F66F2E-3ED9-4D53-A6AC-ADCC1513562A}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {797D384F-D118-4CBB-9450-17949F9EFCA4} + EndGlobalSection +EndGlobal diff --git a/VRCXStorage.cs b/VRCXStorage.cs new file mode 100644 index 00000000..f9f8683c --- /dev/null +++ b/VRCXStorage.cs @@ -0,0 +1,67 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using System.Collections.Generic; +using System.Windows.Forms; + +namespace VRCX +{ + public class VRCXStorage + { + private static Dictionary m_Storage = new Dictionary(); + + public static void Load() + { + JsonSerializer.Deserialize(Application.StartupPath + "/VRCX.json", ref m_Storage); + } + + public static void Save() + { + JsonSerializer.Serialize(Application.StartupPath + "/VRCX.json", m_Storage); + } + + public void Clear() + { + lock (m_Storage) + { + m_Storage.Clear(); + } + } + + public void Flush() + { + lock (m_Storage) + { + Save(); + } + } + + public bool Remove(string key) + { + lock (m_Storage) + { + return m_Storage.Remove(key); + } + } + + public string Get(string key) + { + lock (m_Storage) + { + return m_Storage.TryGetValue(key, out string value) + ? value + : string.Empty; + } + } + + public void Set(string key, string value) + { + lock (m_Storage) + { + m_Storage[key] = value; + } + } + } +} \ No newline at end of file diff --git a/VRCXVR.cs b/VRCXVR.cs new file mode 100644 index 00000000..cf3e2e83 --- /dev/null +++ b/VRCXVR.cs @@ -0,0 +1,584 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using CefSharp; +using SharpDX; +using SharpDX.Direct3D; +using SharpDX.Direct3D11; +using SharpDX.DXGI; +using System; +using System.Collections.Generic; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading; +using System.Windows.Forms; +using Valve.VR; +using Device = SharpDX.Direct3D11.Device; + +namespace VRCX +{ + public static class VRCXVR + { + private static readonly object m_LockObject = new object(); + private static List m_Devices = new List(); + private static Thread m_Thread; + private static Device m_Device; + private static Texture2D m_Texture1; + private static Texture2D m_Texture2; + private static Browser m_Browser1; + private static Browser m_Browser2; + private static float[] m_Rotation = { 0f, 0f, 0f }; + private static float[] m_Translation = { 0f, 0f, 0f }; + private static float[] m_L_Translation = { -7f / 100f, -5f / 100f, 6f / 100f }; + private static float[] m_R_Translation = { 7f / 100f, -5f / 100f, 6f / 100f }; + private static float[] m_L_Rotation = { 90f * (float)(Math.PI / 180f), 90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f) }; + private static float[] m_R_Rotation = { -90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f), -90f * (float)(Math.PI / 180f) }; + + // NOTE + // 메모리 릭 때문에 미리 생성해놓고 계속 사용함 + public static void Setup() + { + m_Device = new Device(DriverType.Hardware, DeviceCreationFlags.SingleThreaded | DeviceCreationFlags.BgraSupport); + m_Texture1 = new Texture2D(m_Device, new Texture2DDescription() + { + Width = 512, + Height = 512, + MipLevels = 1, + ArraySize = 1, + Format = Format.B8G8R8A8_UNorm, + SampleDescription = new SampleDescription(1, 0), + Usage = ResourceUsage.Dynamic, + BindFlags = BindFlags.ShaderResource, + CpuAccessFlags = CpuAccessFlags.Write + }); + m_Texture2 = new Texture2D(m_Device, new Texture2DDescription() + { + Width = 512, + Height = 512, + MipLevels = 1, + ArraySize = 1, + Format = Format.B8G8R8A8_UNorm, + SampleDescription = new SampleDescription(1, 0), + Usage = ResourceUsage.Dynamic, + BindFlags = BindFlags.ShaderResource, + CpuAccessFlags = CpuAccessFlags.Write + }); + m_Browser1 = new Browser(m_Texture1, Application.StartupPath + "/html/vr.html?1"); + m_Browser2 = new Browser(m_Texture2, Application.StartupPath + "/html/vr.html?2"); + } + + public static void Start() + { + lock (m_LockObject) + { + if (m_Thread == null) + { + m_Thread = new Thread(ThreadProc); + m_Thread.Start(); + } + } + } + + public static void Stop() + { + lock (m_LockObject) + { + var thread = m_Thread; + if (thread != null) + { + m_Thread = null; + try + { + thread.Interrupt(); + thread.Join(); + } + catch + { + } + } + } + } + + public static void Refresh() + { + m_Browser1.ExecuteScriptAsync("location.reload()"); + m_Browser2.ExecuteScriptAsync("location.reload()"); + } + + public static string[][] GetDevices() + { + lock (m_Devices) + { + return m_Devices.ToArray(); + } + } + + private static void UpdateDevices(CVRSystem system, ref uint trackingIndex) + { + lock (m_Devices) + { + m_Devices.Clear(); + var sb = new StringBuilder(256); + var state = new VRControllerState_t(); + for (var i = 0u; i < OpenVR.k_unMaxTrackedDeviceCount; ++i) + { + var devClass = system.GetTrackedDeviceClass(i); + if (devClass == ETrackedDeviceClass.Controller || + devClass == ETrackedDeviceClass.GenericTracker) + { + var err = ETrackedPropertyError.TrackedProp_Success; + var batteryPercentage = system.GetFloatTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_DeviceBatteryPercentage_Float, ref err); + if (err != ETrackedPropertyError.TrackedProp_Success) + { + batteryPercentage = 1f; + } + sb.Clear(); + system.GetStringTrackedDeviceProperty(i, ETrackedDeviceProperty.Prop_TrackingSystemName_String, sb, (uint)sb.Capacity, ref err); + var isOculus = sb.ToString().IndexOf("oculus", StringComparison.OrdinalIgnoreCase) >= 0; + // Oculus : B/Y, Bit 1, Mask 2 + // Oculus : A/X, Bit 7, Mask 128 + // Vive : Menu, Bit 1, Mask 2, + // Vive : Grip, Bit 2, Mask 4 + var role = system.GetControllerRoleForTrackedDeviceIndex(i); + if (role == ETrackedControllerRole.LeftHand || + role == ETrackedControllerRole.RightHand) + { + if (system.GetControllerState(i, ref state, (uint)Marshal.SizeOf(state)) && + (state.ulButtonPressed & (isOculus ? 2u : 4u)) != 0) + { + if (role == ETrackedControllerRole.LeftHand) + { + Array.Copy(m_L_Translation, m_Translation, 3); + Array.Copy(m_L_Rotation, m_Rotation, 3); + } + else + { + Array.Copy(m_R_Translation, m_Translation, 3); + Array.Copy(m_R_Rotation, m_Rotation, 3); + } + trackingIndex = i; + } + } + var type = string.Empty; + if (devClass == ETrackedDeviceClass.Controller) + { + if (role == ETrackedControllerRole.LeftHand) + { + type = "leftController"; + } + else if (role == ETrackedControllerRole.RightHand) + { + type = "rightController"; + } + else + { + type = "controller"; + } + } + else if (devClass == ETrackedDeviceClass.GenericTracker) + { + type = "tracker"; + } + m_Devices.Add(new[] + { + type, + system.IsTrackedDeviceConnected(i) + ? "connected" + : "disconnected", + (batteryPercentage * 100).ToString() + }); + } + } + } + } + + private static EVROverlayError ProcessDashboard(CVROverlay overlay, ref ulong dashboardHandle, bool dashboardVisible) + { + var err = EVROverlayError.None; + + if (dashboardHandle == 0) + { + err = overlay.FindOverlay("VRCX", ref dashboardHandle); + if (err != EVROverlayError.None) + { + if (err != EVROverlayError.UnknownOverlay) + { + return err; + } + ulong handle = 0; + err = overlay.CreateDashboardOverlay("VRCX", "VRCX", ref dashboardHandle, ref handle); + if (err != EVROverlayError.None) + { + return err; + } + err = overlay.SetOverlayWidthInMeters(dashboardHandle, 1.5f); + if (err != EVROverlayError.None) + { + return err; + } + err = overlay.SetOverlayInputMethod(dashboardHandle, VROverlayInputMethod.Mouse); + if (err != EVROverlayError.None) + { + return err; + } + } + } + + var e = new VREvent_t(); + + while (overlay.PollNextOverlayEvent(dashboardHandle, ref e, (uint)Marshal.SizeOf(e))) + { + var type = (EVREventType)e.eventType; + if (type == EVREventType.VREvent_MouseMove) + { + var m = e.data.mouse; + var s = m_Browser1.Size; + m_Browser1.GetBrowserHost().SendMouseMoveEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), false, CefEventFlags.None); + } + else if (type == EVREventType.VREvent_MouseButtonDown) + { + var m = e.data.mouse; + var s = m_Browser1.Size; + m_Browser1.GetBrowserHost().SendMouseClickEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), MouseButtonType.Left, false, 1, CefEventFlags.LeftMouseButton); + } + else if (type == EVREventType.VREvent_MouseButtonUp) + { + var m = e.data.mouse; + var s = m_Browser1.Size; + m_Browser1.GetBrowserHost().SendMouseClickEvent((int)(m.x * s.Width), s.Height - (int)(m.y * s.Height), MouseButtonType.Left, true, 1, CefEventFlags.None); + } + } + + if (dashboardVisible) + { + var texture = new Texture_t + { + handle = m_Texture1.NativePointer + }; + err = overlay.SetOverlayTexture(dashboardHandle, ref texture); + if (err != EVROverlayError.None) + { + return err; + } + } + + return err; + } + + private static EVROverlayError ProcessOverlay1(CVROverlay overlay, ref ulong overlayHandle, ref bool overlayVisible, bool dashboardVisible, uint trackingIndex, DateTime nextRender) + { + var err = EVROverlayError.None; + + if (overlayHandle == 0) + { + err = overlay.FindOverlay("VRCX1", ref overlayHandle); + if (err != EVROverlayError.None) + { + if (err != EVROverlayError.UnknownOverlay) + { + return err; + } + overlayVisible = false; + err = overlay.CreateOverlay("VRCX1", "VRCX1", ref overlayHandle); + if (err != EVROverlayError.None) + { + return err; + } + err = overlay.SetOverlayAlpha(overlayHandle, 0.9f); + if (err != EVROverlayError.None) + { + return err; + } + err = overlay.SetOverlayWidthInMeters(overlayHandle, 1f); + if (err != EVROverlayError.None) + { + return err; + } + err = overlay.SetOverlayInputMethod(overlayHandle, VROverlayInputMethod.None); + if (err != EVROverlayError.None) + { + return err; + } + } + } + + if (trackingIndex != OpenVR.k_unTrackedDeviceIndexInvalid) + { + // http://www.opengl-tutorial.org/beginners-tutorials/tutorial-3-matrices + // Scaling-Rotation-Translation + var m = Matrix.Scaling(0.25f); + m *= Matrix.RotationX(m_Rotation[0]); + m *= Matrix.RotationY(m_Rotation[1]); + m *= Matrix.RotationZ(m_Rotation[2]); + m *= Matrix.Translation(m_Translation[0], m_Translation[1], m_Translation[2]); + var hm34 = new HmdMatrix34_t + { + m0 = m.M11, + m1 = m.M21, + m2 = m.M31, + m3 = m.M41, + m4 = m.M12, + m5 = m.M22, + m6 = m.M32, + m7 = m.M42, + m8 = m.M13, + m9 = m.M23, + m10 = m.M33, + m11 = m.M43, + }; + err = overlay.SetOverlayTransformTrackedDeviceRelative(overlayHandle, trackingIndex, ref hm34); + if (err != EVROverlayError.None) + { + return err; + } + } + + if (!dashboardVisible && + DateTime.Now.CompareTo(nextRender) <= 0) + { + var texture = new Texture_t + { + handle = m_Texture1.NativePointer + }; + err = overlay.SetOverlayTexture(overlayHandle, ref texture); + if (err != EVROverlayError.None) + { + return err; + } + if (!overlayVisible) + { + err = overlay.ShowOverlay(overlayHandle); + if (err != EVROverlayError.None) + { + return err; + } + overlayVisible = true; + } + } + else if (overlayVisible) + { + err = overlay.HideOverlay(overlayHandle); + if (err != EVROverlayError.None) + { + return err; + } + overlayVisible = false; + } + + return err; + } + + private static EVROverlayError ProcessOverlay2(CVROverlay overlay, ref ulong overlayHandle, ref bool overlayVisible, bool dashboardVisible) + { + var err = EVROverlayError.None; + + if (overlayHandle == 0) + { + err = overlay.FindOverlay("VRCX2", ref overlayHandle); + if (err != EVROverlayError.None) + { + if (err != EVROverlayError.UnknownOverlay) + { + return err; + } + overlayVisible = false; + err = overlay.CreateOverlay("VRCX2", "VRCX2", ref overlayHandle); + if (err != EVROverlayError.None) + { + return err; + } + err = overlay.SetOverlayAlpha(overlayHandle, 0.9f); + if (err != EVROverlayError.None) + { + return err; + } + err = overlay.SetOverlayWidthInMeters(overlayHandle, 1f); + if (err != EVROverlayError.None) + { + return err; + } + err = overlay.SetOverlayInputMethod(overlayHandle, VROverlayInputMethod.None); + if (err != EVROverlayError.None) + { + return err; + } + var m = Matrix.Scaling(1f); + m *= Matrix.Translation(0, -0.3f, -1.5f); + var hm34 = new HmdMatrix34_t + { + m0 = m.M11, + m1 = m.M21, + m2 = m.M31, + m3 = m.M41, + m4 = m.M12, + m5 = m.M22, + m6 = m.M32, + m7 = m.M42, + m8 = m.M13, + m9 = m.M23, + m10 = m.M33, + m11 = m.M43, + }; + err = overlay.SetOverlayTransformTrackedDeviceRelative(overlayHandle, OpenVR.k_unTrackedDeviceIndex_Hmd, ref hm34); + if (err != EVROverlayError.None) + { + return err; + } + } + } + + if (!dashboardVisible) + { + var texture = new Texture_t + { + handle = m_Texture2.NativePointer + }; + err = overlay.SetOverlayTexture(overlayHandle, ref texture); + if (err != EVROverlayError.None) + { + return err; + } + if (!overlayVisible) + { + err = overlay.ShowOverlay(overlayHandle); + if (err != EVROverlayError.None) + { + return err; + } + overlayVisible = true; + } + } + else if (overlayVisible) + { + err = overlay.HideOverlay(overlayHandle); + if (err != EVROverlayError.None) + { + return err; + } + overlayVisible = false; + } + + return err; + } + + private static void ThreadProc() + { + var e = new VREvent_t(); + var nextOpenVRInit = DateTime.MinValue; + var nextDeviceInfoUpdate = DateTime.MinValue; + var nextRender = DateTime.MinValue; + var trackingIndex = OpenVR.k_unTrackedDeviceIndexInvalid; + var overlayVisible1 = false; + var overlayVisible2 = false; + var dashboardHandle = 0UL; + var overlayHandle1 = 0UL; + var overlayHandle2 = 0UL; + + while (m_Thread != null) + { + m_Browser1.Render(); + m_Browser2.Render(); + + try + { + Thread.Sleep(10); + } + catch + { + // ThreadInterruptedException + } + + var system = OpenVR.System; + + if (system == null) + { + if (DateTime.Now.CompareTo(nextOpenVRInit) < 0) + { + continue; + } + var _err = EVRInitError.None; + system = OpenVR.Init(ref _err, EVRApplicationType.VRApplication_Overlay); + nextOpenVRInit = DateTime.Now.AddSeconds(5); + if (system == null) + { + continue; + } + } + + while (system.PollNextEvent(ref e, (uint)Marshal.SizeOf(e))) + { + var type = (EVREventType)e.eventType; + if (type == EVREventType.VREvent_Quit) + { + OpenVR.Shutdown(); + // VRChat이 실행 중일 때만 켜는 옵션이 생겨서 시간을 줄임 + nextOpenVRInit = DateTime.Now.AddSeconds(10); + system = null; + break; + } + } + + if (system == null) + { + continue; + } + + if (DateTime.Now.CompareTo(nextDeviceInfoUpdate) >= 0) + { + trackingIndex = OpenVR.k_unTrackedDeviceIndexInvalid; + UpdateDevices(system, ref trackingIndex); + if (trackingIndex != OpenVR.k_unTrackedDeviceIndexInvalid) + { + nextRender = DateTime.Now.AddSeconds(10); + } + nextDeviceInfoUpdate = DateTime.Now.AddSeconds(0.1); + } + + var overlay = OpenVR.Overlay; + + if (overlay == null) + { + continue; + } + + var dashboardVisible = overlay.IsDashboardVisible(); + + var err = ProcessDashboard(overlay, ref dashboardHandle, dashboardVisible); + + if (err != EVROverlayError.None && + dashboardHandle != 0) + { + overlay.DestroyOverlay(dashboardHandle); + dashboardHandle = 0; + } + + err = ProcessOverlay1(overlay, ref overlayHandle1, ref overlayVisible1, dashboardVisible, trackingIndex, nextRender); + + if (err != EVROverlayError.None && + overlayHandle1 != 0) + { + overlay.DestroyOverlay(overlayHandle1); + overlayHandle1 = 0; + } + + err = ProcessOverlay2(overlay, ref overlayHandle2, ref overlayVisible2, dashboardVisible); + + if (err != EVROverlayError.None && + overlayHandle2 != 0) + { + overlay.DestroyOverlay(overlayHandle2); + overlayHandle2 = 0; + } + } + + lock (m_Devices) + { + m_Devices.Clear(); + } + + OpenVR.Shutdown(); + } + } +} \ No newline at end of file diff --git a/VRChatRPC.cs b/VRChatRPC.cs new file mode 100644 index 00000000..df584a21 --- /dev/null +++ b/VRChatRPC.cs @@ -0,0 +1,55 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using System; +using System.Runtime.InteropServices; +using System.Text; + +namespace VRCX +{ + public static class VRChatRPC + { + [DllImport("VRChatRPC", CallingConvention = CallingConvention.Cdecl)] + private static extern bool VRChatRPC_000(); + + [DllImport("VRChatRPC", CallingConvention = CallingConvention.Cdecl)] + private static extern int VRChatRPC_001([Out] byte[] data, int size); + + [DllImport("VRChatRPC", CallingConvention = CallingConvention.Cdecl)] + private static extern IntPtr VRChatRPC_002(); + + public static bool Update() + { + return VRChatRPC_000(); + } + + public static string GetAuthSessionTicket() + { + var a = new byte[1024]; + var n = VRChatRPC_001(a, 1024); + return BitConverter.ToString(a, 0, n).Replace("-", string.Empty); + } + + public static string GetPersonaName() + { + var ptr = VRChatRPC_002(); + if (ptr != IntPtr.Zero) + { + int n = 0; + while (Marshal.ReadByte(ptr, n) != 0) + { + ++n; + } + if (n > 0) + { + var a = new byte[n]; + Marshal.Copy(ptr, a, 0, a.Length); + return Encoding.UTF8.GetString(a); + } + } + return string.Empty; + } + } +} \ No newline at end of file diff --git a/VRChatRPC/README.txt b/VRChatRPC/README.txt new file mode 100644 index 00000000..c9ec1e37 --- /dev/null +++ b/VRChatRPC/README.txt @@ -0,0 +1,3 @@ +it grabs some data from VRChat process.. use at own risk. + +by pypy (mina#5656) \ No newline at end of file diff --git a/VRChatRPC/VRChatRPC.dll b/VRChatRPC/VRChatRPC.dll new file mode 100644 index 0000000000000000000000000000000000000000..0a2df93a3512744ffb4583aeeafa6faec5365a11 GIT binary patch literal 14336 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. + +namespace VRCX +{ + partial class VRForm + { + /// + /// 필수 디자이너 변수입니다. + /// + private System.ComponentModel.IContainer components = null; + + /// + /// 사용 중인 모든 리소스를 정리합니다. + /// + /// 관리되는 리소스를 삭제해야 하면 true이고, 그렇지 않으면 false입니다. + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows Form 디자이너에서 생성한 코드 + + /// + /// 디자이너 지원에 필요한 메서드입니다. + /// 이 메서드의 내용을 코드 편집기로 수정하지 마세요. + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + this.timer = new System.Windows.Forms.Timer(this.components); + this.panel1 = new System.Windows.Forms.Panel(); + this.panel2 = new System.Windows.Forms.Panel(); + this.button_refresh = new System.Windows.Forms.Button(); + this.button_devtools = new System.Windows.Forms.Button(); + this.SuspendLayout(); + // + // panel1 + // + this.panel1.Location = new System.Drawing.Point(0, 0); + this.panel1.Name = "panel1"; + this.panel1.Size = new System.Drawing.Size(512, 512); + this.panel1.TabIndex = 0; + // + // panel2 + // + this.panel2.Location = new System.Drawing.Point(518, 0); + this.panel2.Name = "panel2"; + this.panel2.Size = new System.Drawing.Size(512, 512); + this.panel2.TabIndex = 1; + // + // button_refresh + // + this.button_refresh.Location = new System.Drawing.Point(12, 518); + this.button_refresh.Name = "button_refresh"; + this.button_refresh.Size = new System.Drawing.Size(75, 23); + this.button_refresh.TabIndex = 27; + this.button_refresh.Text = "Refresh"; + this.button_refresh.UseVisualStyleBackColor = true; + this.button_refresh.Click += new System.EventHandler(this.button_refresh_Click); + // + // button_devtools + // + this.button_devtools.Location = new System.Drawing.Point(93, 518); + this.button_devtools.Name = "button_devtools"; + this.button_devtools.Size = new System.Drawing.Size(75, 23); + this.button_devtools.TabIndex = 27; + this.button_devtools.Text = "DevTools"; + this.button_devtools.UseVisualStyleBackColor = true; + this.button_devtools.Click += new System.EventHandler(this.button_devtools_Click); + // + // VRForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(7F, 12F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.ClientSize = new System.Drawing.Size(1038, 553); + this.Controls.Add(this.button_devtools); + this.Controls.Add(this.button_refresh); + this.Controls.Add(this.panel2); + this.Controls.Add(this.panel1); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog; + this.MaximizeBox = false; + this.Name = "VRForm"; + this.StartPosition = System.Windows.Forms.FormStartPosition.CenterScreen; + this.Text = "VR"; + this.ResumeLayout(false); + + } + + #endregion + + private System.Windows.Forms.Timer timer; + private System.Windows.Forms.Panel panel1; + private System.Windows.Forms.Panel panel2; + private System.Windows.Forms.Button button_refresh; + private System.Windows.Forms.Button button_devtools; + } +} \ No newline at end of file diff --git a/VRForm.cs b/VRForm.cs new file mode 100644 index 00000000..831f8cba --- /dev/null +++ b/VRForm.cs @@ -0,0 +1,74 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using System.Windows.Forms; +using CefSharp; +using CefSharp.WinForms; + +namespace VRCX +{ + public partial class VRForm : Form + { + public static VRForm Instance { get; private set; } + public static ChromiumWebBrowser Browser1 { get; private set; } + public static ChromiumWebBrowser Browser2 { get; private set; } + + public VRForm() + { + Instance = this; + InitializeComponent(); + // + Browser1 = new ChromiumWebBrowser(Application.StartupPath + "/html/vr.html?1") + { + BrowserSettings = + { + // UniversalAccessFromFileUrls = CefState.Enabled, + DefaultEncoding = "UTF-8", + }, + Dock = DockStyle.Fill, + }; + Browser2 = new ChromiumWebBrowser(Application.StartupPath + "/html/vr.html?2") + { + BrowserSettings = + { + // UniversalAccessFromFileUrls = CefState.Enabled, + DefaultEncoding = "UTF-8", + }, + Dock = DockStyle.Fill, + }; + var options = new BindingOptions() + { + CamelCaseJavascriptNames = false + }; + Browser1.JavascriptObjectRepository.Register("VRCX", new VRCX(), true, options); + Browser1.JavascriptObjectRepository.Register("VRCXStorage", new VRCXStorage(), false, options); + Browser2.JavascriptObjectRepository.Register("VRCX", new VRCX(), true, options); + Browser2.JavascriptObjectRepository.Register("VRCXStorage", new VRCXStorage(), false, options); + Browser1.IsBrowserInitializedChanged += (A, B) => + { + // Browser1.ShowDevTools(); + }; + Browser2.IsBrowserInitializedChanged += (A, B) => + { + // Browser2.ShowDevTools(); + }; + panel1.Controls.Add(Browser1); + panel2.Controls.Add(Browser2); + } + + private void button_refresh_Click(object sender, System.EventArgs e) + { + VRCXVR.Refresh(); + Browser1.ExecuteScriptAsync("location.reload()"); + Browser2.ExecuteScriptAsync("location.reload()"); + } + + private void button_devtools_Click(object sender, System.EventArgs e) + { + Browser1.ShowDevTools(); + Browser2.ShowDevTools(); + } + } +} \ No newline at end of file diff --git a/VRForm.resx b/VRForm.resx new file mode 100644 index 00000000..e22c5ac6 --- /dev/null +++ b/VRForm.resx @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + \ No newline at end of file diff --git a/WinApi.cs b/WinApi.cs new file mode 100644 index 00000000..0c702de9 --- /dev/null +++ b/WinApi.cs @@ -0,0 +1,19 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +using System; +using System.Runtime.InteropServices; + +namespace VRCX +{ + public static class WinApi + { + [DllImport("kernel32.dll", SetLastError = false)] + public static extern void CopyMemory(IntPtr destination, IntPtr source, uint length); + + [DllImport("user32.dll")] + public static extern IntPtr FindWindow(string lpClassName, string lpWindowName); + } +} \ No newline at end of file diff --git a/html/.eslintrc.js b/html/.eslintrc.js new file mode 100644 index 00000000..419f15c0 --- /dev/null +++ b/html/.eslintrc.js @@ -0,0 +1,67 @@ +module.exports = { + 'env': { + 'browser': true, + 'es6': true, + 'jquery': true + }, + 'extends': 'eslint:all', + 'globals': { + 'CefSharp': 'readonly', + 'VRCX': 'readonly', + 'VRCXStorage': 'readonly', + 'LogWatcher': 'readonly', + 'Discord': 'readonly', + 'Noty': 'readonly', + 'Vue': 'readonly', + 'VueLazyload': 'readonly', + 'DataTables': 'readonly', + 'ELEMENT': 'readonly' + }, + 'parserOptions': { + 'ecmaVersion': 9 + }, + 'root': true, + 'rules': { + 'camelcase': 0, + 'capitalized-comments': 0, + 'complexity': 0, + 'default-case': 0, + 'func-names': 0, + 'guard-for-in': 0, + 'id-length': 0, + 'indent': 0, + 'init-declarations': 0, + 'linebreak-style': 0, + 'max-depth': 0, + 'max-len': 0, + 'max-lines': 0, + 'max-lines-per-function': 0, + 'max-statements': 0, + 'multiline-comment-style': 0, + 'newline-per-chained-call': 0, + 'new-cap': 0, + 'no-console': 0, + 'no-empty': ['error', { 'allowEmptyCatch': true }], + 'no-magic-numbers': 0, + 'no-mixed-operators': 0, + 'no-nested-ternary': 0, + 'no-plusplus': 0, + 'no-tabs': 0, + 'no-ternary': 0, + 'no-throw-literal': 0, + 'no-undefined': 0, + 'no-underscore-dangle': 0, + 'no-var': 0, + 'no-warning-comments': 0, + 'object-curly-spacing': ['error', 'always'], + 'one-var': 0, + 'padded-blocks': 0, + 'prefer-named-capture-group': 0, + 'quotes': ['error', 'single', { 'avoidEscape': true }], + 'quote-props': 0, + 'sort-keys': 0, + 'space-before-function-paren': ['error', { 'named': 'never' }], + 'strict': 0, + 'vars-on-top': 0 + } +}; \ No newline at end of file diff --git a/html/app.css b/html/app.css new file mode 100644 index 00000000..e1c4afa5 --- /dev/null +++ b/html/app.css @@ -0,0 +1,413 @@ +@charset "utf-8"; +/* +Copyright(c) 2019 pypy. All rights reserved. + +This work is licensed under the terms of the MIT license. +For a copy, see . +*/ + +.noty_layout { + word-break: break-all; +} + +.noty_theme__mint.noty_bar { + margin: 4px 0; + overflow: hidden; + border-radius: 2px; + position: relative; +} + +.noty_theme__mint.noty_bar .noty_body { + padding: 10px; + font-size: 14px; +} + +.noty_theme__mint.noty_bar .noty_buttons { + padding: 10px; +} + +.noty_theme__mint.noty_type__alert, .noty_theme__mint.noty_type__notification { + background-color: #fff; + border-bottom: 1px solid #D1D1D1; + color: #2F2F2F; +} + +.noty_theme__mint.noty_type__warning { + background-color: #FFAE42; + border-bottom: 1px solid #E89F3C; + color: #fff; +} + +.noty_theme__mint.noty_type__error { + background-color: #DE636F; + border-bottom: 1px solid #CA5A65; + color: #fff; +} + +.noty_theme__mint.noty_type__info, .noty_theme__mint.noty_type__information { + background-color: #7F7EFF; + border-bottom: 1px solid #7473E8; + color: #fff; +} + +.noty_theme__mint.noty_type__success { + background-color: #AFC765; + border-bottom: 1px solid #A0B55C; + color: #fff; +} + +.el-table+.pagination-bar { + margin-top: 15px; +} + +.el-dialog__body { + padding: 20px; +} + +::-webkit-scrollbar { + width: 8px; + height: 8px; +} + +::-webkit-scrollbar-track { + background: rgba(0, 0, 0, 0.1); + border-radius: 16px; +} + +::-webkit-scrollbar-thumb { + background: rgba(0, 0, 0, 0.25); + border-radius: 16px; +} + +body, input, textarea, select, button { + font-family: 'Noto Sans JP', 'Noto Sans KR', 'Meiryo UI', 'Malgun Gothic', 'Segoe UI', sans-serif; + line-height: normal; +} + +.x-link { + cursor: pointer; +} + +.x-link:hover { + text-decoration: underline; +} + +.x-ellipsis { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.x-app { + display: flex; + position: absolute; + width: 100%; + height: 100%; + overflow: hidden auto; +} + +.x-container { + flex: 1; + padding: 10px; + overflow: hidden auto; + background: #fff; + position: relative; +} + +.x-login-container { + display: flex; + position: absolute; + width: 100%; + height: 100%; + background: #fff; + /* modal 시작이 2000이라서 */ + z-index: 1999; +} + +.x-menu-container { + flex: none; + overflow: hidden auto; + background: #383838; +} + +.x-menu-container>.el-menu { + background: 0; + border: 0; +} + +.el-menu-item.notify::after { + position: absolute; + content: ''; + right: 5px; + top: 5px; + width: 5px; + height: 5px; + background: #909399; + border-radius: 50% +} + +.x-aside-container { + flex: none; + width: 236px; + display: flex; + flex-direction: column; + background: #f8f8f8; +} + +.el-popper.x-quick-search { + min-width: 0 !important; + width: 225px; +} + +.el-popper.x-quick-search .el-select-dropdown__item { + padding: 0 10px; + width: 100%; + height: auto; + font-size: 12px; + line-height: normal; +} + +.x-friend-list { + overflow: hidden auto; + padding: 0 10px; +} + +.x-friend-group>.el-icon-arrow-right { + transition: transform .3s; +} + +.x-friend-group>.el-icon-arrow-right.rotate { + transform: rotate(90deg); +} + +.x-aside-container .x-friend-list { + flex: 1; +} + +.x-dialog .x-friend-list { + display: flex; + align-items: flex-start; + flex-wrap: wrap; + max-height: 150px; +} + +.x-friend-list>.x-friend-group { + padding: 20px 0 5px; + font-weight: bold; + font-size: 12px; +} + +.x-friend-item { + display: flex; + align-items: center; + padding: 5px; + cursor: pointer; + font-size: 12px; + box-sizing: border-box; +} + +.x-friend-item:hover { + background: #eee; + border-radius: 2px; +} + +.x-aside-container .x-friend-item:hover { + background: #fff; + border-radius: 2px; +} + +.el-select-dropdown__item .x-friend-item:hover { + background: none; + border-radius: 0; +} + +.x-dialog .x-friend-item { + width: 175px; +} + +.x-friend-item>.avatar { + flex: none; + width: 40px; + height: 40px; + margin-right: 8px; + display: inline-block; + position: relative; +} + +.x-friend-item>img.avatar { + width: 50px; + height: 37.5px; + margin-left: 5px; + margin-right: 0; + border-radius: 2px; +} + +.x-friend-item>.avatar>img { + width: 100%; + height: 100%; + border-radius: 40%; + object-fit: cover; +} + +.x-friend-item>.avatar.offline>img { + filter: grayscale(1); +} + +.x-friend-item:hover>.avatar.offline>img { + filter: none; +} + +.x-friend-item>.avatar.active::after, .x-friend-item>.avatar.joinme::after, .x-friend-item>.avatar.busy::after { + content: ''; + position: absolute; + right: 0; + bottom: 0; + width: 8px; + height: 8px; + border-radius: 50%; + border: 2px solid #fff; + background: #909399; +} + +.x-friend-item>.avatar.active::after { + background: #67C23A; +} + +.x-friend-item>.avatar.joinme::after { + background: #409EFF; +} + +.x-friend-item>.avatar.busy::after { + background: #F56C6C; +} + +.x-friend-item.offline>.avatar::after { + display: none; +} + +.x-friend-item>.detail { + flex: 1; + overflow: hidden; +} + +.x-friend-item>.detail>.name, .x-friend-item>.detail>.extra { + display: block; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.x-friend-item>.detail>.name { + font-weight: bold; +} + +.x-friend-item>.detail>.extra { + font-weight: normal; +} + +.x-dialog .el-dialog { + margin-bottom: 10px; + max-width: 100%; +} + +.x-user-dialog .el-dialog__header, .x-world-dialog .el-dialog__header, .x-avatar-dialog .el-dialog__header { + padding: 0; + display: none; +} + +.x-user-dialog .el-dialog__body, .x-world-dialog .el-dialog__body, .x-avatar-dialog .el-dialog__body { + padding: 20px; +} + +.el-popper.hex { + font-family: monospace; + text-align: center; + min-width: auto; + padding: 10px; +} + +i.x-user-status { + display: inline-block; + width: 10px; + height: 10px; + border-radius: 50%; + background: gray; +} + +i.x-user-status.active { + background: #67C23A; +} + +i.x-user-status.joinme { + background: #409EFF; +} + +i.x-user-status.busy { + background: #F56C6C; +} + +.el-tag.x-tag-vip { + border-color: rgb(181, 38, 38); + color: rgb(181, 38, 38); +} + +.el-tag.x-tag-friend { + /*border-color: rgb(255, 255, 0); + color: rgb(255, 255, 0);*/ + border-color: rgb(255, 208, 0); + color: rgb(255, 208, 0); +} + +.el-tag.x-tag-untrusted { + border-color: rgb(204, 204, 204); + color: rgb(204, 204, 204); +} + +.el-tag.x-tag-basic { + border-color: rgb(23, 120, 255); + color: rgb(23, 120, 255); +} + +.el-tag.x-tag-known { + border-color: rgb(43, 207, 92); + color: rgb(43, 207, 92); +} + +.el-tag.x-tag-trusted { + border-color: rgb(255, 123, 66); + color: rgb(255, 123, 66); +} + +.el-tag.x-tag-veteran { + border-color: rgb(129, 67, 230); + color: rgb(129, 67, 230); +} + +.el-tag.x-tag-legend { + /*border-color: rgb(255, 255, 0); + color: rgb(255, 255, 0);*/ + border-color: rgb(255, 208, 0); + color: rgb(255, 208, 0); +} + +.el-tag.x-tag-troll { + border-color: rgb(120, 47, 47); + color: rgb(120, 47, 47); +} + +.el-tag.x-tag-legendary { + border-color: rgb(0, 0, 0); + color: rgb(0, 0, 0); +} + +.x-dialog .el-tree { + font-size: 12px; +} + +.x-dialog .el-tree-node { + white-space: normal; +} + +.x-dialog .el-tree-node__content { + height: auto; +} \ No newline at end of file diff --git a/html/app.js b/html/app.js new file mode 100644 index 00000000..ea1a306a --- /dev/null +++ b/html/app.js @@ -0,0 +1,6645 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +if (window.CefSharp) { + Promise.all([ + CefSharp.BindObjectAsync('VRCX'), + CefSharp.BindObjectAsync('VRCXStorage'), + CefSharp.BindObjectAsync('LogWatcher'), + CefSharp.BindObjectAsync('Discord') + ]).catch(() => { + location = 'https://github.com/pypy-vrc/vrcx'; + }).then(() => { + + document.addEventListener('keyup', (e) => { + if (e.ctrlKey) { + if (e.shiftKey && e.code === 'KeyI') { + VRCX.ShowDevTools(); + } else if (e.code === 'KeyR') { + location.reload(); + } + } + }); + + VRCXStorage.GetBool = function (key) { + return this.Get(key) === 'true'; + }; + + VRCXStorage.SetBool = function (key, value) { + this.Set(key, value + ? 'true' + : 'false'); + }; + + VRCXStorage.GetInt = function (key) { + return parseInt(this.Get(key), 10) || 0; + }; + + VRCXStorage.SetInt = function (key, value) { + this.Set(key, String(value)); + }; + + VRCXStorage.GetFloat = function (key) { + return parseFloat(this.Get(key), 10) || 0.0; + }; + + VRCXStorage.SetFloat = function (key, value) { + this.Set(key, String(value)); + }; + + VRCXStorage.GetArray = function (key) { + try { + var json = this.Get(key); + if (json) { + var array = JSON.parse(json); + if (Array.isArray(array)) { + return array; + } + } + } catch (err) { + console.error(err); + } + return []; + }; + + VRCXStorage.SetArray = function (key, value) { + this.Set(key, JSON.stringify(value)); + }; + + VRCXStorage.GetObject = function (key) { + try { + var json = this.Get(key); + if (json) { + return JSON.parse(json); + } + } catch (err) { + console.error(err); + } + return {}; + }; + + VRCXStorage.SetObject = function (key, value) { + this.Set(key, JSON.stringify(value)); + }; + + VRCXStorage.Flush(); + + setInterval(() => VRCXStorage.Flush(), 3 * 60 * 1000); + + Noty.overrideDefaults({ + animation: { + open: 'animated bounceInLeft', + close: 'animated bounceOutLeft' + }, + layout: 'bottomLeft', + theme: 'mint', + timeout: 6000 + }); + + var removeFromArray = (array, item) => { + var { length } = array; + for (var i = 0; i < length; ++i) { + if (array[i] === item) { + array.splice(i, 1); + return true; + } + } + return false; + }; + + var escapeTag = (s) => String(s).replace(/["&'<>]/gu, (c) => `&#${c.charCodeAt(0)};`); + Vue.filter('escapeTag', escapeTag); + + var commaNumber = (n) => String(Number(n) || 0).replace(/(\d)(?=(\d{3})+(?!\d))/gu, '$1,'); + Vue.filter('commaNumber', commaNumber); + + var formatDate = (s, format) => { + var ctx = new Date(s); + if (isNaN(ctx)) { + return escapeTag(s); + } + var hours = ctx.getHours(); + var map = { + 'YYYY': String(10000 + ctx.getFullYear()).substr(-4), + 'MM': String(101 + ctx.getMonth()).substr(-2), + 'DD': String(100 + ctx.getDate()).substr(-2), + 'HH24': String(100 + hours).substr(-2), + 'HH': String(100 + (hours > 12 + ? hours - 12 + : hours)).substr(-2), + 'MI': String(100 + ctx.getMinutes()).substr(-2), + 'SS': String(100 + ctx.getSeconds()).substr(-2), + 'AMPM': hours >= 12 + ? 'PM' + : 'AM' + }; + return format.replace(/YYYY|MM|DD|HH24|HH|MI|SS|AMPM/gu, (c) => map[c] || c); + }; + Vue.filter('formatDate', formatDate); + + var textToHex = (s) => String(s).split('').map((c) => c.charCodeAt(0).toString(16)).join(' '); + Vue.filter('textToHex', textToHex); + + var timeToText = (t) => { + var sec = Number(t); + if (isNaN(sec)) { + return escapeTag(t); + } + sec = Math.floor(sec / 1000); + var arr = []; + if (sec < 0) { + sec = -sec; + } + if (sec >= 86400) { + arr.push(`${Math.floor(sec / 86400)}d`); + sec %= 86400; + } + if (sec >= 3600) { + arr.push(`${Math.floor(sec / 3600)}h`); + sec %= 3600; + } + if (sec >= 60) { + arr.push(`${Math.floor(sec / 60)}m`); + sec %= 60; + } + if (sec || + !arr.length) { + arr.push(`${sec}s`); + } + return arr.join(' '); + }; + Vue.filter('timeToText', timeToText); + + Vue.use(VueLazyload, { + preLoad: 1, + observer: true, + observerOptions: { + rootMargin: '0px', + threshold: 0.1 + } + }); + + Vue.use(DataTables.DataTables); + + ELEMENT.locale(ELEMENT.lang.en); + + // + // API + // + + var API = {}; + + API.$handler = {}; + + API.$emit = function (event, ...args) { + try { + // console.log(event, ...args); + var h = this.$handler[event]; + if (h) { + h.forEach((f) => f(...args)); + } + } catch (err) { + console.error(err); + } + }; + + API.$on = function (event, callback) { + var h = this.$handler[event]; + if (h) { + h.push(callback); + } else { + this.$handler[event] = [callback]; + } + }; + + API.$off = function (event, callback) { + var h = this.$handler[event]; + if (h) { + h.find((val, idx, arr) => { + if (val !== callback) { + return false; + } + if (arr.length > 1) { + arr.splice(idx, 1); + } else { + delete this.$handler[event]; + } + return true; + }); + } + }; + + API.$fetch = {}; + + API.call = function (endpoint, options) { + var input = `https://api.vrchat.cloud/api/1/${endpoint}`; + var init = { + method: 'GET', + mode: 'cors', + credentials: 'include', + cache: 'no-cache', + referrerPolicy: 'no-referrer', + ...options + }; + if (init.method === 'GET') { + if (init.body) { + var url = new URL(input); + for (var key in init.body) { + url.searchParams.set(key, init.body[key]); + } + input = url.toString(); + init.body = null; + } + // merge requests + if (this.$fetch[input]) { + return this.$fetch[input]; + } + } else { + init.headers = { + 'Content-Type': 'application/json;charset=utf-8', + ...init.headers + }; + init.body = init.body + ? JSON.stringify(init.body) + : '{}'; + } + var req = fetch(input, init).catch((err) => { + this.$throw(0, err); + }).then((res) => res.json().catch(() => { + if (!res.ok) { + this.$throw(res.status); + } + this.$throw(0, 'Invalid JSON'); + }).then((json) => { + if (res.ok) { + if (json.success) { + new Noty({ + type: 'success', + text: escapeTag(json.success.message) + }).show(); + } + } else if (typeof json.error === 'object') { + this.$throw( + json.error.status_code || res.status, + json.error.message, + json.error.data + ); + } else if (typeof json.error === 'string') { + this.$throw( + json.status_code || res.status, + json.error + ); + } else { + this.$throw(res.status, json); + } + return json; + })); + if (init.method === 'GET') { + this.$fetch[input] = req.finally(() => { + delete this.$fetch[input]; + }); + } + return req; + }; + + API.$status = { + 100: 'Continue', + 101: 'Switching Protocols', + 102: 'Processing', + 103: 'Early Hints', + 200: 'OK', + 201: 'Created', + 202: 'Accepted', + 203: 'Non-Authoritative Information', + 204: 'No Content', + 205: 'Reset Content', + 206: 'Partial Content', + 207: 'Multi-Status', + 208: 'Already Reported', + 226: 'IM Used', + 300: 'Multiple Choices', + 301: 'Moved Permanently', + 302: 'Found', + 303: 'See Other', + 304: 'Not Modified', + 305: 'Use Proxy', + 306: 'Switch Proxy', + 307: 'Temporary Redirect', + 308: 'Permanent Redirect', + 400: 'Bad Request', + 401: 'Unauthorized', + 402: 'Payment Required', + 403: 'Forbidden', + 404: 'Not Found', + 405: 'Method Not Allowed', + 406: 'Not Acceptable', + 407: 'Proxy Authentication Required', + 408: 'Request Timeout', + 409: 'Conflict', + 410: 'Gone', + 411: 'Length Required', + 412: 'Precondition Failed', + 413: 'Payload Too Large', + 414: 'URI Too Long', + 415: 'Unsupported Media Type', + 416: 'Range Not Satisfiable', + 417: 'Expectation Failed', + 418: "I'm a teapot", + 421: 'Misdirected Request', + 422: 'Unprocessable Entity', + 423: 'Locked', + 424: 'Failed Dependency', + 425: 'Too Early', + 426: 'Upgrade Required', + 428: 'Precondition Required', + 429: 'Too Many Requests', + 431: 'Request Header Fields Too Large', + 451: 'Unavailable For Legal Reasons', + 500: 'Internal Server Error', + 501: 'Not Implemented', + 502: 'Bad Gateway', + 503: 'Service Unavailable', + 504: 'Gateway Timeout', + 505: 'HTTP Version Not Supported', + 506: 'Variant Also Negotiates', + 507: 'Insufficient Storage', + 508: 'Loop Detected', + 510: 'Not Extended', + 511: 'Network Authentication Required', + // CloudFlare Error + 520: 'Web server returns an unknown error', + 521: 'Web server is down', + 522: 'Connection timed out', + 523: 'Origin is unreachable', + 524: 'A timeout occurred', + 525: 'SSL handshake failed', + 526: 'Invalid SSL certificate', + 527: 'Railgun Listener to origin error' + }; + + API.$throw = function (code, error, extra) { + var text = []; + if (code) { + var status = this.$status[code]; + if (status) { + text.push(`${code} ${status}`); + } else { + text.push(`${code}`); + } + } + if (error !== undefined) { + text.push(error); + } + if (extra !== undefined) { + text.push(extra); + } + if (text.length) { + new Noty({ + type: 'error', + text: text.map((s) => escapeTag(s)).join('
') + }).show(); + } + throw { + 'status_code': code, + error + }; + }; + + API.bulk = function (options) { + var handle = (args) => { + if (typeof options.handle === 'function') { + options.handle(args, options); + } + if (args.json.length && + (options.param.offset += args.json.length, + options.N > 0 + ? options.N > options.param.offset + : options.N < 0 + ? args.json.length + : options.param.n === args.json.length)) { + this[options.fn](options.param).catch((err) => { + if (typeof options.done === 'function') { + options.done(false, options); + } + throw err; + }).then(handle); + } else if (typeof options.done === 'function') { + options.done(true, options); + } + return args; + }; + this[options.fn](options.param).catch((err) => { + if (typeof options.done === 'function') { + options.done(false, options); + } + throw err; + }).then(handle); + }; + + // API: Config + + API.config = {}; + + API.$on('CONFIG', (args) => { + args.ref = API.updateConfig(args.json); + }); + + API.getConfig = function () { + return this.call('config', { + method: 'GET' + }).then((json) => { + var args = { + json + }; + this.$emit('CONFIG', args); + return args; + }); + }; + + API.updateConfig = function (ref) { + var ctx = { + clientApiKey: '', + ...ref + }; + this.config = ctx; + return ctx; + }; + + // API: Location + + API.parseLocation = function (tag) { + var L = { + tag: String(tag || ''), + isOffline: false, + isPrivate: false, + worldId: '', + instanceId: '', + instanceName: '', + accessType: '', + userId: null, + hiddenId: null, + privateId: null, + friendsId: null, + canRequestInvite: false + }; + if (L.tag === 'offline') { + L.isOffline = true; + } else if (L.tag === 'private') { + L.isPrivate = true; + } else if (!L.tag.startsWith('local')) { + var sep = L.tag.indexOf(':'); + if (sep >= 0) { + L.worldId = L.tag.substr(0, sep); + L.instanceId = L.tag.substr(sep + 1); + L.instanceId.split('~').forEach((s, i) => { + if (i) { + var A = s.indexOf('('); + var Z = A >= 0 + ? s.lastIndexOf(')') + : -1; + var key = Z >= 0 + ? s.substr(0, A) + : s; + var value = A < Z + ? s.substr(A + 1, Z - A - 1) + : ''; + if (key === 'hidden') { + L.hiddenId = value; + } else if (key === 'private') { + L.privateId = value; + } else if (key === 'friends') { + L.friendsId = value; + } else if (key === 'canRequestInvite') { + L.canRequestInvite = true; + } + } else { + L.instanceName = s; + } + }); + L.accessType = 'public'; + if (L.privateId !== null) { + if (L.canRequestInvite) { + // InvitePlus + L.accessType = 'invite+'; + } else { + // InviteOnly + L.accessType = 'invite'; + } + L.userId = L.privateId; + } else if (L.friendsId !== null) { + // FriendsOnly + L.accessType = 'friends'; + L.userId = L.friendsId; + } else if (L.hiddenId !== null) { + // FriendsOfGuests + L.accessType = 'friends+'; + L.userId = L.hiddenId; + } + } else { + L.worldId = L.tag; + } + } + return L; + }; + + Vue.component('launch', { + template: '', + props: { + location: String + }, + methods: { + parse() { + var L = API.parseLocation(this.location); + this.$el.style.display = L.isOffline || L.isPrivate + ? 'none' + : ''; + }, + confirm() { + API.$emit('SHOW_LAUNCH_DIALOG', this.location); + } + }, + watch: { + location() { + this.parse(); + } + }, + mounted() { + this.parse(); + } + }); + + Vue.component('location', { + template: '{{ text }}', + props: { + location: String, + link: { + type: Boolean, + default: true + } + }, + data() { + return { + text: this.location + }; + }, + methods: { + parse() { + var L = API.parseLocation(this.location); + if (L.isOffline) { + this.text = 'Offline'; + } else if (L.isPrivate) { + this.text = 'Private'; + } else if (L.worldId) { + var ref = API.world[L.worldId]; + if (ref) { + if (L.instanceId) { + this.text = `${ref.name} #${L.instanceName} ${L.accessType}`; + } else { + this.text = ref.name; + } + } else { + API.getWorld({ + worldId: L.worldId + }).then((args) => { + if (L.tag === this.location) { + if (L.instanceId) { + this.text = `${args.ref.name} #${L.instanceName} ${L.accessType}`; + } else { + this.text = args.ref.name; + } + } + return args; + }); + } + } + }, + showWorldDialog() { + if (this.link) { + API.$emit('SHOW_WORLD_DIALOG', this.location); + } + } + }, + watch: { + location() { + this.parse(); + } + }, + created() { + this.parse(); + } + }); + + // API: User + + // changeUserName: PUT users/${userId} {displayName: string, currentPassword: string} + // changeUserEmail: PUT users/${userId} {email: string, currentPassword: string} + // changePassword: PUT users/${userId} {password: string, currentPassword: string} + // updateTOSAggreement: PUT users/${userId} {acceptedTOSVersion: number} + + // 2FA + // removeTwoFactorAuth: DELETE auth/twofactorauth + // getTwoFactorAuthpendingSecret: POST auth/twofactorauth/totp/pending -> { qrCodeDataUrl: string, secret: string } + // verifyTwoFactorAuthPendingSecret: POST auth/twofactorauth/totp/pending/verify { code: string } -> { verified: bool, enabled: bool } + // cancelVerifyTwoFactorAuthPendingSecret: DELETE auth/twofactorauth/totp/pending + // getTwoFactorAuthOneTimePasswords: GET auth/user/twofactorauth/otp -> { otp: [ { code: string, used: bool } ] } + + // Account Link + // merge: PUT auth/user/merge {mergeToken: string} + // 링크됐다면 CurrentUser에 steamId, oculusId 값이 생기는듯 + // 스팀 계정으로 로그인해도 steamId, steamDetails에 값이 생김 + + // Password Recovery + // sendLink: PUT auth/password {email: string} + // setNewPassword: PUT auth/password {emailToken: string, id: string, password: string} + + API.isLoggedIn = false; + API.currentUser = {}; + API.user = {}; + + API.$on('LOGOUT', () => { + API.isLoggedIn = false; + VRCX.DeleteAllCookies(); + }); + + API.$on('USER:CURRENT', (args) => { + args.ref = API.updateCurrentUser(args.json); + }); + + API.$on('USER:CURRENT:SAVE', (args) => { + API.$emit('USER:CURRENT', args); + }); + + API.$on('USER', (args) => { + args.ref = API.updateUser(args.json); + }); + + API.$on('USER:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('USER', { + param: { + userId: json.id + }, + json + }); + }); + }); + + API.logout = function () { + return this.call('logout', { + method: 'PUT' + }).finally(() => { + this.$emit('LOGOUT'); + }); + }; + + /* + param: { + username: string, + password: string + } + */ + API.login = function (param) { + return this.call(`auth/user?apiKey=${this.config.clientApiKey}`, { + method: 'GET', + headers: { + Authorization: `Basic ${btoa(encodeURIComponent(`${param.username}:${param.password}`).replace(/%([0-9A-F]{2})/gu, (_, s) => String.fromCharCode(parseInt(s, 16))))}` + } + }).then((json) => { + var args = { + param, + json, + origin: true + }; + if (json.requiresTwoFactorAuth) { + this.$emit('USER:2FA', args); + } else { + this.$emit('USER:CURRENT', args); + } + return args; + }); + }; + + /* + param: { + steamTicket: string + } + */ + API.loginWithSteam = function (param) { + return this.call(`auth/steam?apiKey=${this.config.clientApiKey}`, { + method: 'POST', + body: param + }).then((json) => { + var args = { + param, + json, + origin: true + }; + if (json.requiresTwoFactorAuth) { + this.$emit('USER:2FA', args); + } else { + this.$emit('USER:CURRENT', args); + } + return args; + }); + }; + + /* + param: { + code: string + } + */ + API.verifyOTP = function (param) { + return this.call('auth/twofactorauth/otp/verify', { + method: 'POST', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('OTP', args); + return args; + }); + }; + + /* + param: { + code: string + } + */ + API.verifyTOTP = function (param) { + return this.call('auth/twofactorauth/totp/verify', { + method: 'POST', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('TOTP', args); + return args; + }); + }; + + API.getCurrentUser = function () { + return this.call(`auth/user?apiKey=${this.config.clientApiKey}`, { + method: 'GET' + }).then((json) => { + var args = { + json, + origin: true + }; + if (json.requiresTwoFactorAuth) { + this.$emit('USER:2FA', args); + } else { + this.$emit('USER:CURRENT', args); + } + return args; + }); + }; + + API.updateCurrentUser = function (ref) { + var ctx; + if (this.isLoggedIn) { + ctx = this.currentUser; + Object.assign(ctx, ref); + } else { + this.isLoggedIn = true; + ctx = { + id: ref.id, + username: '', + displayName: '', + pastDisplayNames: [], + friends: [], + currentAvatarImageUrl: '', + currentAvatarThumbnailImageUrl: '', + currentAvatar: '', + homeLocation: '', + twoFactorAuthEnabled: false, + status: '', + statusDescription: '', + state: '', + tags: [], + developerType: '', + last_login: '', + last_platform: '', + allowAvatarCopying: false, + friendKey: '', + onlineFriends: [], + activeFriends: [], + offlineFriends: [], + ...ref + }; + this.currentUser = ctx; + this.$emit('LOGIN', { + json: ref, + ref: ctx + }); + } + return ctx; + }; + + /* + param: { + userId: string + } + */ + API.getUser = function (param) { + return this.call(`users/${param.userId}`, { + method: 'GET' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('USER', args); + return args; + }); + }; + + var userUpdateQueue = []; + var userUpdateTimer = false; + var queueUserUpdate = (args) => { + userUpdateQueue.push(args); + if (userUpdateTimer === false) { + userUpdateTimer = setTimeout(() => { + userUpdateTimer = false; + userUpdateQueue.forEach((v) => API.$emit('USER:UPDATE', v)); + userUpdateQueue.length = 0; + }, 1); + } + }; + + API.updateUser = function (ref) { + var ctx = this.user[ref.id]; + if (ctx) { + var prop = {}; + var key; + for (key in ctx) { + if (typeof ctx[key] !== 'object') { + prop[key] = true; + } + } + var _ctx = { ...ctx }; + Object.assign(ctx, ref); + if (ctx.location_.tag !== ctx.location) { + ctx.location_ = this.parseLocation(ctx.location); + } + for (key in ctx) { + if (typeof ctx[key] !== 'object') { + prop[key] = true; + } + } + var has = false; + for (key in prop) { + if (ctx[key] === _ctx[key]) { + delete prop[key]; + } else { + has = true; + prop[key] = [ + ctx[key], + _ctx[key] + ]; + } + } + if (has) { + if (prop.location) { + var now = Date.now(); + prop.location.push(now - ctx.location_at_); + ctx.location_at_ = now; + } + queueUserUpdate({ + ref: ctx, + prop + }); + } + } else { + ctx = { + id: ref.id, + username: '', + displayName: '', + currentAvatarImageUrl: '', + currentAvatarThumbnailImageUrl: '', + status: '', + statusDescription: '', + state: '', + tags: [], + developerType: '', + last_login: '', + last_platform: '', + allowAvatarCopying: false, + isFriend: false, + friendKey: '', + location: '', + worldId: '', + instanceId: '', + // custom + location_: {}, + location_at_: Date.now(), + admin_: false, + troll_: false, + trustLevel_: 'Visitor', + // + ...ref + }; + ctx.location_ = this.parseLocation(ctx.location); + this.user[ctx.id] = ctx; + } + ctx.admin_ = ctx.developerType && + ctx.developerType !== 'none'; + if (ctx.tags) { + ctx.admin_ = ctx.admin_ || ctx.tags.includes('admin_moderator'); + ctx.troll_ = ctx.tags.includes('system_probable_troll') || + ctx.tags.includes('system_troll'); + if (ctx.tags.includes('system_legend')) { + ctx.trustLevel_ = 'Legendary User'; + } else if (ctx.tags.includes('system_trust_legend')) { + ctx.trustLevel_ = 'Veteran User'; + } else if (ctx.tags.includes('system_trust_veteran')) { + ctx.trustLevel_ = 'Trusted User'; + } else if (ctx.tags.includes('system_trust_trusted')) { + ctx.trustLevel_ = 'Known User'; + } else if (ctx.tags.includes('system_trust_known')) { + ctx.trustLevel_ = 'User'; + } else if (ctx.tags.includes('system_trust_basic')) { + ctx.trustLevel_ = 'New User'; + } else { + ctx.trustLevel_ = 'Visitor'; + } + } + return ctx; + }; + + /* + param: { + userId: string + } + */ + API.getCachedUser = function (param) { + return new Promise((resolve, reject) => { + var ctx = this.user[param.userId]; + if (ctx) { + resolve({ + cache: true, + ref: ctx, + param + }); + } else { + this.getUser(param).catch(reject).then(resolve); + } + }); + }; + + /* + param: { + n: number, + offset: number, + search: string, + sort: string ('nuisanceFactor', 'created', '_created_at', 'last_login'), + order: string ('ascending', 'descending') + } + */ + API.getUsers = function (param) { + return this.call('users', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('USER:LIST', args); + return args; + }); + }; + + /* + param: { + status: string ('active', 'join me', 'busy', 'offline'), + statusDescription: string + } + */ + API.saveCurrentUser = function (param) { + return this.call(`users/${this.currentUser.id}`, { + method: 'PUT', + body: param + }).then((json) => { + var args = { + param, + json + }; + // FIXME: handle this + this.$emit('USER:CURRENT:SAVE', args); + return args; + }); + }; + + // API: World + + API.world = {}; + + API.$on('WORLD', (args) => { + args.ref = API.updateWorld(args.json); + }); + + API.$on('WORLD:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('WORLD', { + param: { + worldId: json.id + }, + json + }); + }); + }); + + /* + param: { + worldId: string + } + */ + API.getWorld = function (param) { + return this.call(`worlds/${param.worldId}`, { + method: 'GET' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('WORLD', args); + return args; + }); + }; + + API.updateWorld = function (ref) { + var ctx = this.world[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + name: '', + description: '', + authorId: '', + authorName: '', + capacity: 0, + tags: [], + releaseStatus: '', + imageUrl: '', + thumbnailImageUrl: '', + assetUrl: '', + assetUrlObject: {}, + pluginUrl: '', + pluginUrlObject: {}, + unityPackageUrl: '', + unityPackageUrlObject: {}, + unityPackages: [], + version: 0, + previewYoutubeId: '', + favorites: 0, + created_at: '', + updated_at: '', + publicationDate: '', + labsPublicationDate: '', + visits: 0, + popularity: 0, + heat: 0, + publicOccupants: 0, + privateOccupants: 0, + occupants: 0, + instances: [], + // custom + labs_: false, + // + ...ref + }; + this.world[ctx.id] = ctx; + } + if (ctx.tags) { + ctx.labs_ = ctx.tags.includes('system_labs'); + } + return ctx; + }; + + /* + param: { + worldId: string + } + */ + API.getCachedWorld = function (param) { + return new Promise((resolve, reject) => { + var ctx = this.world[param.worldId]; + if (ctx) { + resolve({ + cache: true, + ref: ctx, + param + }); + } else { + this.getWorld(param).catch(reject).then(resolve); + } + }); + }; + + /* + param: { + n: number, + offset: number, + search: string, + userId: string, + user: string ('me','friend') + sort: string ('popularity','heat','trust','shuffle','favorites','reportScore','reportCount','publicationDate','labsPublicationDate','created','_created_at','updated','_updated_at','order'), + order: string ('ascending','descending'), + releaseStatus: string ('public','private','hidden','all'), + featured: boolean + } + */ + API.getWorlds = function (param, option) { + var endpoint = 'worlds'; + if (option) { + endpoint = `worlds/${option}`; + } + return this.call(endpoint, { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('WORLD:LIST', args); + return args; + }); + }; + + // API: Friend + + API.friend404 = {}; + API.isFriendLoading = false; + + API.$on('LOGIN', () => { + API.friend404 = {}; + API.isFriendLoading = false; + }); + + API.$on('FRIEND:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('USER', { + param: { + userId: json.id + }, + json + }); + API.user[json.id].friend_ = true; + delete API.friend404[json.id]; + }); + }); + + API.checkFriends = function (mark) { + if (!mark) { + return this.currentUser.friends.every((id) => { + var ctx = this.user[id]; + if (ctx && + ctx.friend_) { + return true; + } + // NOTE: NaN이면 false라서 괜찮음 + return this.friend404[id] >= 2; + }); + } + this.currentUser.friends.forEach((id) => { + var ctx = this.user[id]; + if (!(ctx && + ctx.friend_)) { + var hit = Number(this.friend404[id]) || 0; + if (hit < 2) { + this.friend404[id] = hit + 1; + } + } + }); + return true; + }; + + API.refreshFriend = function () { + var param = { + n: 100, + offset: 0, + offline: false + }; + var N = this.currentUser.onlineFriends.length; + if (!N) { + N = this.currentUser.friends.length; + if (!N || + this.checkFriends(false)) { + return; + } + param.offline = true; + } + if (!this.isFriendLoading) { + this.isFriendLoading = true; + this.bulk({ + fn: 'getFriends', + N, + param, + done: (ok, options) => { + if (this.checkFriends(param.offline)) { + this.isFriendLoading = false; + } else { + N = this.currentUser.friends.length - param.offset; + if (N <= 0) { + N = this.currentUser.friends.length; + } + options.N = N; + param.offset = 0; + param.offline = true; + this.bulk(options); + } + } + }); + } + }; + + /* + param: { + n: number, + offset: number, + offline: boolean + } + */ + API.getFriends = function (param) { + return this.call('auth/user/friends', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FRIEND:LIST', args); + return args; + }); + }; + + /* + param: { + userId: string + } + */ + API.sendFriendRequest = function (param) { + return this.call(`user/${param.userId}/friendRequest`, { + method: 'POST' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FRIEND:REQUEST', args); + return args; + }); + }; + + /* + param: { + userId: string + } + */ + API.cancelFriendRequest = function (param) { + return this.call(`user/${param.userId}/friendRequest`, { + method: 'DELETE' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FRIEND:REQUEST:CANCEL', args); + return args; + }); + }; + + /* + param: { + userId: string + } + */ + API.deleteFriend = function (param) { + return this.call(`auth/user/friends/${param.userId}`, { + method: 'DELETE' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FRIEND:DELETE', args); + return args; + }); + }; + + /* + param: { + userId: string + } + */ + API.getFriendStatus = function (param) { + return this.call(`user/${param.userId}/friendStatus`, { + method: 'GET' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FRIEND:STATUS', args); + return args; + }); + }; + + // API: Avatar + + API.avatar = {}; + + API.$on('AVATAR', (args) => { + args.ref = API.updateAvatar(args.json); + }); + + API.$on('AVATAR:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('AVATAR', { + param: { + avatarId: json.id + }, + json + }); + }); + }); + + API.$on('AVATAR:SELECT', (args) => { + API.$emit('USER:CURRENT', args); + }); + + /* + param: { + avatarId: string + } + */ + API.getAvatar = function (param) { + return this.call(`avatars/${param.avatarId}`, { + method: 'GET' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('AVATAR', args); + return args; + }); + }; + + API.updateAvatar = function (ref) { + var ctx = this.avatar[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + name: '', + description: '', + authorId: '', + authorName: '', + tags: [], + assetUrl: '', + assetUrlObject: {}, + imageUrl: '', + thumbnailImageUrl: '', + releaseStatus: '', + version: 0, + unityPackages: [], + unityPackageUrl: '', + unityPackageUrlObject: {}, + created_at: '', + updated_at: '', + ...ref + }; + this.avatar[ctx.id] = ctx; + } + return ctx; + }; + + /* + param: { + avatarId: string + } + */ + API.getCachedAvatar = function (param) { + return new Promise((resolve, reject) => { + var ctx = this.avatar[param.avatarId]; + if (ctx) { + resolve({ + cache: true, + ref: ctx, + param + }); + } else { + this.getAvatar(param).catch(reject).then(resolve); + } + }); + }; + + /* + param: { + n: number, + offset: number, + search: string, + userId: string, + user: string ('me','friends') + sort: string ('created','updated','order','_created_at','_updated_at'), + order: string ('ascending','descending'), + releaseStatus: string ('public','private','hidden','all'), + featured: boolean + } + */ + API.getAvatars = function (param) { + return this.call('avatars', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('AVATAR:LIST', args); + return args; + }); + }; + + /* + param: { + avatarId: string + } + */ + API.selectAvatar = function (param) { + return this.call(`avatars/${param.avatarId}/select`, { + method: 'PUT', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('AVATAR:SELECT', args); + return args; + }); + }; + + // API: Notification + + API.notification = {}; + API.isNotificationLoading = false; + + API.$on('LOGIN', () => { + API.notification = {}; + API.isNotificationLoading = false; + }); + + API.$on('NOTIFICATION', (args) => { + args.ref = API.updateNotification(args.json); + }); + + API.$on('NOTIFICATION:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('NOTIFICATION', { + param: { + notificationId: json.id + }, + json + }); + }); + }); + + API.$on('NOTIFICATION:ACCEPT', (args) => { + var ctx = API.notification[args.param.notificationId]; + if (ctx && + !ctx.hide_) { + ctx.hide_ = true; + args.ref = ctx; + API.$emit('NOTIFICATION:@DELETE', { + param: { + notificationId: ctx.id + }, + ref: ctx + }); + API.$emit('FRIEND:ADD', { + param: { + userId: ctx.senderUserId + } + }); + } + }); + + API.$on('NOTIFICATION:HIDE', (args) => { + var ctx = API.notification[args.param.notificationId]; + if (ctx && + !ctx.hide_) { + ctx.hide_ = true; + args.ref = ctx; + API.$emit('NOTIFICATION:@DELETE', { + param: { + notificationId: ctx.id + }, + ref: ctx + }); + } + }); + + API.markAllNotificationsAsExpired = function () { + for (var key in this.notification) { + var ctx = this.notification[key]; + if (!ctx.hide_) { + ctx.expired_ = true; + } + } + }; + + API.checkExpiredNotifcations = function () { + for (var key in this.notification) { + var ctx = this.notification[key]; + if (ctx.expired_ && + !ctx.hide_) { + ctx.hide_ = true; + this.$emit('NOTIFICATION:@DELETE', { + param: { + notificationId: ctx.id + }, + ref: ctx + }); + } + } + }; + + API.refreshNotification = function () { + // NOTE : 캐시 때문에 after=~ 로는 갱신이 안됨. 그래서 첨부터 불러옴 + if (!this.isNotificationLoading) { + this.isNotificationLoading = true; + this.markAllNotificationsAsExpired(); + this.bulk({ + fn: 'getNotifications', + N: -1, + param: { + n: 100, + offset: 0 + }, + done: (ok) => { + if (ok) { + this.checkExpiredNotifcations(); + } + this.isNotificationLoading = false; + } + }); + } + }; + + API.updateNotification = function (ref) { + var ctx = this.notification[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + senderUserId: '', + senderUsername: '', + type: '', + message: '', + details: {}, + seen: false, + created_at: '', + ...ref + }; + this.notification[ctx.id] = ctx; + } + if (typeof ctx.details !== 'object') { + var details = {}; + try { + var json = JSON.parse(ctx.details); + if (typeof json === 'object') { + details = json; + } + } catch (err) { + console.error(err); + } + ctx.details = details; + } + ctx.expired_ = false; + return ctx; + }; + + /* + param: { + n: number, + offset: number, + sent: boolean, + type: string, + after: string (ISO8601 or 'five_minutes_ago') + } + */ + API.getNotifications = function (param) { + return this.call('auth/user/notifications', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('NOTIFICATION:LIST', args); + return args; + }); + }; + + API.clearNotification = function () { + return this.call('auth/user/notifications/clear', { + method: 'PUT' + }).then((json) => { + var args = { + json + }; + // FIXME: 고쳐줘 + this.$emit('NOTIFICATION:CLEAR', args); + return args; + }); + }; + + /* + param: { + receiverUserId: string, + type: string, + message: string, + seen: boolean, + details: json-string + } + */ + API.sendNotification = function (param) { + return this.call(`user/${param.receiverUserId}/notification`, { + method: 'POST', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('NOTIFICATION:SEND', args); + return args; + }); + }; + + /* + param: { + notificationId: string + } + */ + API.acceptNotification = function (param) { + return this.call(`auth/user/notifications/${param.notificationId}/accept`, { + method: 'PUT' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('NOTIFICATION:ACCEPT', args); + return args; + }); + }; + + /* + param: { + notificationId: string + } + */ + API.hideNotification = function (param) { + return this.call(`auth/user/notifications/${param.notificationId}/hide`, { + method: 'PUT' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('NOTIFICATION:HIDE', args); + return args; + }); + }; + + API.getFriendRequest = function (userId) { + for (var key in this.notification) { + var ctx = this.notification[key]; + if (ctx.type === 'friendRequest' && + ctx.senderUserId === userId && + !ctx.hide_) { + return key; + } + } + return ''; + }; + + // API: PlayerModeration + + API.playerModeration = {}; + API.isPlayerModerationLoading = false; + + API.$on('LOGIN', () => { + API.playerModeration = {}; + API.isPlayerModerationLoading = false; + }); + + API.$on('PLAYER-MODERATION', (args) => { + args.ref = API.updatePlayerModeration(args.json); + }); + + API.$on('PLAYER-MODERATION:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('PLAYER-MODERATION', { + param: { + playerModerationId: json.id + }, + json + }); + }); + }); + + API.$on('PLAYER-MODERATION:SEND', (args) => { + API.$emit('PLAYER-MODERATION', { + param: { + playerModerationId: args.json.id + }, + json: args.json + }); + }); + + API.$on('PLAYER-MODERATION:DELETE', (args) => { + API.handleDeletePlayerModeration(args.param.type, args.param.moderated); + }); + + API.markAllPlayerModerationsAsExpired = function () { + for (var key in this.playerModeration) { + var ctx = this.playerModeration[key]; + if (!ctx.hide_) { + ctx.expired_ = true; + } + } + }; + + API.checkExpiredPlayerModerations = function () { + for (var key in this.playerModeration) { + var ctx = this.playerModeration[key]; + if (ctx.expired_ && + !ctx.hide_) { + ctx.hide_ = true; + this.$emit('PLAYER-MODERATION:@DELETE', { + param: { + playerModerationId: ctx.id + }, + ref: ctx + }); + } + } + }; + + API.refreshPlayerModeration = function () { + if (!this.isPlayerModerationLoading) { + this.isPlayerModerationLoading = true; + this.markAllPlayerModerationsAsExpired(); + Promise.all([ + this.getPlayerModerations(), + this.getPlayerModerationsAgainstMe() + ]).finally(() => { + this.isPlayerModerationLoading = false; + }).then(() => { + this.checkExpiredPlayerModerations(); + }); + } + }; + + API.handleDeletePlayerModeration = function (type, moderated) { + var cuid = this.currentUser.id; + for (var key in this.playerModeration) { + var ctx = this.playerModeration[key]; + if (ctx.type === type && + ctx.targetUserId === moderated && + ctx.sourceUserId === cuid && + !ctx.hide_) { + ctx.hide_ = true; + this.$emit('PLAYER-MODERATION:@DELETE', { + param: { + playerModerationId: ctx.id + }, + ref: ctx + }); + } + } + }; + + API.updatePlayerModeration = function (ref) { + var ctx = this.playerModeration[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + type: '', + sourceUserId: '', + sourceDisplayName: '', + targetUserId: '', + targetDisplayName: '', + created: '', + ...ref + }; + this.playerModeration[ctx.id] = ctx; + } + ctx.expired_ = false; + return ctx; + }; + + API.getPlayerModerations = function () { + return this.call('auth/user/playermoderations', { + method: 'GET' + }).then((json) => { + var args = { + json + }; + this.$emit('PLAYER-MODERATION:LIST', args); + return args; + }); + }; + + API.getPlayerModerationsAgainstMe = function () { + return this.call('auth/user/playermoderated', { + method: 'GET' + }).then((json) => { + var args = { + json + }; + this.$emit('PLAYER-MODERATION:LIST', args); + return args; + }); + }; + + /* + param: { + moderated: string, + type: string + } + */ + // old-way: POST auth/user/blocks {blocked:userId} + API.sendPlayerModeration = function (param) { + return this.call('auth/user/playermoderations', { + method: 'POST', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('PLAYER-MODERATION:SEND', args); + return args; + }); + }; + + /* + param: { + moderated: string, + type: string + } + */ + // old-way: PUT auth/user/unblocks {blocked:userId} + API.deletePlayerModeration = function (param) { + return this.call('auth/user/unplayermoderate', { + method: 'PUT', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('PLAYER-MODERATION:DELETE', args); + return args; + }); + }; + + // API: Favorite + + API.favorite = {}; + API.favoriteGroup = {}; + API.favoriteObject = {}; + API.favoriteFriendGroups = []; + API.favoriteWorldGroups = []; + API.favoriteAvatarGroups = []; + API.isFavoriteLoading = false; + API.isFavoriteGroupLoading = false; + + API.$on('LOGIN', () => { + API.favorite = {}; + API.favoriteGroup = {}; + API.favoriteObject = {}; + API.favoriteFriendGroups = []; + API.favoriteWorldGroups = []; + API.favoriteAvatarGroups = []; + API.isFavoriteLoading = false; + API.isFavoriteGroupLoading = false; + API.refreshFavorite(); + }); + + API.$on('FAVORITE', (args) => { + var ref = API.updateFavorite(args.json); + args.ref = ref; + if (!ref.hide_ && + API.favoriteObject[ref.favoriteId] !== ref) { + API.favoriteObject[ref.favoriteId] = ref; + if (ref.type === 'friend') { + API.favoriteFriendGroups.find((ctx) => { + if (ctx.name === ref.group_) { + ++ctx.count; + return true; + } + return false; + }); + } else if (ref.type === 'world') { + API.favoriteWorldGroups.find((ctx) => { + if (ctx.name === ref.group_) { + ++ctx.count; + return true; + } + return false; + }); + } else if (ref.type === 'avatar') { + API.favoriteAvatarGroups.find((ctx) => { + if (ctx.name === ref.group_) { + ++ctx.count; + return true; + } + return false; + }); + } + } + }); + + API.$on('FAVORITE:@DELETE', (args) => { + var { ref } = args; + if (API.favoriteObject[ref.favoriteId]) { + delete API.favoriteObject[ref.favoriteId]; + if (ref.type === 'friend') { + API.favoriteFriendGroups.find((ctx) => { + if (ctx.name === ref.group_) { + --ctx.count; + return true; + } + return false; + }); + } else if (ref.type === 'world') { + API.favoriteWorldGroups.find((ctx) => { + if (ctx.name === ref.group_) { + --ctx.count; + return true; + } + return false; + }); + } else if (ref.type === 'avatar') { + API.favoriteAvatarGroups.find((ctx) => { + if (ctx.name === ref.group_) { + --ctx.count; + return true; + } + return false; + }); + } + } + }); + + API.$on('FAVORITE:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('FAVORITE', { + param: { + favoriteId: json.id + }, + json + }); + }); + }); + + API.$on('FAVORITE:ADD', (args) => { + API.$emit('FAVORITE', { + param: { + favoriteId: args.json.id + }, + json: args.json + }); + }); + + API.$on('FAVORITE:DELETE', (args) => { + API.handleDeleteFavorite(args.param.objectId); + }); + + API.$on('FAVORITE:GROUP', (args) => { + var ref = API.updateFavoriteGroup(args.json); + args.ref = ref; + if (!ref.hide_) { + if (ref.type === 'friend') { + API.favoriteFriendGroups.find((ctx) => { + if (ctx.name === ref.name) { + ctx.displayName = ref.displayName; + return true; + } + return false; + }); + } else if (ref.type === 'world') { + API.favoriteWorldGroups.find((ctx) => { + if (ctx.name === ref.name) { + ctx.displayName = ref.displayName; + return true; + } + return false; + }); + } else if (ref.type === 'avatar') { + API.favoriteAvatarGroups.find((ctx) => { + if (ctx.name === ref.name) { + ctx.displayName = ref.displayName; + return true; + } + return false; + }); + } + } + }); + + API.$on('FAVORITE:GROUP:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('FAVORITE:GROUP', { + param: { + favoriteGroupId: json.id + }, + json + }); + }); + }); + + API.$on('FAVORITE:GROUP:SAVE', (args) => { + API.$emit('FAVORITE:GROUP', { + param: { + favoriteGroupId: args.json.id + }, + json: args.json + }); + }); + + API.$on('FAVORITE:GROUP:CLEAR', (args) => { + API.handleClearFavoriteGroup(args.param.group); + }); + + API.$on('FAVORITE:FRIEND:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('USER', { + param: { + userId: json.id + }, + json + }); + }); + }); + + API.$on('FAVORITE:WORLD:LIST', (args) => { + args.json.forEach((json) => { + if (json.id !== '???') { + // FIXME + // json.favoriteId로 따로 불러와야 하나? + // 근데 ???가 많으면 과다 요청이 될듯 + API.$emit('WORLD', { + param: { + worldId: json.id + }, + json + }); + } + }); + }); + + API.$on('FAVORITE:AVATAR:LIST', (args) => { + args.json.forEach((json) => { + if (json.releaseStatus !== 'hidden') { + // NOTE: 얘는 또 더미 데이터로 옴 + API.$emit('AVATAR', { + param: { + avatarId: json.id + }, + json + }); + } + }); + }); + + API.markAllFavoritesAsExpired = function () { + for (var key in this.favorite) { + var ctx = this.favorite[key]; + if (!ctx.hide_) { + ctx.expired_ = true; + } + } + }; + + API.checkExpiredFavorites = function () { + for (var key in this.favorite) { + var ctx = this.favorite[key]; + if (ctx.expired_ && + !ctx.hide_) { + ctx.hide_ = true; + this.$emit('FAVORITE:@DELETE', { + param: { + favoriteId: ctx.id + }, + ref: ctx + }); + } + } + }; + + API.refreshFavorite = function () { + if (!this.isFavoriteLoading) { + this.isFavoriteLoading = true; + this.markAllFavoritesAsExpired(); + this.bulk({ + fn: 'getFavorites', + N: -1, + param: { + n: 100, + offset: 0 + }, + done: (ok) => { + if (ok) { + this.checkExpiredFavorites(); + } + this.refreshFavoriteGroup(); + this.refreshFavoriteFriends(); + this.refreshFavoriteWorlds(); + this.refreshFavoriteAvatars(); + this.isFavoriteLoading = false; + } + }); + } + }; + + API.refreshFavoriteFriends = function () { + var N = 0; + for (var key in this.favorite) { + var ctx = this.favorite[key]; + if (ctx.type === 'friend' && + !ctx.hide_) { + ++N; + } + } + if (N) { + this.bulk({ + fn: 'getFavoriteFriends', + N, + param: { + n: 100, + offset: 0 + } + }); + } + }; + + API.refreshFavoriteWorlds = function () { + var N = 0; + for (var key in this.favorite) { + var ctx = this.favorite[key]; + if (ctx.type === 'world' && + !ctx.hide_) { + ++N; + } + } + if (N) { + this.bulk({ + fn: 'getFavoriteWorlds', + N, + param: { + n: 100, + offset: 0 + } + }); + } + }; + + API.refreshFavoriteAvatars = function () { + var N = 0; + for (var key in this.favorite) { + var ctx = this.favorite[key]; + if (ctx.type === 'avatar' && + !ctx.hide_) { + ++N; + } + } + if (N) { + this.bulk({ + fn: 'getFavoriteAvatars', + N, + param: { + n: 100, + offset: 0 + } + }); + } + }; + + API.markAllFavoriteGroupsAsExpired = function () { + for (var key in this.favoriteGroup) { + var ctx = this.favoriteGroup[key]; + if (!ctx.hide_) { + ctx.expired_ = true; + } + } + }; + + API.checkExpiredFavoriteGroups = function () { + for (var key in this.favoriteGroup) { + var ctx = this.favoriteGroup[key]; + if (ctx.expired_ && + !ctx.hide_) { + ctx.hide_ = true; + this.$emit('FAVORITE:GROUP:@DELETE', { + param: { + favoriteGroupId: ctx.id + }, + ref: ctx + }); + } + } + }; + + API.resetFavoriteGroup = function () { + var i; + // 96 = ['group_0', 'group_1', 'group_2'] x 32 + this.favoriteFriendGroups = []; + for (i = 0; i < 3; ++i) { + this.favoriteFriendGroups.push({ + type: 'friend', + name: `group_${i}`, + displayName: `Group ${i + 1}`, + capacity: 32, + count: 0 + }); + } + // 128 = ['worlds1', 'worlds2', 'worlds3', 'worlds4'] x 32 + this.favoriteWorldGroups = []; + for (i = 0; i < 4; ++i) { + this.favoriteWorldGroups.push({ + type: 'world', + name: `worlds${i + 1}`, + displayName: `Group ${i + 1}`, + capacity: 32, + count: 0 + }); + } + // 16 = ['avatars1'] x 16 + this.favoriteAvatarGroups = []; + for (i = 0; i < 1; ++i) { + this.favoriteAvatarGroups.push({ + type: 'avatar', + name: `avatars${i + 1}`, + displayName: `Group ${i + 1}`, + capacity: 16, + count: 0 + }); + } + }; + + API.assignFavoriteGroup = function () { + var assign = []; + var set1 = function (array, ref) { + if (!assign[ref.id]) { + array.find((ctx) => { + if (ctx.name === ref.name && + !ctx.assign_) { + ctx.assign_ = true; + ctx.displayName = ref.displayName; + assign[ref.id] = true; + return true; + } + return false; + }); + } + }; + var set2 = function (array, ref) { + if (!assign[ref.id]) { + array.find((ctx) => { + if (!ctx.assign_) { + ctx.assign_ = true; + ctx.name = ref.name; + ctx.displayName = ref.displayName; + assign[ref.id] = true; + return true; + } + return false; + }); + } + }; + var key; + var ctx; + for (key in this.favoriteGroup) { + ctx = this.favoriteGroup[key]; + if (!ctx.hide_) { + if (ctx.type === 'friend') { + set1(this.favoriteFriendGroups, ctx); + } else if (ctx.type === 'world') { + set1(this.favoriteWorldGroups, ctx); + } else if (ctx.type === 'avatar') { + set1(this.favoriteAvatarGroups, ctx); + } + } + } + for (key in this.favoriteGroup) { + ctx = this.favoriteGroup[key]; + if (!ctx.hide_) { + if (ctx.type === 'friend') { + set2(this.favoriteFriendGroups, ctx); + } else if (ctx.type === 'world') { + set2(this.favoriteWorldGroups, ctx); + } else if (ctx.type === 'avatar') { + set2(this.favoriteAvatarGroups, ctx); + } + } + } + for (key in this.favorite) { + ctx = this.favorite[key]; + if (!ctx.hide_) { + if (ctx.type === 'friend') { + // eslint-disable-next-line no-loop-func + this.favoriteFriendGroups.find((ref) => { + if (ref.name === ctx.group_) { + ++ref.count; + return true; + } + return false; + }); + } else if (ctx.type === 'world') { + // eslint-disable-next-line no-loop-func + this.favoriteWorldGroups.find((ref) => { + if (ref.name === ctx.group_) { + ++ref.count; + return true; + } + return false; + }); + } else if (ctx.type === 'avatar') { + // eslint-disable-next-line no-loop-func + this.favoriteAvatarGroups.find((ref) => { + if (ref.name === ctx.group_) { + ++ref.count; + return true; + } + return false; + }); + } + } + } + }; + + API.refreshFavoriteGroup = function () { + if (!this.isFavoriteGroupLoading) { + this.isFavoriteGroupLoading = true; + this.markAllFavoriteGroupsAsExpired(); + this.bulk({ + fn: 'getFavoriteGroups', + N: -1, + param: { + n: 100, + offset: 0 + }, + done: (ok) => { + if (ok) { + this.checkExpiredFavoriteGroups(); + this.resetFavoriteGroup(); + this.assignFavoriteGroup(); + } + this.isFavoriteGroupLoading = false; + } + }); + } + }; + + API.handleDeleteFavorite = function (objectId) { + for (var key in this.favorite) { + var ctx = this.favorite[key]; + if (ctx.favoriteId === objectId && + !ctx.hide_) { + ctx.hide_ = true; + API.$emit('FAVORITE:@DELETE', { + param: { + favoriteId: ctx.id + }, + ref: ctx + }); + } + } + }; + + API.updateFavorite = function (ref) { + var ctx = this.favorite[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + type: '', + favoriteId: '', + tags: [], + // custom + group_: '', + // + ...ref + }; + this.favorite[ctx.id] = ctx; + } + ctx.expired_ = false; + if (ctx.tags) { + [ctx.group_] = ctx.tags; + } + return ctx; + }; + + /* + param: { + n: number, + offset: number, + type: string, + tag: string + } + */ + API.getFavorites = function (param) { + return this.call('favorites', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:LIST', args); + return args; + }); + }; + + /* + param: { + type: string, + favoriteId: string (objectId), + tags: string + } + */ + API.addFavorite = function (param) { + return this.call('favorites', { + method: 'POST', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:ADD', args); + return args; + }); + }; + + /* + param: { + objectId: string + } + */ + API.deleteFavorite = function (param) { + return this.call(`favorites/${param.objectId}`, { + method: 'DELETE' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:DELETE', args); + return args; + }); + }; + + API.updateFavoriteGroup = function (ref) { + var ctx = this.favoriteGroup[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + ownerId: '', + ownerDisplayName: '', + name: '', + displayName: '', + type: '', + visibility: '', + tags: [], + ...ref + }; + this.favoriteGroup[ctx.id] = ctx; + } + ctx.expired_ = false; + return ctx; + }; + + /* + param: { + n: number, + offset: number, + type: string + } + */ + API.getFavoriteGroups = function (param) { + return this.call('favorite/groups', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:GROUP:LIST', args); + return args; + }); + }; + + /* + param: { + type: string, + group: string (name), + displayName: string, + visibility: string + } + */ + API.saveFavoriteGroup = function (param) { + return this.call(`favorite/group/${param.type}/${param.group}/${this.currentUser.id}`, { + method: 'PUT', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:GROUP:SAVE', args); + return args; + }); + }; + + /* + param: { + type: string, + group: string (name) + } + */ + API.clearFavoriteGroup = function (param) { + return this.call(`favorite/group/${param.type}/${param.group}/${this.currentUser.id}`, { + method: 'DELETE', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:GROUP:CLEAR', args); + return args; + }); + }; + + API.handleClearFavoriteGroup = function (name) { + for (var key in this.favorite) { + var ctx = this.favorite[key]; + if (ctx.group_ === name && + !ctx.hide_) { + ctx.hide_ = true; + API.$emit('FAVORITE:@DELETE', { + param: { + favoriteId: ctx.id + }, + ref: ctx + }); + } + } + }; + + /* + param: { + n: number, + offset: number + } + */ + API.getFavoriteFriends = function (param) { + return this.call('auth/user/friends/favorite', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:FRIEND:LIST', args); + return args; + }); + }; + + /* + param: { + n: number, + offset: number + } + */ + API.getFavoriteWorlds = function (param) { + return this.call('worlds/favorites', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:WORLD:LIST', args); + return args; + }); + }; + + /* + param: { + n: number, + offset: number + } + */ + API.getFavoriteAvatars = function (param) { + return this.call('avatars/favorites', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FAVORITE:AVATAR:LIST', args); + return args; + }); + }; + + // API: Feedback + + API.feedback = {}; + API.isFeedbackLoading = false; + + API.$on('LOGIN', () => { + API.feedback = {}; + API.isFeedbackLoading = false; + }); + + API.$on('FEEDBACK', (args) => { + args.ref = API.updateFeedback(args.json); + }); + + API.$on('FEEDBACK:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('FEEDBACK', { + param: { + feedbackId: json.id + }, + json + }); + }); + }); + + API.$on('FEEDBACK:DELETE', (args) => { + var ctx = API.feedback[args.param.feedbackId]; + if (ctx && + !ctx.hide_) { + ctx.hide_ = true; + args.ref = ctx; + API.$emit('FEEDBACK:@DELETE', { + param: { + feedbackId: ctx.id + }, + ref: ctx + }); + } + }); + + API.markAllFeedbacksAsExpired = function () { + for (var key in this.feedback) { + var ctx = this.feedback[key]; + if (!ctx.hide_) { + ctx.expired_ = true; + } + } + }; + + API.checkExpiredFeedbacks = function () { + for (var key in this.feedback) { + var ctx = this.feedback[key]; + if (ctx.expired_ && + !ctx.hide_) { + ctx.hide_ = true; + this.$emit('FEEDBACK:@DELETE', { + param: { + feedbackId: ctx.id + }, + ref: ctx + }); + } + } + }; + + API.refreshFeedback = function () { + if (!this.isFeedbackLoading) { + this.isFeedbackLoading = true; + this.markAllFeedbacksAsExpired(); + this.bulk({ + fn: 'getFeedbacks', + N: -1, + param: { + n: 100, + offset: 0 + }, + done: (ok) => { + if (ok) { + this.checkExpiredFeedbacks(); + } + this.isFeedbackLoading = false; + } + }); + } + }; + + API.updateFeedback = function (ref) { + var ctx = this.feedback[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + type: '', + reason: '', + commenterId: '', + commenterName: '', + contentId: '', + contentType: '', + contentVersion: '', + contentName: '', + contentAuthorId: '', + contentAuthorName: '', + tags: [], + ...ref + }; + this.feedback[ctx.id] = ctx; + } + ctx.expired_ = false; + return ctx; + }; + + /* + param: { + n: number, + offset: number + } + */ + API.getFeedbacks = function (param) { + return this.call(`users/${this.currentUser.id}/feedback`, { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FEEDBACK:LIST', args); + return args; + }); + }; + + /* + param: { + feedbackId: string + } + */ + API.deleteFeedback = function (param) { + return this.call(`feedback/${param.feedbackId}`, { + method: 'DELETE', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('FEEDBACK:DELETE', args); + return args; + }); + }; + + // API: Thing + + API.thing = {}; + API.isThingLoading = false; + + API.$on('LOGIN', () => { + API.thing = {}; + API.isThingLoading = false; + }); + + API.$on('THING', (args) => { + args.ref = API.updateThing(args.json); + }); + + API.$on('THING:LIST', (args) => { + args.json.forEach((json) => { + API.$emit('THING', { + param: { + thingId: json.id + }, + json + }); + }); + }); + + API.$on('THING:ADD', (args) => { + API.$emit('THING', { + param: { + thingId: args.json.id + }, + json: args.json + }); + }); + + API.$on('THING:SAVE', (args) => { + API.$emit('THING', { + param: { + thingId: args.json.id + }, + json: args.json + }); + }); + + API.$on('THING:DELETE', (args) => { + var ctx = API.thing[args.param.thingId]; + if (ctx && + !ctx.hide_) { + ctx.hide_ = true; + args.ref = ctx; + API.$emit('THING:@DELETE', { + param: { + thingId: ctx.id + }, + ref: ctx + }); + } + }); + + API.markAllThingsAsExpired = function () { + for (var key in this.thing) { + var ctx = this.thing[key]; + if (!ctx.hide_) { + ctx.expired_ = true; + } + } + }; + + API.checkExpiredThings = function () { + for (var key in this.thing) { + var ctx = this.thing[key]; + if (ctx.expired_ && + !ctx.hide_) { + ctx.hide_ = true; + this.$emit('THING:@DELETE', { + param: { + thingId: ctx.id + }, + ref: ctx + }); + } + } + }; + + API.refreshThing = function () { + if (!this.isThingLoading) { + this.isThingLoading = true; + this.markAllThingsAsExpired(); + this.bulk({ + fn: 'getThings', + N: -1, + param: { + n: 100, + offset: 0 + }, + done: (ok) => { + if (ok) { + this.checkExpiredThings(); + } + this.isThingLoading = false; + } + }); + } + }; + + API.updateThing = function (ref) { + var ctx = this.thing[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + ownerId: '', + ownerDisplayName: '', + thingProperty: '', + otherThingProperty: '', + tags: [], + ...ref + }; + this.thing[ctx.id] = ctx; + } + ctx.expired_ = false; + }; + + /* + param: { + n: number, + offset: number + } + */ + API.getThings = function (param) { + return this.call('things', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('THING:LIST', args); + return args; + }); + }; + + /* + param: { + thingId: string, + thingProperty: string, + tags: string + } + */ + API.addThing = function (param) { + return this.call('things', { + method: 'POST', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('THING:ADD', args); + return args; + }); + }; + + /* + param: { + thingId: string, + thingProperty: string, + tags: string + } + */ + API.saveThing = function (param) { + return this.call(`things/${param.thingId}`, { + method: 'PUT', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('THING:SAVE', args); + return args; + }); + }; + + /* + param: { + thingId: string + } + */ + API.deleteThing = function (param) { + return this.call(`things/${param.thingId}`, { + method: 'DELETE', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('THING:DELETE', args); + return args; + }); + }; + + // API: WebSocket + + API.webSocket = false; + + API.$on('LOGOUT', () => { + API.closeWebSocket(); + }); + + API.$on('USER:CURRENT', () => { + if (API.webSocket === false) { + API.getAuth(); + } + }); + + API.$on('AUTH', (args) => { + if (args.json.ok) { + API.connectWebSocket(args.json.token); + } + }); + + API.$on('PIPELINE', (args) => { + var { type, content } = args.json; + switch (type) { + case 'notification': + API.$emit('NOTIFICATION', { + param: { + notificationId: content.id + }, + json: content + }); + break; + + case 'friend-add': + API.$emit('USER', { + param: { + userId: content.userId + }, + json: content.user + }); + API.$emit('FRIEND:ADD', { + param: { + userId: content.userId + } + }); + break; + + case 'friend-delete': + API.$emit('FRIEND:DELETE', { + param: { + userId: content.userId + } + }); + break; + + case 'friend-online': + API.$emit('USER', { + param: { + userId: content.userId + }, + json: { + location: content.location, + ...content.user + } + }); + API.$emit('FRIEND:STATE', { + param: { + userId: content.userId + }, + json: { + state: 'online' + } + }); + break; + + case 'friend-active': + API.$emit('USER', { + param: { + userId: content.userId + }, + json: content.user + }); + API.$emit('FRIEND:STATE', { + param: { + userId: content.userId + }, + json: { + state: 'active' + } + }); + break; + + case 'friend-offline': + API.$emit('FRIEND:STATE', { + param: { + userId: content.userId + }, + json: { + state: 'offline' + } + }); + break; + + case 'friend-update': + API.$emit('USER', { + param: { + userId: content.userId + }, + json: content.user + }); + break; + + case 'user-update': + API.$emit('USER:CURRENT', { + param: { + userId: content.userId + }, + json: content.user + }); + break; + } + }); + + API.getAuth = function () { + return this.call('auth', { + method: 'GET' + }).then((json) => { + var args = { + json + }; + this.$emit('AUTH', args); + return args; + }); + }; + + API.connectWebSocket = function (token) { + if (this.webSocket === false) { + var socket = new WebSocket(`wss://pipeline.vrchat.cloud/?auth=${token}`); + socket.onclose = () => { + if (this.webSocket === socket) { + this.webSocket = false; + } + try { + socket.close(); + } catch (err) { + console.error(err); + } + }; + socket.onerror = socket.onclose; + socket.onmessage = (e) => { + try { + var json = JSON.parse(e.data); + if (json.content) { + json.content = JSON.parse(json.content); + } + this.$emit('PIPELINE', { + json + }); + } catch (err) { + console.error(err); + } + }; + this.webSocket = socket; + } + }; + + API.closeWebSocket = function () { + if (this.webSocket !== false) { + var socket = this.webSocket; + this.webSocket = false; + try { + socket.close(); + } catch (err) { + console.error(err); + } + } + }; + + // API: Visit + + API.getVisits = function () { + return this.call('visits', { + method: 'GET' + }).then((json) => { + var args = { + json + }; + this.$emit('VISITS', args); + return args; + }); + }; + + // API: Time + + API.getServerTime = function () { + return this.call('time', { + method: 'GET' + }).then((json) => { + var args = { + json + }; + this.$emit('TIME', args); + return args; + }); + }; + + // API: Youtube + + /* + param = { + q: string, + type: string ('video'), + safeSearch: string ('strict'), + maxResults: number (25), + part: string ('snippet') + } + */ + API.youtube = function (param) { + return this.call('youtube', { + method: 'GET', + body: param + }).then((json) => { + var args = { + param, + json + }; + this.$emit('YOUTUBE', args); + return args; + }); + }; + + // API: Events + + // deprecated: moved to user's property + API.getEvents = function () { + return this.call('events', { + method: 'GET' + }).then((json) => { + var args = { + json + }; + this.$emit('EVENTS', args); + return args; + }); + }; + + // API + + var extractFileId = (s) => { + var match = String(s).match(/file_[0-9A-Za-z-]+/u); + return match + ? match[0] + : ''; + }; + + // Misc + + var $timers = []; + + Vue.component('timer', { + template: '', + props: { + epoch: { + type: Number, + default() { + return Date.now(); + } + } + }, + data() { + return { + text: '' + }; + }, + methods: { + update() { + this.text = timeToText(Date.now() - this.epoch); + } + }, + watch: { + date() { + this.update(); + } + }, + mounted() { + $timers.push(this); + this.update(); + }, + destroyed() { + removeFromArray($timers, this); + } + }); + + setInterval(() => { + $timers.forEach((v) => v.update()); + }, 5000); + + var $app = { + data: { + API, + VRCX, + nextRefresh: 0, + isGameRunning: false, + appVersion: '2019.08.16', + latestAppVersion: '', + ossDialog: false + }, + computed: {}, + methods: {}, + watch: {}, + el: '#x-app', + mounted() { + LogWatcher.Reset().then(() => { + API.$on('SHOW_WORLD_DIALOG', (tag) => this.showWorldDialog(tag)); + API.$on('SHOW_LAUNCH_DIALOG', (tag) => this.showLaunchDialog(tag)); + setInterval(() => this.update(), 1000); + this.update(); + this.$nextTick(() => { + this.$el.style.display = ''; + this.loginForm.loading = true; + API.getConfig().catch((err) => { + this.loginForm.loading = false; + throw err; + }).then((args) => { + API.getCurrentUser().finally(() => { + this.loginForm.loading = false; + }); + return args; + }); + }); + }); + this.checkAppVersion(); + } + }; + + $app.methods.checkAppVersion = function () { + var url = 'https://api.github.com/repos/pypy-vrc/VRCX/releases/latest'; + fetch(url).then((res) => res.json()).then((json) => { + if (json.name && + json.published_at) { + this.latestAppVersion = `${json.name} (${formatDate(json.published_at, 'YYYY-MM-DD HH24:MI:SS')})`; + } else { + this.latestAppVersion = 'Error occured'; + } + }); + }; + + var insertOrUpdateArrayById = (array, json) => { + var insertOrUpdate = array.some((val, idx, arr) => { + if (val.id === json.id) { + $app.$set(arr, idx, json); + return true; + } + return false; + }); + if (!insertOrUpdate) { + array.push(json); + } + }; + + $app.methods.update = function () { + if (API.isLoggedIn) { + if (--this.nextRefresh <= 0) { + this.nextRefresh = 60; + API.getCurrentUser().catch((err1) => { + if (err1.status_code === 401) { + API.getConfig().then((args) => { + API.login({ + username: this.loginForm.username, + password: this.loginForm.password + }).catch((err2) => { + if (err2.status_code === 401) { + API.logout(); + } + throw err2; + }); + return args; + }); + } + throw err1; + }); + } + this.refreshGameLog(); + VRCX.IsGameRunning().then((running) => { + if (this.isGameRunning !== running) { + this.isGameRunning = running; + Discord.SetTimestamps(Date.now(), 0); + } + this.updateDiscord(); + this.updateOpenVR(); + }); + } + }; + + $app.methods.updateSharedFeed = function () { + var arr = []; + var ref; + var i; + var j; + i = this.gameLogTable.data.length; + j = 0; + while (j < 25) { + if (i <= 0) { + break; + } + ref = this.gameLogTable.data[--i]; + // Location, OnPlayerJoined, OnPlayerLeft + if (ref.type) { + // FIXME: 이거 존나 느릴거 같은데 + var isFriend = false; + var isFavorite = false; + for (var key in API.user) { + var ctx = API.user[key]; + if (ctx.displayName === ref.data) { + isFriend = Boolean(this.friend[ctx.id]); + isFavorite = Boolean(API.favoriteObject[ctx.id]); + break; + } + } + arr.push({ + ...ref, + isFriend, + isFavorite + }); + } else { + arr.push(ref); + } + ++j; + } + i = this.feedTable.data.length; + j = 0; + while (j < 25) { + if (i <= 0) { + break; + } + ref = this.feedTable.data[--i]; + // GPS, Online, Offline, Status, Avatar + if (ref.type !== 'Avatar') { + arr.push({ + ...ref, + isFriend: Boolean(this.friend[ref.userId]), + isFavorite: Boolean(API.favoriteObject[ref.userId]) + }); + ++j; + } + } + arr.sort((a, b) => { + if (a.created_at < b.created_at) { + return 1; + } + if (a.created_at > b.created_at) { + return -1; + } + return 0; + }); + if (arr.length > 25) { + arr.length = 25; + } + VRCXStorage.SetArray('sharedFeeds', arr); + }; + + $app.methods.notifyMenu = function (index) { + if (this.$refs.menu.activeIndex !== index) { + var item = this.$refs.menu.items[index]; + if (item) { + item.$el.classList.add('notify'); + } + } + }; + + $app.methods.selectMenu = function (index) { + // NOTE + // 툴팁이 쌓여서 느려지기 때문에 날려줌. + // 근데 이 방법이 안전한지는 모르겠음 + document.querySelectorAll('[role="tooltip"]').forEach((node) => { + node.remove(); + }); + var item = this.$refs.menu.items[index]; + if (item) { + item.$el.classList.remove('notify'); + } + }; + + $app.methods.showLaunchDialog = function (tag) { + var L = API.parseLocation(tag); + if (L.worldId) { + this.$msgbox({ + title: 'Launch World', + message: `${escapeTag(`https://vrchat.net/launch?worldId=${encodeURIComponent(L.worldId)}&instanceId=${encodeURIComponent(L.instanceId)}`)}`, + dangerouslyUseHTMLString: true, + distinguishCancelAndClose: true, + showCancelButton: true, + cancelButtonText: 'Invite', + confirmButtonText: 'Launch', + callback: (action) => { + if (action === 'confirm') { + VRCX.StartGame(tag); + } else if (action === 'cancel') { + $app.showInviteDialog(tag); + } + } + }); + } + }; + + $app.methods.promptTOTP = function () { + this.$prompt('Enter a numeric code from your authenticator app', 'Two-factor Authentication', { + distinguishCancelAndClose: true, + cancelButtonText: 'Use OTP', + confirmButtonText: 'Verify', + inputPlaceholder: 'Code', + inputPattern: /^[0-9]{6}$/u, + inputErrorMessage: 'Invalid Code', + callback: (action, instance) => { + if (action === 'confirm') { + API.verifyTOTP({ + code: instance.inputValue + }).catch((err) => { + if (err.status_code === 400) { + this.promptTOTP(); + } + throw err; + }).then((args) => { + API.getCurrentUser(); + return args; + }); + } else if (action === 'cancel') { + this.promptOTP(); + } + } + }); + }; + + $app.methods.promptOTP = function () { + this.$prompt('Enter one of your saved recovery codes', 'Two-factor Authentication', { + distinguishCancelAndClose: true, + cancelButtonText: 'Use TOTP', + confirmButtonText: 'Verify', + inputPlaceholder: 'Code', + inputPattern: /^[a-z0-9]{4}-[a-z0-9]{4}$/u, + inputErrorMessage: 'Invalid Code', + callback: (action, instance) => { + if (action === 'confirm') { + API.verifyOTP({ + code: instance.inputValue + }).catch((err) => { + if (err.status_code === 400) { + this.promptOTP(); + } + throw err; + }).then((args) => { + API.getCurrentUser(); + return args; + }); + } else if (action === 'cancel') { + this.promptTOTP(); + } + } + }); + }; + + API.$on('USER:2FA', () => { + $app.promptTOTP(); + }); + + API.$on('LOGOUT', () => { + new Noty({ + type: 'success', + text: `See you again, ${escapeTag(API.currentUser.displayName)}!` + }).show(); + }); + + API.$on('LOGIN', (args) => { + $app.$refs.menu.activeIndex = 'feed'; + new Noty({ + type: 'success', + text: `Hello there, ${escapeTag(args.ref.displayName)}!` + }).show(); + }); + + $app.data.loginForm = { + loading: true, + username: '', + password: '', + rules: { + username: [ + { + required: true, + trigger: 'blur' + } + ], + password: [ + { + required: true, + trigger: 'blur' + } + ] + } + }; + + $app.methods.login = function () { + this.$refs.loginForm.validate((valid) => { + if (valid && + !this.loginForm.loading) { + this.loginForm.loading = true; + API.getConfig().catch((err) => { + this.loginForm.loading = false; + throw err; + }).then((args) => { + API.login({ + username: this.loginForm.username, + password: this.loginForm.password + }).finally(() => { + this.loginForm.loading = false; + }); + return args; + }); + } + }); + }; + + $app.methods.loginWithSteam = function () { + if (!this.loginForm.loading) { + this.loginForm.loading = true; + VRCX.LoginWithSteam().catch((err) => { + this.loginForm.loading = false; + throw err; + }).then((steamTicket) => { + if (steamTicket) { + API.getConfig().catch((err) => { + this.loginForm.loading = false; + throw err; + }).then((args) => { + API.loginWithSteam({ + steamTicket + }).finally(() => { + this.loginForm.loading = false; + }); + return args; + }); + } else { + this.loginForm.loading = false; + this.$message({ + message: 'It only works when VRChat is running.', + type: 'error' + }); + } + }); + } + }; + + // App: Friends + + $app.data.friend = {}; + $app.data.friendNo = 0; + $app.data.isFriendGroup0 = true; + $app.data.isFriendGroup1 = true; + $app.data.isFriendGroup2 = true; + $app.data.isFriendGroup3 = false; + $app.data.friendGroup0_ = []; + $app.data.friendGroup1_ = []; + $app.data.friendGroup2_ = []; + $app.data.friendGroup3_ = []; + $app.data.friendGroupA_ = []; + $app.data.friendGroupB_ = []; + $app.data.friendGroupC_ = []; + $app.data.friendGroupD_ = []; + $app.data.sortFriendGroup0 = false; + $app.data.sortFriendGroup1 = false; + $app.data.sortFriendGroup2 = false; + $app.data.sortFriendGroup3 = false; + $app.data.orderFriendGroup0 = VRCXStorage.GetBool('orderFriendGroup0'); + $app.data.orderFriendGroup1 = VRCXStorage.GetBool('orderFriendGroup1'); + $app.data.orderFriendGroup2 = VRCXStorage.GetBool('orderFriendGroup2'); + $app.data.orderFriendGroup3 = VRCXStorage.GetBool('orderFriendGroup3'); + var saveOrderFriendGroup = function () { + VRCXStorage.SetBool('orderFriendGroup0', this.orderFriendGroup0); + VRCXStorage.SetBool('orderFriendGroup1', this.orderFriendGroup1); + VRCXStorage.SetBool('orderFriendGroup2', this.orderFriendGroup2); + VRCXStorage.SetBool('orderFriendGroup3', this.orderFriendGroup3); + }; + $app.watch.orderFriendGroup0 = saveOrderFriendGroup; + $app.watch.orderFriendGroup1 = saveOrderFriendGroup; + $app.watch.orderFriendGroup2 = saveOrderFriendGroup; + $app.watch.orderFriendGroup3 = saveOrderFriendGroup; + + API.$on('LOGIN', () => { + $app.friend = {}; + $app.friendNo = 0; + $app.isFriendGroup0 = true; + $app.isFriendGroup1 = true; + $app.isFriendGroup2 = true; + $app.isFriendGroup3 = false; + $app.friendGroup0_ = []; + $app.friendGroup1_ = []; + $app.friendGroup2_ = []; + $app.friendGroup3_ = []; + $app.friendGroupA_ = []; + $app.friendGroupB_ = []; + $app.friendGroupC_ = []; + $app.friendGroupD_ = []; + $app.sortFriendGroup0 = false; + $app.sortFriendGroup1 = false; + $app.sortFriendGroup2 = false; + $app.sortFriendGroup3 = false; + }); + + API.$on('USER:CURRENT', (args) => { + // initFriendship()이 LOGIN에서 처리되기 때문에 + // USER:CURRENT에서 처리를 함 + $app.refreshFriend(args.ref, args.origin); + }); + + API.$on('USER', (args) => { + $app.updateFriend(args.ref.id); + }); + + API.$on('FRIEND:ADD', (args) => { + $app.addFriend(args.param.userId); + }); + + API.$on('FRIEND:DELETE', (args) => { + $app.removeFriend(args.param.userId); + }); + + API.$on('FRIEND:STATE', (args) => { + $app.updateFriend(args.param.userId, args.json.state); + }); + + API.$on('FAVORITE', (args) => { + $app.updateFriend(args.ref.favoriteId); + }); + + API.$on('FAVORITE:@DELETE', (args) => { + $app.updateFriend(args.ref.favoriteId); + }); + + $app.methods.refreshFriend = function (ref, origin) { + var map = {}; + ref.friends.forEach((id) => { + map[id] = 'offline'; + }); + ref.offlineFriends.forEach((id) => { + map[id] = 'offline'; + }); + ref.activeFriends.forEach((id) => { + map[id] = 'active'; + }); + ref.onlineFriends.forEach((id) => { + map[id] = 'online'; + }); + var key; + for (key in map) { + if (this.friend[key]) { + this.updateFriend(key, map[key], origin); + } else { + this.addFriend(key, map[key]); + } + } + for (key in this.friend) { + if (!map[key]) { + this.removeFriend(key); + } + } + if (origin) { + API.refreshFriend(); + } + }; + + $app.methods.addFriend = function (id, state) { + if (!this.friend[id]) { + var ref = API.user[id]; + var ctx = { + id, + state: state || 'offline', + ref, + vip: Boolean(API.favoriteObject[id]), + name: '', + no: ++this.friendNo + }; + if (ref) { + ctx.name = ref.name; + } else { + ref = this.friendLog[id]; + if (ref && + ref.displayName) { + ctx.name = ref.displayName; + } + } + this.$set(this.friend, id, ctx); + if (ctx.state === 'online') { + if (ctx.vip) { + this.sortFriendGroup0 = true; + this.friendGroup0_.push(ctx); + this.friendGroupA_.unshift(ctx); + } else { + this.sortFriendGroup1 = true; + this.friendGroup1_.push(ctx); + this.friendGroupB_.unshift(ctx); + } + } else if (ctx.state === 'active') { + this.sortFriendGroup2 = true; + this.friendGroup2_.push(ctx); + this.friendGroupC_.unshift(ctx); + } else { + this.sortFriendGroup3 = true; + this.friendGroup3_.push(ctx); + this.friendGroupD_.unshift(ctx); + } + } + }; + + $app.methods.removeFriend = function (id) { + var ctx = this.friend[id]; + if (ctx) { + this.$delete(this.friend, id); + if (ctx.state === 'online') { + if (ctx.vip) { + removeFromArray(this.friendGroup0_, ctx); + removeFromArray(this.friendGroupA_, ctx); + } else { + removeFromArray(this.friendGroup1_, ctx); + removeFromArray(this.friendGroupB_, ctx); + } + } else if (ctx.state === 'active') { + removeFromArray(this.friendGroup2_, ctx); + removeFromArray(this.friendGroupC_, ctx); + } else { + removeFromArray(this.friendGroup3_, ctx); + removeFromArray(this.friendGroupD_, ctx); + } + } + }; + + $app.methods.updateFriend = function (id, state, origin) { + var ctx = this.friend[id]; + if (ctx) { + var ref = API.user[id]; + var vip = Boolean(API.favoriteObject[id]); + if (state === undefined || + ctx.state === state) { + if (ctx.ref !== ref) { + ctx.ref = ref; + // NOTE + // AddFriend (CurrentUser) 이후, + // 서버에서 오는 순서라고 보면 될 듯. + if (ctx.state === 'online') { + if (ctx.vip) { + removeFromArray(this.friendGroupA_, ctx); + this.friendGroupA_.push(ctx); + } else { + removeFromArray(this.friendGroupB_, ctx); + this.friendGroupB_.push(ctx); + } + } else if (ctx.state === 'active') { + removeFromArray(this.friendGroupC_, ctx); + this.friendGroupC_.push(ctx); + } else { + removeFromArray(this.friendGroupD_, ctx); + this.friendGroupD_.push(ctx); + } + } + if (ctx.vip !== vip) { + ctx.vip = vip; + if (ctx.state === 'online') { + if (ctx.vip) { + removeFromArray(this.friendGroup1_, ctx); + removeFromArray(this.friendGroupB_, ctx); + this.sortFriendGroup0 = true; + this.friendGroup0_.push(ctx); + this.friendGroupA_.unshift(ctx); + } else { + removeFromArray(this.friendGroup0_, ctx); + removeFromArray(this.friendGroupA_, ctx); + this.sortFriendGroup1 = true; + this.friendGroup1_.push(ctx); + this.friendGroupB_.unshift(ctx); + } + } + } + if (ctx.ref && + ctx.name !== ctx.ref.displayName) { + ctx.name = ctx.ref.displayName; + if (ctx.state === 'online') { + if (ctx.vip) { + this.sortFriendGroup0 = true; + } else { + this.sortFriendGroup1 = true; + } + } else if (ctx.state === 'active') { + this.sortFriendGroup2 = true; + } else { + this.sortFriendGroup3 = true; + } + } + // FIXME: 도배 가능성 있음 + if (origin && + ctx.state !== 'online' && + ctx.ref && + ctx.ref.location !== '' && + ctx.ref.location !== 'offline') { + API.getUser({ + userId: id + }); + } + } else { + if (ctx.state === 'online') { + if (ctx.vip) { + removeFromArray(this.friendGroup0_, ctx); + removeFromArray(this.friendGroupA_, ctx); + } else { + removeFromArray(this.friendGroup1_, ctx); + removeFromArray(this.friendGroupB_, ctx); + } + } else if (ctx.state === 'active') { + removeFromArray(this.friendGroup2_, ctx); + removeFromArray(this.friendGroupC_, ctx); + } else { + removeFromArray(this.friendGroup3_, ctx); + removeFromArray(this.friendGroupD_, ctx); + } + ctx.state = state; + if (ctx.ref !== ref) { + ctx.ref = ref; + } + if (ctx.vip !== vip) { + ctx.vip = vip; + } + if (ctx.ref && + ctx.name !== ctx.ref.displayName) { + ctx.name = ctx.ref.displayName; + } + if (ctx.state === 'online') { + if (ctx.vip) { + this.sortFriendGroup0 = true; + this.friendGroup0_.push(ctx); + this.friendGroupA_.unshift(ctx); + } else { + this.sortFriendGroup1 = true; + this.friendGroup1_.push(ctx); + this.friendGroupB_.unshift(ctx); + } + } else if (ctx.state === 'active') { + this.sortFriendGroup2 = true; + this.friendGroup2_.push(ctx); + this.friendGroupC_.unshift(ctx); + } else { + this.sortFriendGroup3 = true; + this.friendGroup3_.push(ctx); + this.friendGroupD_.unshift(ctx); + } + } + } + }; + + var sortFriendByName = (a, b) => { + var A = String(a.name).toUpperCase(); + var B = String(b.name).toUpperCase(); + if (A < B) { + return -1; + } + if (A > B) { + return 1; + } + return 0; + }; + + $app.computed.friendGroup0 = function () { + if (this.orderFriendGroup0) { + return this.friendGroupA_; + } + if (this.sortFriendGroup0) { + this.sortFriendGroup0 = false; + this.friendGroup0_.sort(sortFriendByName); + } + return this.friendGroup0_; + }; + + $app.computed.friendGroup1 = function () { + if (this.orderFriendGroup1) { + return this.friendGroupB_; + } + if (this.sortFriendGroup1) { + this.sortFriendGroup1 = false; + this.friendGroup1_.sort(sortFriendByName); + } + return this.friendGroup1_; + }; + + $app.computed.friendGroup2 = function () { + if (this.orderFriendGroup2) { + return this.friendGroupC_; + } + if (this.sortFriendGroup2) { + this.sortFriendGroup2 = false; + this.friendGroup2_.sort(sortFriendByName); + } + return this.friendGroup2_; + }; + + $app.computed.friendGroup3 = function () { + if (this.orderFriendGroup3) { + return this.friendGroupD_; + } + if (this.sortFriendGroup3) { + this.sortFriendGroup3 = false; + this.friendGroup3_.sort(sortFriendByName); + } + return this.friendGroup3_; + }; + + $app.methods.userStatusClass = function (user) { + var style = {}; + if (user) { + if (user.location === 'offline') { + style.offline = true; + } else if (user.status === 'active') { + style.active = true; + } else if (user.status === 'join me') { + style.joinme = true; + } else if (user.status === 'busy') { + style.busy = true; + } + } + return style; + }; + + $app.methods.deleteFriend = function (id) { + // FIXME: 메시지 수정 + this.$confirm('Continue? Delete Friend', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + API.deleteFriend({ + userId: id + }); + } + } + }); + }; + + // App: Quick Search + + $app.data.quickSearch = ''; + $app.data.quickSearchItems = []; + + $app.methods.quickSearchRemoteMethod = function (query) { + this.quickSearchItems = []; + if (query) { + var QUERY = query.toUpperCase(); + for (var key in this.friend) { + var ctx = this.friend[key]; + if (ctx.ref) { + var NAME = ctx.name.toUpperCase(); + var match = NAME.includes(QUERY); + if (!match) { + var uname = String(ctx.ref.username); + match = uname.toUpperCase().includes(QUERY) && + !uname.startsWith('steam_'); + } + if (match) { + this.quickSearchItems.push({ + value: ctx.id, + label: ctx.name, + ref: ctx.ref, + NAME + }); + } + } + } + this.quickSearchItems.sort((a, b) => { + var A = a.NAME.startsWith(QUERY); + var B = b.NAME.startsWith(QUERY); + if (A !== B) { + if (A) { + return -1; + } + if (B) { + return 1; + } + } + if (a.NAME < b.NAME) { + return -1; + } + if (a.NAME > b.NAME) { + return 1; + } + return 0; + }); + if (this.quickSearchItems.length > 4) { + this.quickSearchItems.length = 4; + } + this.quickSearchItems.push({ + value: `search:${query}`, + label: query + }); + } + }; + + $app.methods.quickSearchChange = function (value) { + if (value) { + if (value.startsWith('search:')) { + this.searchText = value.substr(7); + this.search(); + this.$refs.menu.activeIndex = 'search'; + } else { + this.showUserDialog(value); + } + } + }; + + // NOTE: 그냥 열고 닫고 했을때 changed 이벤트 발생이 안되기 때문에 넣음 + $app.methods.quickSearchVisibleChange = function (value) { + if (value) { + this.quickSearch = ''; + } + }; + + // App: Feed + + $app.data.feedTable = { + data: [], + filters: [ + { + prop: 'type', + value: [], + filterFn: (row, filter) => filter.value.some((v) => v === row.type) + }, + { + prop: 'displayName', + value: '' + }, + { + prop: 'userId', + value: false, + filterFn: (row, filter) => !filter.value || Boolean(API.favoriteObject[row.userId]) + } + ], + tableProps: { + stripe: true, + size: 'mini', + defaultSort: { + prop: 'created_at', + order: 'descending' + } + }, + pageSize: 10, + paginationProps: { + small: true, + layout: 'sizes,prev,pager,next,total', + pageSizes: [ + 10, + 25, + 50, + 100 + ] + } + }; + + API.$on('LOGIN', (args) => { + $app.feedTable.data = VRCXStorage.GetArray(`${args.ref.id}_feedTable`); + }); + + API.$on('USER:UPDATE', (args) => { + var { ref, prop } = args; + if ($app.friend[ref.id]) { + if (prop.location) { + if (prop.location[0] === 'offline') { + $app.addFeed('Offline', ref, { + location: prop.location[1], + time: prop.location[2] + }); + } else if (prop.location[1] === 'offline') { + $app.addFeed('Online', ref, { + location: prop.location[0] + }); + } else { + $app.addFeed('GPS', ref, { + location: [ + prop.location[0], + prop.location[1] + ], + time: prop.location[2] + }); + } + } + if (prop.currentAvatarThumbnailImageUrl) { + $app.addFeed('Avatar', ref, { + avatar: prop.currentAvatarThumbnailImageUrl + }); + } + if (prop.status || + prop.statusDescription) { + $app.addFeed('Status', ref, { + status: [ + { + status: prop.status + ? prop.status[0] + : ref.status, + statusDescription: prop.statusDescription + ? prop.statusDescription[0] + : ref.statusDescription + }, + { + status: prop.status + ? prop.status[1] + : ref.status, + statusDescription: prop.statusDescription + ? prop.statusDescription[1] + : ref.statusDescription + } + ] + }); + } + } + }); + + var saveFeedTimer = false; + $app.methods.saveFeed = function () { + if (saveFeedTimer === false) { + saveFeedTimer = setTimeout(() => { + saveFeedTimer = false; + VRCXStorage.SetArray(`${API.currentUser.id}_feedTable`, this.feedTable.data); + }, 1); + } + }; + + $app.methods.addFeed = function (type, ref, extra) { + this.feedTable.data.push({ + created_at: new Date().toJSON(), + type, + userId: ref.id, + displayName: ref.displayName, + ...extra + }); + this.saveFeed(); + this.notifyMenu('feed'); + }; + + $app.methods.clearFeed = function () { + // FIXME: 메시지 수정 + this.$confirm('Continue? Clear Feed', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + this.feedTable.data = []; + } + } + }); + }; + + // App: gameLog + + $app.data.lastLocation = ''; + $app.data.lastLocation_ = {}; + $app.data.discordActive = VRCXStorage.GetBool('discordActive'); + $app.data.discordInstance = VRCXStorage.GetBool('discordInstance'); + var saveDiscordOption = function () { + VRCXStorage.SetBool('discordActive', this.discordActive); + VRCXStorage.SetBool('discordInstance', this.discordInstance); + }; + $app.watch.discordActive = saveDiscordOption; + $app.watch.discordInstance = saveDiscordOption; + + $app.data.gameLogTable = { + data: [], + filters: [ + { + prop: 'type', + value: [], + filterFn: (row, filter) => filter.value.some((v) => v === row.type) + }, + { + prop: 'detail', + value: '' + } + ], + tableProps: { + stripe: true, + size: 'mini', + defaultSort: { + prop: 'created_at', + order: 'descending' + } + }, + pageSize: 10, + paginationProps: { + small: true, + layout: 'sizes,prev,pager,next,total', + pageSizes: [ + 10, + 25, + 50, + 100 + ] + } + }; + + $app.methods.resetGameLog = function () { + LogWatcher.Reset().then(() => { + this.gameLogTable.data = []; + }); + }; + + $app.methods.refreshGameLog = function () { + LogWatcher.HasLog().then((result) => { + if (result) { + LogWatcher.GetLogs().then((logs) => { + logs.forEach((log) => { + var ctx = { + created_at: log[0], + type: log[1], + data: log[2] + }; + this.gameLogTable.data.push(ctx); + if (ctx.type === 'Location') { + this.lastLocation = ctx.data; + } + }); + this.updateSharedFeed(); + this.notifyMenu('gameLog'); + }); + } else { + this.updateSharedFeed(); + } + }); + }; + + $app.methods.updateDiscord = function () { + if (this.isGameRunning && + this.lastLocation) { + if (this.lastLocation !== this.lastLocation_.tag) { + var L = API.parseLocation(this.lastLocation); + L.worldName = L.worldId; + this.lastLocation_ = L; + if (L.worldId) { + var ref = API.world[L.worldId]; + if (ref) { + L.worldName = ref.name; + } else { + API.getWorld({ + worldId: L.worldId + }).then((args) => { + L.worldName = args.ref.name; + return args; + }); + } + } + } + // NOTE + // 글자 수가 짧으면 업데이트가 안된다.. + var LL = this.lastLocation_; + if (LL.worldName.length < 2) { + LL.worldName += '\uFFA0'.repeat(2 - LL.worldName.length); + } + if (this.discordInstance) { + Discord.SetText(LL.worldName, `#${LL.instanceName} ${LL.accessType}`); + } else { + Discord.SetText(LL.worldName, ''); + } + Discord.SetActive(this.discordActive); + } else { + Discord.SetActive(false); + } + }; + + $app.methods.lookupUser = function (name) { + for (var key in API.user) { + var ctx = API.user[key]; + if (ctx.displayName === name) { + this.showUserDialog(ctx.id); + return; + } + } + this.searchText = name; + this.search(); + this.$refs.menu.activeIndex = 'search'; + this.$refs.searchTab.currentName = '0'; + }; + + // App: Search + + $app.data.searchText = ''; + $app.data.searchUsers = []; + $app.data.searchUserParam = {}; + $app.data.searchWorlds = []; + $app.data.searchWorldOption = ''; + $app.data.searchWorldParam = {}; + $app.data.searchAvatars = []; + $app.data.searchAvatarParam = {}; + $app.data.isSearchUserLoading = false; + $app.data.isSearchWorldLoading = false; + $app.data.isSearchAvatarLoading = false; + + API.$on('LOGIN', () => { + $app.searchText = ''; + $app.searchUsers = []; + $app.searchUserParam = {}; + $app.searchWorlds = []; + $app.searchWorldOption = ''; + $app.searchWorldParam = {}; + $app.searchAvatars = []; + $app.searchAvatarParam = {}; + $app.isSearchUserLoading = false; + $app.isSearchWorldLoading = false; + $app.isSearchAvatarLoading = false; + }); + + $app.methods.clearSearch = function () { + this.searchUsers = []; + this.searchWorlds = []; + this.searchAvatars = []; + }; + + $app.methods.search = function () { + this.searchUser(); + this.searchWorld({}); + }; + + $app.methods.searchUser = function () { + this.searchUserParam = { + n: 10, + offset: 0, + search: this.searchText + }; + this.moreSearchUser(); + }; + + $app.methods.moreSearchUser = function (go) { + var param = this.searchUserParam; + if (go) { + param.offset += param.n * go; + if (param.offset < 0) { + param.offset = 0; + } + } + this.isSearchUserLoading = true; + API.getUsers(param).finally(() => { + this.isSearchUserLoading = false; + }).then((args) => { + this.searchUsers = []; + args.json.forEach((json) => { + insertOrUpdateArrayById(this.searchUsers, json); + }); + return args; + }); + }; + + $app.methods.searchWorld = function (ref) { + this.searchWorldOption = ''; + var param = { + n: 10, + offset: 0 + }; + switch (ref.sortHeading) { + case 'featured': + param.sort = 'order'; + param.featured = 'true'; + break; + case 'trending': + param.sort = 'popularity'; + param.featured = 'false'; + break; + case 'updated': + param.sort = 'updated'; + break; + case 'created': + param.sort = 'created'; + break; + case 'publication': + param.sort = 'publicationDate'; + break; + case 'shuffle': + param.sort = 'shuffle'; + break; + case 'active': + this.searchWorldOption = 'active'; + break; + case 'recent': + this.searchWorldOption = 'recent'; + break; + case 'favorite': + this.searchWorldOption = 'favorites'; + break; + case 'labs': + param.sort = 'labsPublicationDate'; + break; + case 'heat': + param.sort = 'heat'; + param.featured = 'false'; + break; + default: + param.sort = 'popularity'; + param.search = this.searchText; + break; + } + param.order = ref.sortOrder || 'descending'; + if (ref.sortOwnership === 'mine') { + param.user = 'me'; + param.releaseStatus = 'all'; + } + if (ref.tag) { + param.tag = ref.tag; + } + // TODO: option.platform + this.searchWorldParam = param; + this.moreSearchWorld(); + }; + + $app.methods.moreSearchWorld = function (go) { + var param = this.searchWorldParam; + if (go) { + param.offset += param.n * go; + if (param.offset < 0) { + param.offset = 0; + } + } + this.isSearchWorldLoading = true; + API.getWorlds(param, this.searchWorldOption).finally(() => { + this.isSearchWorldLoading = false; + }).then((args) => { + this.searchWorlds = []; + args.json.forEach((json) => { + insertOrUpdateArrayById(this.searchWorlds, json); + }); + return args; + }); + }; + + $app.methods.searchAvatar = function (option) { + var param = { + n: 10, + offset: 0 + }; + switch (option) { + case 'updated': + param.sort = 'updated'; + break; + case 'created': + param.sort = 'created'; + break; + case 'mine': + param.user = 'me'; + param.releaseStatus = 'all'; + break; + default: + param.sort = 'popularity'; + param.search = this.searchText; + break; + } + param.order = 'descending'; + // TODO: option.platform + this.searchAvatarParam = param; + this.moreSearchAvatar(); + }; + + $app.methods.moreSearchAvatar = function (go) { + var param = this.searchAvatarParam; + if (go) { + param.offset += param.n * go; + if (param.offset < 0) { + param.offset = 0; + } + } + this.isSearchAvatarLoading = true; + API.getAvatars(param).finally(() => { + this.isSearchAvatarLoading = false; + }).then((args) => { + this.searchAvatars = []; + args.json.forEach((json) => { + insertOrUpdateArrayById(this.searchAvatars, json); + }); + return args; + }); + }; + + // App: Favorite + + $app.data.favoriteFriend = {}; + $app.data.favoriteWorld = {}; + $app.data.favoriteAvatar = {}; + $app.data.favoriteFriends_ = []; + $app.data.favoriteWorlds_ = []; + $app.data.favoriteAvatars_ = []; + $app.data.sortFavoriteFriends = false; + $app.data.sortFavoriteWorlds = false; + $app.data.sortFavoriteAvatars = false; + + API.$on('LOGIN', () => { + $app.favoriteFriend = {}; + $app.favoriteWorld = {}; + $app.favoriteAvatar = {}; + $app.favoriteFriends_ = []; + $app.favoriteWorlds_ = []; + $app.favoriteAvatars_ = []; + $app.sortFavoriteFriends = false; + $app.sortFavoriteWorlds = false; + $app.sortFavoriteAvatars = false; + }); + + API.$on('FAVORITE', (args) => { + $app.updateFavorite(args.ref.type, args.ref.favoriteId); + }); + + API.$on('FAVORITE:@DELETE', (args) => { + $app.updateFavorite(args.ref.type, args.ref.favoriteId); + }); + + API.$on('USER', (args) => { + $app.updateFavorite('friend', args.ref.id); + }); + + API.$on('WORLD', (args) => { + $app.updateFavorite('world', args.ref.id); + }); + + API.$on('AVATAR', (args) => { + $app.updateFavorite('avatar', args.ref.id); + }); + + $app.methods.updateFavorite = function (type, objectId) { + var favorite = API.favoriteObject[objectId]; + var ctx; + var ref; + if (type === 'friend') { + ctx = this.favoriteFriend[objectId]; + if (favorite) { + ref = API.user[objectId]; + if (ctx) { + if (ctx.ref !== ref) { + ctx.ref = ref; + } + if (ref && + ctx.name !== ref.displayName) { + ctx.name = ref.displayName; + this.sortFavoriteFriends = true; + } + } else { + ctx = { + id: objectId, + group: favorite.group_, + ref, + name: '' + }; + if (ref) { + ctx.name = ref.displayName; + } else { + ref = this.friendLog[objectId]; + if (ref && + ref.displayName) { + ctx.name = ref.displayName; + } + } + this.$set(this.favoriteFriend, objectId, ctx); + this.favoriteFriends_.push(ctx); + this.sortFavoriteFriends = true; + } + } else if (ctx) { + this.$delete(this.favoriteFriend, objectId); + removeFromArray(this.favoriteFriends_, ctx); + } + } else if (type === 'world') { + ctx = this.favoriteWorld[objectId]; + if (favorite) { + ref = API.world[objectId]; + if (ctx) { + if (ctx.ref !== ref) { + ctx.ref = ref; + } + if (ref && + ctx.name !== ref.name) { + ctx.name = ref.name; + this.sortFavoriteWorlds = true; + } + } else { + ctx = { + id: objectId, + group: favorite.group_, + ref, + name: '' + }; + if (ref) { + ctx.name = ref.name; + } + this.$set(this.favoriteWorld, objectId, ctx); + this.favoriteWorlds_.push(ctx); + this.sortFavoriteWorlds = true; + } + } else { + this.$delete(this.favoriteWorld, objectId); + removeFromArray(this.favoriteWorlds_, ctx); + } + } else if (type === 'avatar') { + ctx = this.favoriteAvatar[objectId]; + if (favorite) { + ref = API.avatar[objectId]; + if (ctx) { + if (ctx.ref !== ref) { + ctx.ref = ref; + } + if (ref && + ctx.name !== ref.name) { + ctx.name = ref.name; + this.sortFavoriteAvatars = true; + } + } else { + ctx = { + id: objectId, + group: favorite.group_, + ref, + name: '' + }; + if (ref) { + ctx.name = ref.name; + } + this.$set(this.favoriteAvatar, objectId, ctx); + this.favoriteAvatars_.push(ctx); + this.sortFavoriteAvatars = true; + } + } else { + this.$delete(this.favoriteAvatar, objectId); + removeFromArray(this.favoriteAvatars_, ctx); + } + } + }; + + $app.methods.deleteFavorite = function (objectId) { + // FIXME: 메시지 수정 + this.$confirm('Continue? Delete Favorite', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + API.deleteFavorite({ + objectId + }); + } + } + }); + }; + + $app.methods.changeFavoriteGroupName = function (ctx) { + this.$prompt('Enter a new name', 'Change Group Name', { + distinguishCancelAndClose: true, + cancelButtonText: 'Cancel', + confirmButtonText: 'Change', + inputPlaceholder: 'Name', + inputValue: ctx.displayName, + inputPattern: /\S+/u, + inputErrorMessage: 'Name is required', + callback: (action, instance) => { + if (action === 'confirm') { + API.saveFavoriteGroup({ + type: ctx.type, + group: ctx.name, + displayName: instance.inputValue + }).then((args) => { + this.$message('Group updated!'); + return args; + }); + } + } + }); + }; + + $app.methods.clearFavoriteGroup = function (ctx) { + // FIXME: 메시지 수정 + this.$confirm('Continue? Clear Group', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action2) => { + if (action2 === 'confirm') { + API.clearFavoriteGroup({ + type: ctx.type, + group: ctx.name + }); + } + } + }); + }; + + var sortFavoriteByName = (a, b) => { + var A = String(a.name).toUpperCase(); + var B = String(b.name).toUpperCase(); + if (A < B) { + return -1; + } + if (A > B) { + return 1; + } + return 0; + }; + + $app.computed.favoriteFriends = function () { + if (this.sortFavoriteFriends) { + this.sortFavoriteFriends = false; + this.favoriteFriends_.sort(sortFavoriteByName); + } + return this.favoriteFriends_; + }; + + $app.computed.favoriteWorlds = function () { + if (this.sortFavoriteWorlds) { + this.sortFavoriteWorlds = false; + this.favoriteWorlds_.sort(sortFavoriteByName); + } + return this.favoriteWorlds_; + }; + + $app.computed.favoriteAvatars = function () { + if (this.sortFavoriteAvatars) { + this.sortFavoriteAvatars = false; + this.favoriteAvatars_.sort(sortFavoriteByName); + } + return this.favoriteAvatars_; + }; + + // App: friendLog + + $app.data.friendLog = {}; + $app.data.friendLogTable = { + data: [], + filters: [ + { + prop: 'type', + value: [], + filterFn: (row, filter) => filter.value.some((v) => v === row.type) + }, + { + prop: 'displayName', + value: '' + } + ], + tableProps: { + stripe: true, + size: 'mini', + defaultSort: { + prop: 'created_at', + order: 'descending' + } + }, + pageSize: 10, + paginationProps: { + small: true, + layout: 'sizes,prev,pager,next,total', + pageSizes: [ + 10, + 25, + 50, + 100 + ] + } + }; + + API.$on('LOGIN', (args) => { + $app.initFriendship(args.ref); + }); + + API.$on('USER:CURRENT', (args) => { + $app.updateFriendships(args.ref); + }); + + API.$on('USER', (args) => { + $app.updateFriendship(args.ref); + }); + + API.$on('FRIEND:ADD', (args) => { + $app.addFriendship(args.param.userId); + }); + + API.$on('FRIEND:DELETE', (args) => { + $app.deleteFriendship(args.param.userId); + }); + + API.$on('FRIEND:REQUEST', (args) => { + var ref = API.user[args.param.userId]; + if (ref) { + $app.friendLogTable.data.push({ + created_at: new Date().toJSON(), + type: 'FriendRequest', + userId: ref.id, + displayName: ref.displayName + }); + $app.saveFriendLog(); + } + }); + + API.$on('FRIEND:REQUEST:CANCEL', (args) => { + var ref = API.user[args.param.userId]; + if (ref) { + $app.friendLogTable.data.push({ + created_at: new Date().toJSON(), + type: 'CancelFriendRequst', + userId: ref.id, + displayName: ref.displayName + }); + $app.saveFriendLog(); + } + }); + + var saveFriendLogTimer = false; + $app.methods.saveFriendLog = function () { + if (saveFriendLogTimer === false) { + saveFriendLogTimer = setTimeout(() => { + saveFriendLogTimer = false; + VRCXStorage.SetObject(`${API.currentUser.id}_friendLog`, this.friendLog); + VRCXStorage.SetArray(`${API.currentUser.id}_friendLogTable`, this.friendLogTable.data); + VRCXStorage.Set(`${API.currentUser.id}_friendLogUpdatedAt`, new Date().toJSON()); + }, 1); + } + }; + + $app.methods.initFriendship = function (ref) { + if (VRCXStorage.Get(`${ref.id}_friendLogUpdatedAt`)) { + this.friendLog = VRCXStorage.GetObject(`${ref.id}_friendLog`); + this.friendLogTable.data = VRCXStorage.GetArray(`${ref.id}_friendLogTable`); + } else { + this.friendLog = {}; + ref.friends.forEach((id) => { + this.friendLog[id] = { + id + }; + }); + this.friendLogTable.data = []; + this.saveFriendLog(); + } + }; + + $app.methods.addFriendship = function (id) { + if (!this.friendLog[id]) { + var ctx = { + id, + displayName: null + }; + this.$set(this.friendLog, id, ctx); + var ref = API.user[id]; + if (ref) { + ctx.displayName = ref.displayName; + this.friendLogTable.data.push({ + created_at: new Date().toJSON(), + type: 'Friend', + userId: ref.id, + displayName: ctx.displayName + }); + } + this.saveFriendLog(); + this.notifyMenu('friendLog'); + } + }; + + $app.methods.deleteFriendship = function (id) { + var ctx = this.friendLog[id]; + if (ctx) { + this.$delete(this.friendLog, id); + this.friendLogTable.data.push({ + created_at: new Date().toJSON(), + type: 'Unfriend', + userId: id, + displayName: ctx.displayName + }); + this.saveFriendLog(); + this.notifyMenu('friendLog'); + } + }; + + $app.methods.updateFriendships = function (ref) { + var map = {}; + ref.friends.forEach((id) => { + map[id] = true; + this.addFriendship(id); + }); + for (var key in this.friendLog) { + if (!map[key]) { + this.deleteFriendship(key); + } + } + }; + + $app.methods.updateFriendship = function (ref) { + var ctx = this.friendLog[ref.id]; + if (ctx && + ctx.displayName !== ref.displayName) { + if (ctx.displayName) { + this.friendLogTable.data.push({ + created_at: new Date().toJSON(), + type: 'DisplayName', + userId: ref.id, + displayName: ref.displayName, + previousDisplayName: ctx.displayName + }); + } else if (ctx.displayName === null) { + this.friendLogTable.data.push({ + created_at: new Date().toJSON(), + type: 'Friend', + userId: ref.id, + displayName: ref.displayName + }); + } + ctx.displayName = ref.displayName; + this.saveFriendLog(); + this.notifyMenu('friendLog'); + } + }; + + $app.methods.deleteFriendLog = function (row) { + // FIXME: 메시지 수정 + this.$confirm('Continue? Delete Log', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + if (removeFromArray(this.friendLogTable.data, row)) { + this.saveFriendLog(); + } + } + } + }); + }; + + // App: Moderation + + $app.data.playerModerationTable = { + data: [], + filters: [ + { + prop: 'type', + value: [], + filterFn: (row, filter) => filter.value.some((v) => v === row.type) + }, + { + prop: [ + 'sourceDisplayName', + 'targetDisplayName' + ], + value: '' + } + ], + tableProps: { + stripe: true, + size: 'mini', + defaultSort: { + prop: 'created', + order: 'descending' + } + }, + pageSize: 10, + paginationProps: { + small: true, + layout: 'sizes,prev,pager,next,total', + pageSizes: [ + 10, + 25, + 50, + 100 + ] + } + }; + + API.$on('LOGIN', () => { + $app.playerModerationTable.data = []; + }); + + API.$on('PLAYER-MODERATION', (args) => { + var insertOrUpdate = $app.playerModerationTable.data.some((val, idx, arr) => { + if (val.id === args.ref.id) { + if (args.ref.hide_) { + $app.$delete(arr, idx); + } else { + $app.$set(arr, idx, args.ref); + } + return true; + } + return false; + }); + if (!insertOrUpdate && + !args.ref.hide_) { + $app.playerModerationTable.data.push(args.ref); + $app.notifyMenu('moderation'); + } + }); + + API.$on('PLAYER-MODERATION:@DELETE', (args) => { + $app.playerModerationTable.data.find((val, idx, arr) => { + if (val.id === args.ref.id) { + $app.$delete(arr, idx); + return true; + } + return false; + }); + }); + + $app.methods.deletePlayerModeration = function (row) { + // FIXME: 메시지 수정 + this.$confirm('Continue? Delete Moderation', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + API.deletePlayerModeration({ + moderated: row.targetUserId, + type: row.type + }); + } + } + }); + }; + + // App: Notification + + $app.data.notificationTable = { + data: [], + filters: [ + { + prop: 'type', + value: [], + filterFn: (row, filter) => filter.value.some((v) => v === row.type) + }, + { + prop: 'senderUsername', + value: '' + } + ], + tableProps: { + stripe: true, + size: 'mini', + defaultSort: { + prop: 'created_at', + order: 'descending' + } + }, + pageSize: 10, + paginationProps: { + small: true, + layout: 'sizes,prev,pager,next,total', + pageSizes: [ + 10, + 25, + 50, + 100 + ] + } + }; + + API.$on('LOGIN', () => { + $app.notificationTable.data = []; + }); + + API.$on('NOTIFICATION', (args) => { + var insertOrUpdate = $app.notificationTable.data.some((val, idx, arr) => { + if (val.id === args.ref.id) { + if (args.ref.hide_) { + $app.$delete(arr, idx); + } else { + $app.$set(arr, idx, args.ref); + } + return true; + } + return false; + }); + if (!insertOrUpdate && + !args.ref.hide_) { + $app.notificationTable.data.push(args.ref); + $app.notifyMenu('notification'); + } + }); + + API.$on('NOTIFICATION:@DELETE', (args) => { + $app.notificationTable.data.find((val, idx, arr) => { + if (val.id === args.ref.id) { + $app.$delete(arr, idx); + return true; + } + return false; + }); + }); + + $app.methods.parseInviteLocation = function (row) { + try { + var L = API.parseLocation(row.details.worldId); + return `${row.details.worldName} #${L.instanceName} ${L.accessType}`; + } catch (err) { + console.error(err); + return ''; + } + }; + + $app.methods.acceptNotification = function (row) { + // FIXME: 메시지 수정 + this.$confirm('Continue? Accept Friend Request', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + API.acceptNotification({ + notificationId: row.id + }); + } + } + }); + }; + + $app.methods.hideNotification = function (row) { + // FIXME: 메시지 수정 + this.$confirm('Continue? Delete Notification', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + API.hideNotification({ + notificationId: row.id + }); + } + } + }); + }; + + // App: More + + $app.data.pastDisplayNameTable = { + data: [], + tableProps: { + stripe: true, + size: 'mini', + defaultSort: { + prop: 'updated_at', + order: 'descending' + } + }, + pageSize: 10, + paginationProps: { + small: true, + layout: 'sizes,prev,pager,next,total', + pageSizes: [ + 10, + 25, + 50, + 100 + ] + } + }; + $app.data.visits = 0; + $app.data.openVR = VRCXStorage.GetBool('openVR'); + $app.data.openVRAlways = VRCXStorage.GetBool('openVRAlways'); + var saveOpenVROption = function () { + VRCXStorage.SetBool('openVR', this.openVR); + VRCXStorage.SetBool('openVRAlways', this.openVRAlways); + }; + $app.watch.openVR = saveOpenVROption; + $app.watch.openVRAlways = saveOpenVROption; + + API.$on('LOGIN', () => { + $app.pastDisplayNameTable.data = []; + }); + + API.$on('USER:CURRENT', (args) => { + if (args.ref.pastDisplayNames) { + $app.pastDisplayNameTable.data = args.ref.pastDisplayNames; + } + }); + + API.$on('VISITS', (args) => { + $app.visits = args.json; + }); + + $app.methods.logout = function () { + this.$confirm('Continue? Logout', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + API.logout(); + } + } + }); + }; + + $app.methods.resetHome = function () { + this.$confirm('Continue? Reset Home', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + API.saveCurrentUser({ + homeLocation: '' + }).then((args) => { + this.$message({ + message: 'Home world has been reset', + type: 'success' + }); + return args; + }); + } + } + }); + }; + + $app.methods.updateOpenVR = function () { + if (this.openVR && + (this.isGameRunning || this.openVRAlways)) { + VRCX.StartVR(); + } else { + VRCX.StopVR(); + } + }; + + $app.methods.promptUserDialog = function () { + this.$prompt('Enter a User ID (UUID)', 'Direct Access', { + distinguishCancelAndClose: true, + confirmButtonText: 'Send', + cancelButtonText: 'Cancel', + inputPattern: /\S+/u, + inputErrorMessage: 'User ID is required', + callback: (action, instance) => { + if (action === 'confirm' && + instance.inputValue) { + this.showUserDialog(instance.inputValue); + } + } + }); + }; + + $app.methods.promptWorldDialog = function () { + this.$prompt('Enter a World ID (UUID)', 'Direct Access', { + distinguishCancelAndClose: true, + confirmButtonText: 'Send', + cancelButtonText: 'Cancel', + inputPattern: /\S+/u, + inputErrorMessage: 'World ID is required', + callback: (action, instance) => { + if (action === 'confirm' && + instance.inputValue) { + this.showWorldDialog(instance.inputValue); + } + } + }); + }; + + $app.methods.promptAvatarDialog = function () { + this.$prompt('Enter a Avatar ID (UUID)', 'Direct Access', { + distinguishCancelAndClose: true, + confirmButtonText: 'Send', + cancelButtonText: 'Cancel', + inputPattern: /\S+/u, + inputErrorMessage: 'Avatar ID is required', + callback: (action, instance) => { + if (action === 'confirm' && + instance.inputValue) { + this.showAvatarDialog(instance.inputValue); + } + } + }); + }; + + // App: Dialog + + var adjustDialogZ = (el) => { + var z = 0; + document.querySelectorAll('.v-modal,.el-dialog__wrapper').forEach((v) => { + var _z = Number(v.style.zIndex) || 0; + if (_z && + _z > z && + v !== el) { + z = _z; + } + }); + if (z) { + el.style.zIndex = z + 1; + } + }; + + var buildTreeData = (json) => { + var node = []; + for (var key in json) { + var value = json[key]; + if (typeof value === 'object') { + if (Array.isArray(value)) { + node.push({ + children: value.map((val, idx) => { + if (typeof val === 'object') { + return { + children: buildTreeData(val), + key: idx + }; + } + return { + key: idx, + value: val + }; + }), + key + }); + } else { + node.push({ + children: buildTreeData(value), + key + }); + } + } else { + node.push({ + key, + value: String(value) + }); + } + } + node.sort((a, b) => { + var A = String(a.key).toUpperCase(); + var B = String(b.key).toUpperCase(); + if (A < B) { + return -1; + } + if (A > B) { + return 1; + } + return 0; + }); + return node; + }; + + // App: User Dialog + + $app.data.userDialog = { + visible: false, + loading: false, + id: '', + ref: {}, + friend: {}, + isFriend: false, + incomingRequest: false, + outgoingRequest: false, + isBlock: false, + isMute: false, + isHideAvatar: false, + isFavorite: false, + + location_: {}, + users: [], + instance: {}, + + worlds: [], + avatars: [], + isWorldsLoading: false, + isAvatarsLoading: false, + + treeData: [] + }; + + API.$on('LOGOUT', () => { + $app.userDialog.visible = false; + }); + + API.$on('USER', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref.id === D.id) { + D.ref = args.ref; + $app.updateUserDialogLocation(); + } + }); + + API.$on('WORLD', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref.id === D.location_.worldId) { + $app.updateUserDialogLocation(); + } + }); + + API.$on('FRIEND:STATUS', (args) => { + var D = $app.userDialog; + if (D.visible && + args.param.userId === D.id) { + D.isFriend = args.json.isFriend; + D.incomingRequest = args.json.incomingRequest; + D.outgoingRequest = args.json.outgoingRequest; + } + }); + + API.$on('FRIEND:REQUEST', (args) => { + var D = $app.userDialog; + if (D.visible && + args.param.userId === D.id) { + if (args.json.success) { + D.isFriend = true; + } else { + D.outgoingRequest = true; + } + } + }); + + API.$on('FRIEND:REQUEST:CANCEL', (args) => { + var D = $app.userDialog; + if (D.visible && + args.param.userId === D.id) { + D.outgoingRequest = false; + } + }); + + API.$on('NOTIFICATION', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref && + args.ref.senderUserId === D.id && + args.ref.type === 'friendRequest') { + D.incomingRequest = true; + } + }); + + API.$on('NOTIFICATION:ACCEPT', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref && + args.ref.senderUserId === D.id && + args.ref.type === 'friendRequest') { + D.isFriend = true; + } + }); + + API.$on('NOTIFICATION:@DELETE', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref.senderUserId === D.id && + args.ref.type === 'friendRequest') { + D.incomingRequest = false; + } + }); + + API.$on('FRIEND:DELETE', (args) => { + var D = $app.userDialog; + if (D.visible && + args.param.userId === D.id) { + D.isFriend = false; + } + }); + + API.$on('PLAYER-MODERATION', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref.targetUserId === D.id && + args.ref.sourceUserId === API.currentUser.id && + !args.ref.hide_) { + if (args.ref.type === 'block') { + D.isBlock = true; + } else if (args.ref.type === 'mute') { + D.isMute = true; + } else if (args.ref.type === 'hideAvatar') { + D.isHideAvatar = true; + } + } + }); + + API.$on('PLAYER-MODERATION:@DELETE', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref.targetUserId === D.id && + args.ref.sourceUserId === API.currentUser.id) { + if (args.ref.type === 'block') { + D.isBlock = false; + } else if (args.ref.type === 'mute') { + D.isMute = false; + } else if (args.ref.type === 'hideAvatar') { + D.isHideAvatar = false; + } + } + }); + + API.$on('FAVORITE', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref.favoriteId === D.id && + !args.ref.hide_) { + D.isFavorite = true; + } + }); + + API.$on('FAVORITE:@DELETE', (args) => { + var D = $app.userDialog; + if (D.visible && + args.ref.favoriteId === D.id) { + D.isFavorite = false; + } + }); + + $app.methods.showUserDialog = function (userId) { + this.$nextTick(() => adjustDialogZ(this.$refs.userDialog.$el)); + var D = this.userDialog; + D.id = userId; + D.treeData = []; + D.visible = true; + D.loading = true; + API.getCachedUser({ + userId + }).catch((err) => { + D.loading = false; + D.visible = false; + throw err; + }).then((args) => { + if (args.ref.id === D.id) { + D.loading = false; + D.ref = args.ref; + D.friend = this.friend[D.id]; + D.isFriend = Boolean(D.friend); + D.incomingRequest = false; + D.outgoingRequest = false; + D.isBlock = false; + D.isMute = false; + D.isHideAvatar = false; + var key; + var ref; + for (key in API.playerModeration) { + ref = API.playerModeration[key]; + if (ref.targetUserId === D.id && + ref.sourceUserId === API.currentUser.id && + !ref.hide_) { + if (ref.type === 'block') { + D.isBlock = true; + } else if (ref.type === 'mute') { + D.isMute = true; + } else if (ref.type === 'hideAvatar') { + D.isHideAvatar = true; + } + } + } + D.isFavorite = Boolean(API.favoriteObject[D.id]); + this.updateUserDialogLocation(); + D.worlds = []; + D.avatars = []; + D.isWorldsLoading = false; + D.isAvatarsLoading = false; + for (key in API.world) { + ref = API.world[key]; + if (ref.authorId === D.id) { + D.worlds.push(ref); + } + } + for (key in API.avatar) { + ref = API.avatar[key]; + if (ref.authorId === D.id) { + D.avatars.push(ref); + } + } + $app.sortUserDialogWorlds(); + $app.sortUserDialogAvatars(); + API.getFriendStatus({ + userId: D.id + }); + if (args.cache) { + API.getUser(args.param); + } + } + return args; + }); + }; + + $app.methods.updateUserDialogLocation = function () { + var ref; + var D = this.userDialog; + var L = API.parseLocation(D.ref.location); + D.location_ = L; + if (L.userId) { + ref = API.user[L.userId]; + if (ref) { + L.user = ref; + } else { + API.getUser({ + userId: L.userId + }).then((args) => { + this.$set(L, 'user', args.ref); + return args; + }); + } + } + D.users = []; + if (!L.isOffline) { + for (var key in this.friend) { + ref = API.user[key]; + if (ref && + ref.location === D.ref.location) { + D.users.push(ref); + } + } + D.users.sort((a, b) => { + var A = String(a.displayName).toUpperCase(); + var B = String(b.displayName).toUpperCase(); + if (A < B) { + return -1; + } + if (A > B) { + return 1; + } + return 0; + }); + } + D.instance = {}; + if (L.worldId) { + var handle = (instances) => { + if (instances) { + instances.find((v) => { + if (v[0] === L.instanceId) { + D.instance = { + id: v[0], + occupants: v[1] + }; + return true; + } + return false; + }); + } + }; + ref = API.world[L.worldId]; + if (ref) { + handle(ref.instances); + } else { + API.getWorld({ + worldId: L.worldId + }).then((args) => { + if (L.tag === D.location_.tag) { + handle(args.ref.instances); + } + return true; + }); + } + } + }; + + $app.methods.sortUserDialogWorlds = function () { + this.userDialog.worlds.sort((a, b) => { + var A = String(a.name).toUpperCase(); + var B = String(b.name).toUpperCase(); + if (A < B) { + return -1; + } + if (A > B) { + return 1; + } + return 0; + }); + }; + + $app.methods.refreshUserDialogWorlds = function () { + var D = this.userDialog; + if (!D.isWorldsLoading) { + D.isWorldsLoading = true; + var param = { + n: 100, + offset: 0, + sort: 'updated', + order: 'descending', + user: 'friends', + userId: D.id, + releaseStatus: 'public' + }; + if (param.userId === API.currentUser.id) { + param.user = 'me'; + param.releaseStatus = 'all'; + } + API.bulk({ + fn: 'getWorlds', + N: -1, + param, + handle: (args) => { + args.json.forEach((json) => { + insertOrUpdateArrayById(D.worlds, json); + }); + }, + done: () => { + this.sortUserDialogWorlds(); + D.isWorldsLoading = false; + } + }); + } + }; + + $app.methods.sortUserDialogAvatars = function () { + this.userDialog.avatars.sort((a, b) => { + var A = String(a.name).toUpperCase(); + var B = String(b.name).toUpperCase(); + if (A < B) { + return -1; + } + if (A > B) { + return 1; + } + return 0; + }); + }; + + $app.methods.refreshUserDialogAvatars = function () { + var D = this.userDialog; + if (!D.isAvatarsLoading) { + D.isAvatarsLoading = true; + var param = { + n: 100, + offset: 0, + sort: 'updated', + order: 'descending', + user: 'friends', + userId: D.id, + releaseStatus: 'public' + }; + if (param.userId === API.currentUser.id) { + param.user = 'me'; + param.releaseStatus = 'all'; + } + API.bulk({ + fn: 'getAvatars', + N: -1, + param, + handle: (args) => { + args.json.forEach((json) => { + insertOrUpdateArrayById(D.avatars, json); + }); + }, + done: () => { + this.sortUserDialogAvatars(); + D.isAvatarsLoading = false; + } + }); + } + }; + + var performUserDialogCommand = (command, userId) => { + var key; + switch (command) { + case 'Delete Favorite': + API.deleteFavorite({ + objectId: userId + }); + break; + case 'Unfriend': + API.deleteFriend({ + userId + }); + break; + case 'Accept Friend Request': + key = API.getFriendRequest(userId); + if (key === '') { + API.sendFriendRequest({ + userId + }); + } else { + API.acceptNotification({ + notificationId: key + }); + } + break; + case 'Decline Friend Request': + key = API.getFriendRequest(userId); + if (key === '') { + API.cancelFriendRequest({ + userId + }); + } else { + API.hideNotification({ + notificationId: key + }); + } + break; + case 'Cancel Friend Request': + API.cancelFriendRequest({ + userId + }); + break; + case 'Send Friend Request': + API.sendFriendRequest({ + userId + }); + break; + case 'Unblock': + API.deletePlayerModeration({ + moderated: userId, + type: 'block' + }); + break; + case 'Block': + API.sendPlayerModeration({ + moderated: userId, + type: 'block' + }); + break; + case 'Unmute': + API.deletePlayerModeration({ + moderated: userId, + type: 'mute' + }); + break; + case 'Mute': + API.sendPlayerModeration({ + moderated: userId, + type: 'mute' + }); + break; + case 'Show Avatar': + API.deletePlayerModeration({ + moderated: userId, + type: 'hideAvatar' + }); + break; + case 'Hide Avatar': + API.sendPlayerModeration({ + moderated: userId, + type: 'hideAvatar' + }); + break; + } + }; + + $app.methods.userDialogCommand = function (command) { + var D = this.userDialog; + if (D.visible) { + if (command === 'Add Favorite') { + this.showFavoriteDialog('friend', D.id); + } else if (command === 'Message') { + this.$prompt('Enter a message', 'Send Message', { + distinguishCancelAndClose: true, + confirmButtonText: 'Send', + cancelButtonText: 'Cancel', + inputPattern: /\S+/u, + inputErrorMessage: 'Message is required', + callback: (action, instance) => { + if (action === 'confirm' && + instance.inputValue) { + API.sendNotification({ + receiverUserId: D.id, + type: 'message', + message: instance.inputValue, + seen: false, + details: '{}' + }).then((args) => { + this.$message('Message sent'); + return args; + }); + } + } + }); + } else { + this.$confirm(`Continue? ${command}`, 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + performUserDialogCommand(command, D.id); + } + } + }); + } + } + }; + + $app.methods.refreshUserDialogTreeData = function () { + var D = this.userDialog; + D.treeData = buildTreeData(D.ref); + }; + + // App: World Dialog + + $app.data.worldDialog = { + visible: false, + loading: false, + location_: {}, + ref: {}, + isFavorite: false, + rooms: [], + treeData: [], + fileCreatedAt: '', + fileSize: '' + }; + + API.$on('LOGOUT', () => { + $app.worldDialog.visible = false; + }); + + API.$on('WORLD', (args) => { + var D = $app.worldDialog; + if (D.visible && + args.ref.id === D.location_.worldId) { + D.ref = args.ref; + var id = extractFileId(args.ref.assetUrl); + if (id) { + API.call(`file/${id}`).then((json) => { + var ref = json.versions[json.versions.length - 1]; + D.fileCreatedAt = ref.created_at; + D.fileSize = `${(ref.file.sizeInBytes / 1048576).toFixed(2)} MiB`; + }); + } + $app.updateWorldDialogInstances(); + } + }); + + API.$on('FAVORITE', (args) => { + var D = $app.worldDialog; + if (D.visible && + args.ref.favoriteId === D.location_.worldId && + !args.ref.hide_) { + D.isFavorite = true; + } + }); + + API.$on('FAVORITE:@DELETE', (args) => { + var D = $app.worldDialog; + if (D.visible && + args.ref.favoriteId === D.location_.worldId) { + D.isFavorite = false; + } + }); + + $app.methods.showWorldDialog = function (tag) { + this.$nextTick(() => adjustDialogZ(this.$refs.worldDialog.$el)); + var D = this.worldDialog; + var L = API.parseLocation(tag); + if (L.worldId) { + D.location_ = L; + D.treeData = []; + D.fileCreatedAt = ''; + D.fileSize = 'Loading'; + D.visible = true; + D.loading = true; + API.getCachedWorld({ + worldId: L.worldId + }).catch((err) => { + D.loading = false; + D.visible = false; + throw err; + }).then((args) => { + if (D.location_.worldId === args.ref.id) { + D.loading = false; + D.ref = args.ref; + D.isFavorite = Boolean(API.favoriteObject[D.location_.worldId]); + D.rooms = []; + this.updateWorldDialogInstances(); + if (args.cache) { + API.getWorld(args.param); + } + } + return args; + }); + } + }; + + $app.methods.updateWorldDialogInstances = function () { + var ref; + var D = this.worldDialog; + if (D.ref.instances) { + var map = {}; + D.ref.instances.forEach((v) => { + map[v[0]] = { + id: v[0], + occupants: v[1], + users: [] + }; + }); + var { instanceId } = D.location_; + if (instanceId && + !map[instanceId]) { + map[instanceId] = { + id: instanceId, + occupants: 0, + users: [] + }; + } + for (var key in this.friend) { + ref = API.user[key]; + if (ref && + ref.location_.worldId === D.location_.worldId) { + ({ instanceId } = ref.location_); + if (map[instanceId]) { + map[instanceId].users.push(ref); + } else { + map[instanceId] = { + id: instanceId, + occupants: 0, + users: [ref] + }; + } + } + } + D.rooms = []; + Object.values(map).sort((a, b) => b.users.length - a.users.length || b.occupants - a.occupants).forEach((v) => { + var L = API.parseLocation(`${D.location_.worldId}:${v.id}`); + v.location_ = L; + v.location = L.tag; + if (L.userId) { + ref = API.user[L.userId]; + if (ref) { + L.user = ref; + } else { + API.getUser({ + userId: L.userId + }).then((args) => { + this.$set(L, 'user', args.ref); + return args; + }); + } + } + v.users.sort((a, b) => { + var A = String(a.displayName).toUpperCase(); + var B = String(b.displayName).toUpperCase(); + if (A < B) { + return -1; + } + if (A > B) { + return 1; + } + return 0; + }); + D.rooms.push(v); + }); + } + }; + + $app.methods.worldDialogCommand = function (command) { + var D = this.worldDialog; + if (D.visible) { + if (command === 'New Instance') { + this.showNewInstanceDialog(D.location_.tag); + } else if (command === 'Add Favorite') { + this.showFavoriteDialog('world', D.location_.worldId); + } else { + this.$confirm(`Continue? ${command}`, 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + switch (command) { + case 'Delete Favorite': + API.deleteFavorite({ + objectId: D.location_.worldId + }); + break; + case 'Make Home': + API.saveCurrentUser({ + homeLocation: D.location_.worldId + }).then((args) => { + this.$message({ + message: 'Home world updated', + type: 'success' + }); + return args; + }); + break; + case 'Reset Home': + API.saveCurrentUser({ + homeLocation: '' + }).then((args) => { + this.$message({ + message: 'Home world has been reset', + type: 'success' + }); + return args; + }); + break; + } + } + } + }); + } + } + }; + + $app.methods.refreshWorldDialogTreeData = function () { + var D = this.worldDialog; + D.treeData = buildTreeData(D.ref); + }; + + $app.computed.worldDialogPlatform = function () { + var { ref } = this.worldDialog; + var platforms = []; + if (ref.unityPackages) { + ref.unityPackages.forEach((v) => { + var platform = 'PC'; + if (v.platform === 'standalonewindows') { + platform = 'PC'; + } else if (v.platform === 'android') { + platform = 'Quest'; + } else if (v.platform) { + ({ platform } = v); + } + platforms.push(`${platform}/${v.unityVersion}`); + }); + } + return platforms.join(', '); + }; + + // App: Avatar Dialog + + $app.data.avatarDialog = { + visible: false, + loading: false, + id: '', + ref: {}, + isFavorite: false, + treeData: [], + fileCreatedAt: '', + fileSize: '' + }; + + API.$on('LOGOUT', () => { + $app.avatarDialog.visible = false; + }); + + API.$on('AVATAR', (args) => { + var D = $app.avatarDialog; + if (D.visible && + args.ref.id === D.id) { + D.ref = args.ref; + var id = extractFileId(args.ref.assetUrl); + if (id) { + API.call(`file/${id}`).then((json) => { + var ref = json.versions[json.versions.length - 1]; + D.fileCreatedAt = ref.created_at; + D.fileSize = `${(ref.file.sizeInBytes / 1048576).toFixed(2)} MiB`; + }); + } + } + }); + + API.$on('FAVORITE', (args) => { + var D = $app.avatarDialog; + if (D.visible && + args.ref.favoriteId === D.id && + !args.ref.hide_) { + D.isFavorite = true; + } + }); + + API.$on('FAVORITE:@DELETE', (args) => { + var D = $app.avatarDialog; + if (D.visible && + args.ref.favoriteId === D.id) { + D.isFavorite = false; + } + }); + + $app.methods.showAvatarDialog = function (avatarId) { + this.$nextTick(() => adjustDialogZ(this.$refs.avatarDialog.$el)); + var D = this.avatarDialog; + D.id = avatarId; + D.treeData = []; + D.fileCreatedAt = ''; + D.fileSize = 'Loading'; + D.visible = true; + D.loading = true; + API.getCachedAvatar({ + avatarId + }).catch((err) => { + D.loading = false; + D.visible = false; + throw err; + }).then((args) => { + if (D.id === args.ref.id) { + D.loading = false; + D.ref = args.ref; + D.isFavorite = Boolean(API.favoriteObject[D.ref.id]); + if (args.cache) { + API.getAvatar(args.param); + } + } + return args; + }); + }; + + $app.methods.avatarDialogCommand = function (command) { + var D = this.avatarDialog; + if (D.visible) { + if (command === 'Add Favorite') { + this.showFavoriteDialog('avatar', D.id); + } else { + this.$confirm(`Continue? ${command}`, 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + switch (command) { + case 'Delete Favorite': + API.deleteFavorite({ + objectId: D.id + }); + break; + case 'Select Avatar': + API.selectAvatar({ + avatarId: D.id + }); + break; + } + } + } + }); + } + } + }; + + $app.methods.refreshAvatarDialogTreeData = function () { + var D = this.avatarDialog; + D.treeData = buildTreeData(D.ref); + }; + + $app.computed.avatarDialogLastUpdate = function () { + var at = ''; + var { ref } = this.avatarDialog; + if (ref.unityPackages) { + ref.unityPackages.forEach((v) => { + if (at < v.created_at) { + at = v.created_at; + } + }); + } + return at || ref.updated_at || ''; + }; + + $app.computed.avatarDialogPlatform = function () { + var { ref } = this.avatarDialog; + var platforms = []; + if (ref.unityPackages) { + ref.unityPackages.forEach((v) => { + var platform = 'PC'; + if (v.platform === 'standalonewindows') { + platform = 'PC'; + } else if (v.platform === 'android') { + platform = 'Quest'; + } else if (v.platform) { + ({ platform } = v); + } + platforms.push(`${platform}/${v.unityVersion}`); + }); + } + return platforms.join(', '); + }; + + // App: Favorite Dialog + + $app.data.favoriteDialog = { + visible: false, + loading: false, + type: '', + objectId: '', + groups: [] + }; + + API.$on('LOGOUT', () => { + $app.favoriteDialog.visible = false; + }); + + $app.methods.addFavorite = function (group) { + var D = this.favoriteDialog; + D.loading = true; + API.addFavorite({ + type: D.type, + favoriteId: D.objectId, + tags: group.name + }).finally(() => { + D.loading = false; + }).then((args) => { + D.visible = false; + return args; + }); + }; + + $app.methods.showFavoriteDialog = function (type, objectId) { + this.$nextTick(() => adjustDialogZ(this.$refs.favoriteDialog.$el)); + var D = this.favoriteDialog; + D.type = type; + D.objectId = objectId; + if (type === 'friend') { + D.groups = API.favoriteFriendGroups; + D.visible = true; + } else if (type === 'world') { + D.groups = API.favoriteWorldGroups; + D.visible = true; + } else if (type === 'avatar') { + D.groups = API.favoriteAvatarGroups; + D.visible = true; + } + }; + + // App: Invite Dialog + + $app.data.inviteDialog = { + visible: false, + loading: false, + worldId: '', + worldName: '', + userIds: [] + }; + + API.$on('LOGOUT', () => { + $app.inviteDialog.visible = false; + }); + + $app.methods.sendInvite = function () { + this.$confirm('Continue? Invite', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + var D = this.inviteDialog; + if (!D.loading) { + D.loading = true; + var param = { + receiverUserId: '', + type: 'invite', + message: '', + seen: false, + details: { + worldId: D.worldId, + worldName: D.worldName + } + }; + var invite = () => { + if (D.userIds.length) { + param.receiverUserId = D.userIds.shift(); + API.sendNotification(param).finally(invite); + } else { + D.loading = false; + D.visible = false; + this.$message({ + message: 'Invite sent', + type: 'success' + }); + } + }; + invite(); + } + + } + } + }); + }; + + $app.methods.showInviteDialog = function (tag) { + this.$nextTick(() => adjustDialogZ(this.$refs.inviteDialog.$el)); + var L = API.parseLocation(tag); + if (!(L.isOffline || L.isPrivate) && + L.worldId) { + var handle = (ref) => { + var D = this.inviteDialog; + D.userIds = []; + D.worldId = L.tag; + D.worldName = ref.name; + D.visible = true; + }; + var ref = API.world[L.worldId]; + if (ref) { + handle(ref); + } else { + API.getWorld({ + worldId: L.worldId + }).then((args) => { + handle(args.ref); + return args; + }); + } + } + }; + + // App: Social Status Dialog + + $app.data.socialStatusDialog = { + visible: false, + loading: false, + status: '', + statusDescription: '' + }; + + API.$on('LOGOUT', () => { + $app.socialStatusDialog.visible = false; + }); + + $app.methods.saveSocialStatus = function () { + var D = this.socialStatusDialog; + if (!D.loading) { + D.loading = true; + API.saveCurrentUser({ + status: D.status, + statusDescription: D.statusDescription + }).finally(() => { + D.loading = false; + }).then((args) => { + D.visible = false; + this.$message({ + message: 'Status updated', + type: 'success' + }); + return args; + }); + } + }; + + $app.methods.showSocialStatusDialog = function () { + this.$nextTick(() => adjustDialogZ(this.$refs.socialStatusDialog.$el)); + var D = this.socialStatusDialog; + D.status = API.currentUser.status; + D.statusDescription = API.currentUser.statusDescription; + D.visible = true; + }; + + // App: New Instance Dialog + + $app.data.newInstanceDialog = { + visible: false, + loading: false, + worldId: '', + instanceId: '', + accessType: '', + location: '', + url: '' + }; + + API.$on('LOGOUT', () => { + $app.newInstanceDialog.visible = false; + }); + + $app.methods.buildInstanceTag = function () { + var D = this.newInstanceDialog; + var tags = []; + tags.push((99999 * Math.random() + 1).toFixed(0)); + if (D.accessType !== 'public') { + if (D.accessType === 'friends+') { + tags.push(`~hidden(${API.currentUser.id})`); + } else if (D.accessType === 'friends') { + tags.push(`~friends(${API.currentUser.id})`); + } else { + tags.push(`~private(${API.currentUser.id})`); + } + // NOTE : crypto.getRandomValues()를 쓰면 안전한 대신 무겁겠지.. + var nonce = []; + for (var i = 0; i < 10; ++i) { + nonce.push(Math.random().toString(16).substr(2).toUpperCase()); + } + nonce = nonce.join('').substr(0, 64); + tags.push(`~nonce(${nonce})`); + if (D.accessType === 'invite+') { + tags.push('~canRequestInvite'); + } + } + D.instanceId = tags.join(''); + }; + + var updateLocationURL = function () { + var D = this.newInstanceDialog; + if (D.instanceId) { + D.location = `${D.worldId}:${D.instanceId}`; + D.url = `https://vrchat.net/launch?worldId=${encodeURIComponent(D.worldId)}&instanceId=${encodeURIComponent(D.instanceId)}`; + } else { + D.location = D.worldId; + D.url = `https://vrchat.net/launch?worldId=${encodeURIComponent(D.worldId)}`; + } + }; + $app.watch['newInstanceDialog.worldId'] = updateLocationURL; + $app.watch['newInstanceDialog.instanceId'] = updateLocationURL; + + $app.methods.showNewInstanceDialog = function (tag) { + this.$nextTick(() => adjustDialogZ(this.$refs.inviteDialog.$el)); + var L = API.parseLocation(tag); + if (!(L.isOffline || L.isPrivate) && + L.worldId) { + var D = this.newInstanceDialog; + D.worldId = L.worldId; + D.accessType = 'public'; + this.buildInstanceTag(); + D.visible = true; + } + }; + + $app.methods.makeHome = function (tag) { + this.$confirm('Continue? Make Home', 'Confirm', { + confirmButtonText: 'Confirm', + cancelButtonText: 'Cancel', + type: 'info', + callback: (action) => { + if (action === 'confirm') { + API.saveCurrentUser({ + homeLocation: tag + }).then((args) => { + this.$message({ + message: 'Home world updated', + type: 'success' + }); + return args; + }); + } + } + }); + }; + + $app = new Vue($app); + window.$app = $app; + }); +} else { + location = 'https://github.com/pypy-vrc/vrcx'; +} diff --git a/html/images/controller_status_off.png b/html/images/controller_status_off.png new file mode 100644 index 0000000000000000000000000000000000000000..75afa9374c5319953b566946b5d42764783dfbb9 GIT binary patch literal 1479 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz$r9IylHmNblJdl&R0hYC{G?O` z&)mfH)S%SFl*+=BsWuD@%u1Od5hW46K32*3xq68pHF_1f1wh>l3^w)^1&PVosU-?Y zsp*+{wo31J?^jaDOtDo8H}y5}EpSfF$n>ZxN)4{^3rViZPPR-@vbR&PsjvbXkegbP zs8ErclUHn2VXFi-*9yo63F|81#=KlDb#X~hD#E>34K5C;EJ)Q4 zN-fSWElLJPT$(b-ssbzLqSVBa{GyQj{2W*)24v)yqwGc|QJG;}qyv@mnDaB?$uGBk0t zaJ4jp>2=9ZF3nBND}m`vLFl!_sTY(KatnYqyQCInmZhe+73JqDfW2&$iQ6q^IL(9V zO~LIJbDVnhfsWA!MJ!T8!-RmT2gHOYTObFX@Kf`Esl5o8tZn{@$ucl7S$n!ThE&{2 z`t$$4{b2_twKhh!#e5P4>>Ct{KYi*hSha?wiNgJZFwh*N^S__a)`*YEBfq{l(ih-@aba+mPvFio!OANA*YA z9E=2JCw$)6zMH%4sltJyM>%9uVo6+`-G}sE~Jb*^Ohzx*DfW6+N@B_`BTU zudmG|?dt#Wl+9SP#^mtn@bw>EU8M!qvp)LXBE#UdbJ2??u1`e?@l6L7yZ1}_&9!2l zUj6x-u7ohdq6;!p+x5A=G*}4F&ND1@$=g- z4U)En{JTzRhmhDmG3n6v? zd1(bDTbQS_YMt^*=;51ZQ+evco14Wsd@G#vnLnr=+UZck7Ar92mwE0zEmdKI;Vst0I2#6U;qFB literal 0 HcmV?d00001 diff --git a/html/images/controller_status_ready.png b/html/images/controller_status_ready.png new file mode 100644 index 0000000000000000000000000000000000000000..63fb2c6c1542c0c7f21091c36c6c0fb540fcbefe GIT binary patch literal 2003 zcmaJ?Yg7|w8Xi;v!g2%^RxP_30&a_tD@h*qNm74-}VU3jv60i+orHYHJu4u`M1X$sKTPp0tirpVe=giD^InVRF@B6*a zIo}~+Qk<8^Iu8H+|xa&|xjY6(cFI95G0A5D+bcGa-<#mMEZP zNFp=sya`1Dz*3wlRg8!QA26k`njmpv2u8IQWdlHDlu;{@W7H-_qh67bH z7EVMHkObOTNU4g?(?KbDNvYDjEGa{Vi`ocA8kwko8bTzXQJt;PGmR|VYh5NfcWx7L z;A;qy#lroXlvp4HV__Wx(g2v~_N~6=sp&*4srVvT!OUIL`Od6d@2?yUi zI5e70CTAvdcyD5%D;7?PAX+AoXfPNEhA;xGQxM4v2E(aAq2N&jUT@MM5+h!t4_r{- zKzgZ8rA1V*26QS)GT|JAg+nv_wFI^Ht*l1>=9tg}BN`=IBAGyPmb3sA2!0=`R=-8- zk!0w%eE+YoKGmd!h{=#1&e2KH#>oSnp|s3c9V9_uT`CM`FPx%K2_vvx32VXF6gv2x zNTrd%27T~rygSSDX^tAwAPZdCZ(PQrT&ES(S~M~T(y4MG8BYhR!Pg}-Rg33BUsUf6SGIUA z;fr#KXfi}+WB;eo3tOmroYS|qMHg?44{1=h>rh*Zs@b0bz_K_#Cpy(QFe*w^rgPWK z4G$hG-BG$d;Z9M2hhOw^{1)tGSM0xHgqEFwSDNsvN2P&;PxqDi)o7}I*zy7|iH4lyUr< zs>r?@rNv2p|K$F4Et%o}*nP&DCaNI$J{?*!&oHGN$J+ZPu~q&ZdHp@E9(URIulQ7# zHk@@ye0H@oyKPDE^%Fz#+QhQlVwalMPP-Q-jO~*)yM=PPx-rbXDcwv;$F$DN+x_de z4ge7ee%`s{V+FPLkc~YRzSP2W>$aYlS6S}wRl2{7%#dxg;4%*FD~XOLVKLiF8(fe4 z@TlK&>(4r$ZM&O(Y*%JSc8n=B?Im&HXALR!16?aOPpqvz(E21g>jqmm1oXY~!Mhf7 zo-|*y)vqMu4;%;;xL$CS988tdv=N;_eJT1)b=<6Yfq(`tFXtMTb$vdwXGy7{6nAaUzU z+@bsX-VNmqbIBD2vmFJt+gxk*Nc?2q?W%dYgv^e5 zajiMHDE{NL5Fo`4?*%-Ei5o~{jLhaH|&-E&jlca+tk!rP%oPI(K{GueHYZeA*B9DnGG$)n~^ z{s#NDpM1V^vKFq0_@UGXj_^uU&)3@J%a_xb+DjJ94!m6C}an8WAz zM||U&f3iok{9*1kuU^5FL`fyS%8>6rKfZZ(MQGSb@vhgTS|#X89k`lC5- z>{9+XFg@xz_e;U%z}?z&Zl;T>x+Om2tB>;Ar@uPBl#^99B;0j%U>H|B7jUY1*87%0 zK=5esne!^1HeV3^eD48upT*_lmj{o1^6$@1Yi3-q-ev2}gUebxKPr#e&{@Ot`_Ia~ zs(>AM_SfG!YR${4TC4Tz|DZ6f^*kvTzg&LPu8VXx$M>5PUqsdK;-1bbnY@p^>tDa= z;MchaJcBwr_Wq@!It4SFmT*`Y&#HIJ{qscmsOkNC`+xMP|MGb8?jAZ&H#yk`ECqtH V#c3CY8e+EZ`7h^mH=FpM+E|b zY$Uo7yrnC2?Nd^e{`m5Vi=u829IN@L%l?Ona=$tSBN@P(PfHy#;$4B1<>>&_2 z7?Vr^DWn5f8ixg^u3_K;7FWuKK~R)B+j*2PNqYi0xt`WXU7;$VLV zMIm`X@f;oiMZvAiX%tx;$+(hO>8fwV+eNME!$(i)3GV=XbzFAq%WjYkj1 zdJ|l}_>!J*um}+3ViAbAxHx#66`aFkAdt4Uwrd)emgZ7~IX|8aQU&I0zR|h@0pQbk zOfJaeu%T;;)G$sAh=WNZ{W}E~_p2U+SW9UgNFx1zD2w$K%?G`K zf8zb0!hCW(7eIIed`=9HCT(1}(V8nR7S98yAcsfhaH7_$=oP^MIs6C?7mD{mLrwgd zY&s{7Z~7TeB4LSaK1gNL03rbglPbWOOgh#EZ;i6HA=tQ}P|irCGujDdv(FY|B{jPs zF;>pD>s$hd7Q+JA;5wK757+ja+_h0)aiyLK0FN09&|P>O7W8wO$J%H>v9%4$f0X4Rwy$}p9%CFh8& z!Nt5ZEmUT*o2*N9N=~3*rD|zCrPT2|y(dTGT9(FUpJ1%J)ZHY1{k~GfUl?b+`mKjw zOAT+nnD6TUe%YYicZ0^gkk-1ULi-0fGG-5U6|HCr8x7{Q^%r#apP(`V45 zo5JL)q^4Iv^J-Ow=q@p#6?%37?}DJ48Zj2+i#ta4KZ7tT(?{(fR_F0i>8&;H!(rtb z^cJns-?O@w$9GKRAu1s$6FU?yH)%A`r{B~RwqZp>?~i8ofsClctul6+YKI+98#36Z z{CU)&@9BeD*ic=PzJ4YD7(?9i05N#WK=HMFcJ*tf2hG%6VB?fw>CmFCQ!0=XtC`78 ze!3&W=(OxF)G)U@-F)Wq^Qm(T7nA(zcjOZfW7Q8v-)<;?Q*)60H*ZjzhK%E#l)}<& zBV?`A>PF659nRC;Ec}G4kB3ZZ?eR{5kwcuW?vA zVXU9IH^N)z&b0A?O9pxnA2~5I^0&r;2Z6^{&yYLgR^*gZa*I3SZwj@pDOEpOlAqg^| zBbxCUaK>Mi7o}%t&lQ|2`z2nOjP27cmB2}oeUQ}VM>cU3Px?LFyy-!;y>~;GhK7f) zb&+qBr%le{=5Am9AV`*Z(5t?dH;PLa%J!+vK$2vg9)6qb-X;r$)`p z(WK4As~&d}A>B#S%@lp#1Fwy4jnrYHC2wp9%=*-5oUe!y;`J_C&i`~$@^IBf^H0gr?PmY6rl%uya?uX%wKkF8}HvZvdfL^B4}Tn_q6zUWOkF1 zQjuo)%&Rk33chnU`}Fo#@2cI}cs&nhPHy%5ct<@BODBQf>pNfYm;)zHiM%vBJQgZ-DxpRD~y39BWHRiXJacr)E?cRaBf04oX&&?=A{9R0^8cbz+Tt za1v`Tdi(QE8Rs_Uj~_i-E$cNHu`^MrAZa4#L~hXOOT^5ClTC%54LG0qow9l-?~t#d zknXdsrnjDN05M_57~S{w;U|gy!P%4%!e`s29~oPx+# zdke6)sbNal7ar#a&wS6gKa*VOH;V3$wQ6;F7-<*vL9@qABP+@-=_(7J zs7dNQgBqJ!afjsm$S$4esb6(u7p43mghqQ7ypA&pSN;xL6giW={szOFsR*!R9`#!E+c!) CkoCp@ literal 0 HcmV?d00001 diff --git a/html/images/other_status_off.png b/html/images/other_status_off.png new file mode 100644 index 0000000000000000000000000000000000000000..1dc9b1aa924d4d84e269e3a4041e742b174b0978 GIT binary patch literal 1290 zcmbVMZD<>19KW>PTGKWI+2-2mc(`@y#*({Ba+l<6)?Dw>HO#bG5@I2qS@SdjZG22523(z(h=E+pYSM?iO(MFI-6L{L_Ws>zna_?j+@=Jqy$gEfdX z62{k^%ES|Z*9-_~kI$VWDGD%*hw{@5LmdWQlJXKHx*0d+XK9A@2EfLJBWs3~XOlwT zhAp%T;|0soS%N5)N}iI>qZz{l6$*uH4X@XY5N>l!wZyVpHTTyQ1Zd_AS+`_O1-7D? z)kdu_jyzotLDA#!O<~pCNEAvLQ5JQA@{ok0*m13)O)CliabrugnI6+2k%Xo;YUEHo z^84##l)DETvVq7OcF>SfQN*I4GEm6(Ex?LIB-QaQ$ zzjoXk>CCvi3zw#g%ljtYmG6un zn*UC?@QQhQxowxbr@i`n|G~4XGf(Vxe)>|OwsQ1@Qhs>i=hSD8*0=NLzu7n6R2$rx zaou``i@p5QfooI88nC0gP!HY{63zZ6}P)4x~s6+&dfKagTdJHL%5OX3K${l|Hijx7 z3Dg`gMIMq4gHh>1kt97;!jNKD2LS$hCQ6_L5iy`wDpVS#o`s#}Wumh2n1}_YRghE` zcE+h#K{&vHU=W}ZeDD$ynGDcq1hOxcMkB8TC?qn4NJ4KKp6tt{(wG!KVD`eI)?lfO z8OaTvwT13j*c1d&Gl@iii#rCK2PNUYM#CJId%Q7={#$pjKnsWiqlt*t>K!GGNNq_#$s zrUr?Tpa#;y60{yN+#DFq-RBJ%6;W@PVXz!6ideygBw8h?Lik)37X3ny%B4(pFvpj} z;nICcR637FM#HDj85}l+N@7zvR0eI1<5O4?FPQD?Lu0f3*eH^R3Uqo9nNH&b@%%U> zHe(LUS7{KjN&?Q=m7{iNv5e1RnH(4tBM>ZtAjMnK0m1+H{MZS(P;aQhhVZoY527?7WLE_*G0Jj?w|V2PXMBOT|VCt+!YzA#_W zzc9o^x1?LEsIsHp_+VE9ozeRRDu2Jl<#QdQUT z%~Z#t7k!Uq$$ggEoop}6&FvQ}J@l2%<~E6|RyWv%Jo>z_;PNfVI1<3e-{KF+0!WR3ls39GnKV z`{~{t+Ebkk!;>4w1wSs%32$+4>Oa!G$vfLRW9aBf3n!LV6Q{IS@OLzpIyFAQ%kv6e zXIiQ~FW5L;``YHVuqLWl8kSoY(c%(L@jB5sd8{-tbEQ%+vdC@|Ce9U;fXnq>VcIUb zPVhLcyqzgu_Mq(Y54@g>BHofvlcxCNmm<0f+eZ4DaOHL8O;p&X1-!^|x~k2iMCwT|+XxMl8|{u!CDc|C2tjHKEL4qbaL) z@T~6bydU9i9U`c+miJ3+o$e0jkN#0p(;a{1amD?hj1O4DGnxGk$H3w)cAoXYHhf2+ zuKN8%p`a-A&ApM`_nq3Ciw;Y36Ju5`SnAk+(&@_XU5<>=Gc`{)r@%d-Z@zcWKn8x( zmh_Uw62O;xw(#QY0;BErx4Mj-uC2Irhv(SWLAhqRDq@@2UgGH;J)6626pexJviycW zIP_a=NCbO4WCyo$Po%S#JKml5qWN*cmOBjRk_W0O(?iYi#i6T|wxos*CBE|PcuVfN u9H2OD(d81bWD3_mm{7R_vm$Hq3lhfWkeP6q{qr&7Uy9EYa(@m=-2FGwt-eVB literal 0 HcmV?d00001 diff --git a/html/images/other_status_standby.png b/html/images/other_status_standby.png new file mode 100644 index 0000000000000000000000000000000000000000..4cf5202bcbc46f3c8e6df1deb8e45b3c1c41351f GIT binary patch literal 1385 zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz$r9IylHmNblJdl&R0hYC{G?O` z&)mfH)S%SFl*+=BsWuD@%xRe+5hW46K32*3xq68pHF_1f1wh>l3^w)^1&PVosU-?Y zsp*+{wo31J?^jaDOtDo8H}y5}EpSfF$n>ZxN)4{^3rViZPPR-@vbR&PsjvbXkegbP zs8ErclUHn2VXFi-*9yo63F|8KW+g=7RhMR$W{Yl!|Z$R@KEJl?AE#L8-<0 zrA5iW_()TRX$FQJev3c~fv&OgFUkZ)N@9*nesXDUYF>$_i>(q+MlU5Z#mdpm*~Hn| z#lpnE)WX%w5a@j)3rlB5BU1xMQ)g34Gng6J^qLx*S(-T;8akRgIvE<<`tJD<|U`X?9Bw)3)O3YSFe?GQEFmIeo;t%ehw@J1Z3owJ;K1iIMdU`F{I+wlj(c?m>fk~%a0!M z+c4?IXTA`LMXd`j{0P=Oudpra2n+L;b-nrv!v48%J1sPf_{jIgMZ4ZgsMOZnvbA-$ zwXwCdiqEG~>*w?KS{J{Mz5cy6eMa^n$xpM^Y~PeTkMZd9X%2qDyV-A<8Es(pV$%e1=Hdi7k>oiW)hd>R#hWvm7GykJ za6iENwQ$G*@rq3e4_In~gHJYan>k#4R4Tr60 literal 0 HcmV?d00001 diff --git a/html/images/tracker_status_off.png b/html/images/tracker_status_off.png new file mode 100644 index 0000000000000000000000000000000000000000..4f266aa454477b9a5f31f0910edf37bc1af41135 GIT binary patch literal 1279 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 literal 0 HcmV?d00001 diff --git a/html/index.html b/html/index.html new file mode 100644 index 00000000..453a4f56 --- /dev/null +++ b/html/index.html @@ -0,0 +1,1722 @@ + + + + + + + +VRCX + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/html/vr.css b/html/vr.css new file mode 100644 index 00000000..dbc1dac9 --- /dev/null +++ b/html/vr.css @@ -0,0 +1,222 @@ +@charset "utf-8"; +/* +Copyright(c) 2019 pypy. All rights reserved. + +This work is licensed under the terms of the MIT license. +For a copy, see . +*/ + +/* + 마지노선인듯 + 화면 24px -> 나나 32 + 손등 18px -> 나나 24 +*/ + +.noty_body { + display: block; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.noty_layout { + max-width: none; + width: 80% !important; +} + +.noty_theme__relax.noty_bar { + margin: 4px 0; + overflow: hidden; + border-radius: 2px; + position: relative; +} + +.noty_theme__relax.noty_bar .noty_body { + padding: 5px 10px 10px; + font-size: 24px; + text-align: center; +} + +.noty_theme__relax.noty_bar .noty_buttons { + border-top: 1px solid #e7e7e7; + padding: 5px 10px; +} + +.noty_theme__relax.noty_type__alert, .noty_theme__relax.noty_type__notification { + background-color: #fff; + border: 1px solid #dedede; + color: #444; +} + +.noty_theme__relax.noty_type__warning { + background-color: #FFEAA8; + border: 1px solid #FFC237; + color: #826200; +} + +.noty_theme__relax.noty_type__warning .noty_buttons { + border-color: #dfaa30; +} + +.noty_theme__relax.noty_type__error { + background-color: #FF8181; + border: 1px solid #e25353; + color: #FFF; +} + +.noty_theme__relax.noty_type__error .noty_buttons { + border-color: darkred; +} + +.noty_theme__relax.noty_type__info, .noty_theme__relax.noty_type__information { + background-color: #78C5E7; + border: 1px solid #3badd6; + color: #FFF; +} + +.noty_theme__relax.noty_type__info .noty_buttons, .noty_theme__relax.noty_type__information .noty_buttons { + border-color: #0B90C4; +} + +.noty_theme__relax.noty_type__success { + background-color: #BCF5BC; + border: 1px solid #7cdd77; + color: darkgreen; +} + +.noty_theme__relax.noty_type__success .noty_buttons { + border-color: #50C24E; +} + +::-webkit-scrollbar { + width: 8px; + height: 8px; +} + +::-webkit-scrollbar-track { + background: rgba(0, 0, 0, 0.1); + border-radius: 16px; +} + +::-webkit-scrollbar-thumb { + background: rgba(0, 0, 0, 0.25); + border-radius: 16px; +} + +body, input, textarea, select, button { + font-family: 'Noto Sans JP', 'Noto Sans KR', 'Meiryo UI', 'Malgun Gothic', 'Segoe UI', sans-serif; + line-height: normal; +} + +.x-app { + display: flex; + flex-direction: column; + position: absolute; + width: 100%; + height: 100%; + overflow: hidden; +} + +.x-app-type { + background: #1f1f1f; + color: #fff; +} + +.x-container { + flex: none; + padding: 10px; + overflow: hidden auto; + position: relative; +} + +.x-friend-list { + overflow: hidden auto; + padding: 0 10px; +} + +.x-friend-item { + display: flex; + align-items: center; + font-size: 18px; + box-sizing: border-box; +} + +.x-friend-item .time { + margin-right: 5px; +} + +.x-friend-item .name { + font-weight: bold; +} + +.x-friend-item.friend .name { + color: #fff; +} + +.x-friend-item.favorite .name { + color: #ff0; +} + +.x-friend-item>.avatar { + flex: none; + width: 40px; + height: 40px; + margin-right: 8px; + display: inline-block; + position: relative; +} + +.x-friend-item>img.avatar { + width: 50px; + height: 37.5px; + margin-left: 5px; + margin-right: 0; + border-radius: 2px; +} + +.x-friend-item>.avatar>img { + width: 100%; + height: 100%; + border-radius: 40%; + object-fit: cover; +} + +.x-friend-item>.detail { + flex: 1; + overflow: hidden; +} + +.x-friend-item>.detail>.name, .x-friend-item>.detail>.extra { + display: block; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} + +.x-friend-item>.detail>.name { + font-weight: bold; +} + +.x-friend-item>.detail>.extra { + font-weight: normal; +} + +i.x-user-status { + display: inline-block; + width: 14px; + height: 14px; + border-radius: 50%; + background: gray; +} + +i.x-user-status.active { + background: #67C23A; +} + +i.x-user-status.joinme { + background: #409EFF; +} + +i.x-user-status.busy { + background: #F56C6C; +} \ No newline at end of file diff --git a/html/vr.html b/html/vr.html new file mode 100644 index 00000000..a1165005 --- /dev/null +++ b/html/vr.html @@ -0,0 +1,144 @@ + + + + + + + +VRCXVR + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/html/vr.js b/html/vr.js new file mode 100644 index 00000000..d2a176a3 --- /dev/null +++ b/html/vr.js @@ -0,0 +1,726 @@ +// Copyright(c) 2019 pypy. All rights reserved. +// +// This work is licensed under the terms of the MIT license. +// For a copy, see . + +if (window.CefSharp) { + Promise.all([ + CefSharp.BindObjectAsync('VRCX'), + CefSharp.BindObjectAsync('VRCXStorage') + ]).catch(() => { + location = 'https://github.com/pypy-vrc/vrcx'; + }).then(() => { + + VRCXStorage.GetBool = function (key) { + return this.Get(key) === 'true'; + }; + + VRCXStorage.SetBool = function (key, value) { + this.Set(key, value + ? 'true' + : 'false'); + }; + + VRCXStorage.GetInt = function (key) { + return parseInt(this.Get(key), 10) || 0; + }; + + VRCXStorage.SetInt = function (key, value) { + this.Set(key, String(value)); + }; + + VRCXStorage.GetFloat = function (key) { + return parseFloat(this.Get(key), 10) || 0.0; + }; + + VRCXStorage.SetFloat = function (key, value) { + this.Set(key, String(value)); + }; + + VRCXStorage.GetArray = function (key) { + try { + var json = this.Get(key); + if (json) { + var array = JSON.parse(json); + if (Array.isArray(array)) { + return array; + } + } + } catch (err) { + console.error(err); + } + return []; + }; + + VRCXStorage.SetArray = function (key, value) { + this.Set(key, JSON.stringify(value)); + }; + + VRCXStorage.GetObject = function (key) { + try { + var json = this.Get(key); + if (json) { + return JSON.parse(json); + } + } catch (err) { + console.error(err); + } + return {}; + }; + + VRCXStorage.SetObject = function (key, value) { + this.Set(key, JSON.stringify(value)); + }; + + Noty.overrideDefaults({ + animation: { + open: 'animated fadeIn', + close: 'animated zoomOut' + }, + layout: 'topCenter', + theme: 'relax', + timeout: 6000 + }); + + var escapeTag = (s) => String(s).replace(/["&'<>]/gu, (c) => `&#${c.charCodeAt(0)};`); + Vue.filter('escapeTag', escapeTag); + + var commaNumber = (n) => String(Number(n) || 0).replace(/(\d)(?=(\d{3})+(?!\d))/gu, '$1,'); + Vue.filter('commaNumber', commaNumber); + + var formatDate = (s, format) => { + var ctx = new Date(s); + if (isNaN(ctx)) { + return escapeTag(s); + } + var hours = ctx.getHours(); + var map = { + 'YYYY': String(10000 + ctx.getFullYear()).substr(-4), + 'MM': String(101 + ctx.getMonth()).substr(-2), + 'DD': String(100 + ctx.getDate()).substr(-2), + 'HH24': String(100 + hours).substr(-2), + 'HH': String(100 + (hours > 12 + ? hours - 12 + : hours)).substr(-2), + 'MI': String(100 + ctx.getMinutes()).substr(-2), + 'SS': String(100 + ctx.getSeconds()).substr(-2), + 'AMPM': hours >= 12 + ? 'PM' + : 'AM' + }; + return format.replace(/YYYY|MM|DD|HH24|HH|MI|SS|AMPM/gu, (c) => map[c] || c); + }; + Vue.filter('formatDate', formatDate); + + var textToHex = (s) => String(s).split('').map((c) => c.charCodeAt(0).toString(16)).join(' '); + Vue.filter('textToHex', textToHex); + + var timeToText = (t) => { + var sec = Number(t); + if (isNaN(sec)) { + return escapeTag(t); + } + sec = Math.floor(sec / 1000); + var arr = []; + if (sec < 0) { + sec = -sec; + } + if (sec >= 86400) { + arr.push(`${Math.floor(sec / 86400)}d`); + sec %= 86400; + } + if (sec >= 3600) { + arr.push(`${Math.floor(sec / 3600)}h`); + sec %= 3600; + } + if (sec >= 60) { + arr.push(`${Math.floor(sec / 60)}m`); + sec %= 60; + } + if (sec || + !arr.length) { + arr.push(`${sec}s`); + } + return arr.join(' '); + }; + Vue.filter('timeToText', timeToText); + + ELEMENT.locale(ELEMENT.lang.en); + + // + // API + // + + var API = {}; + + API.$handler = {}; + + API.$emit = function (event, ...args) { + try { + // console.log(event, ...args); + var h = this.$handler[event]; + if (h) { + h.forEach((f) => f(...args)); + } + } catch (err) { + console.error(err); + } + }; + + API.$on = function (event, callback) { + var h = this.$handler[event]; + if (h) { + h.push(callback); + } else { + this.$handler[event] = [callback]; + } + }; + + API.$off = function (event, callback) { + var h = this.$handler[event]; + if (h) { + h.find((val, idx, arr) => { + if (val !== callback) { + return false; + } + if (arr.length > 1) { + arr.splice(idx, 1); + } else { + delete this.$handler[event]; + } + return true; + }); + } + }; + + API.$fetch = {}; + + API.call = function (endpoint, options) { + var input = `https://api.vrchat.cloud/api/1/${endpoint}`; + var init = { + method: 'GET', + mode: 'cors', + credentials: 'include', + cache: 'no-cache', + referrerPolicy: 'no-referrer', + ...options + }; + if (init.method === 'GET') { + if (init.body) { + var url = new URL(input); + for (var key in init.body) { + url.searchParams.set(key, init.body[key]); + } + input = url.toString(); + init.body = null; + } + // merge requests + if (this.$fetch[input]) { + return this.$fetch[input]; + } + } else { + init.headers = { + 'Content-Type': 'application/json;charset=utf-8', + ...init.headers + }; + init.body = init.body + ? JSON.stringify(init.body) + : '{}'; + } + var req = fetch(input, init).catch((err) => { + this.$throw(0, err); + }).then((res) => res.json().catch(() => { + if (!res.ok) { + this.$throw(res.status); + } + this.$throw(0, 'Invalid JSON'); + }).then((json) => { + if (!res.ok) { + if (typeof json.error === 'object') { + this.$throw( + json.error.status_code || res.status, + json.error.message, + json.error.data + ); + } else if (typeof json.error === 'string') { + this.$throw( + json.status_code || res.status, + json.error + ); + } else { + this.$throw(res.status, json); + } + } + return json; + })); + if (init.method === 'GET') { + this.$fetch[input] = req.finally(() => { + delete this.$fetch[input]; + }); + } + return req; + }; + + API.$status = { + 100: 'Continue', + 101: 'Switching Protocols', + 102: 'Processing', + 103: 'Early Hints', + 200: 'OK', + 201: 'Created', + 202: 'Accepted', + 203: 'Non-Authoritative Information', + 204: 'No Content', + 205: 'Reset Content', + 206: 'Partial Content', + 207: 'Multi-Status', + 208: 'Already Reported', + 226: 'IM Used', + 300: 'Multiple Choices', + 301: 'Moved Permanently', + 302: 'Found', + 303: 'See Other', + 304: 'Not Modified', + 305: 'Use Proxy', + 306: 'Switch Proxy', + 307: 'Temporary Redirect', + 308: 'Permanent Redirect', + 400: 'Bad Request', + 401: 'Unauthorized', + 402: 'Payment Required', + 403: 'Forbidden', + 404: 'Not Found', + 405: 'Method Not Allowed', + 406: 'Not Acceptable', + 407: 'Proxy Authentication Required', + 408: 'Request Timeout', + 409: 'Conflict', + 410: 'Gone', + 411: 'Length Required', + 412: 'Precondition Failed', + 413: 'Payload Too Large', + 414: 'URI Too Long', + 415: 'Unsupported Media Type', + 416: 'Range Not Satisfiable', + 417: 'Expectation Failed', + 418: "I'm a teapot", + 421: 'Misdirected Request', + 422: 'Unprocessable Entity', + 423: 'Locked', + 424: 'Failed Dependency', + 425: 'Too Early', + 426: 'Upgrade Required', + 428: 'Precondition Required', + 429: 'Too Many Requests', + 431: 'Request Header Fields Too Large', + 451: 'Unavailable For Legal Reasons', + 500: 'Internal Server Error', + 501: 'Not Implemented', + 502: 'Bad Gateway', + 503: 'Service Unavailable', + 504: 'Gateway Timeout', + 505: 'HTTP Version Not Supported', + 506: 'Variant Also Negotiates', + 507: 'Insufficient Storage', + 508: 'Loop Detected', + 510: 'Not Extended', + 511: 'Network Authentication Required', + // CloudFlare Error + 520: 'Web server returns an unknown error', + 521: 'Web server is down', + 522: 'Connection timed out', + 523: 'Origin is unreachable', + 524: 'A timeout occurred', + 525: 'SSL handshake failed', + 526: 'Invalid SSL certificate', + 527: 'Railgun Listener to origin error' + }; + + API.$throw = function (code, error) { + throw { + 'status_code': code, + error + }; + }; + + // API: Config + + API.config = {}; + + API.$on('CONFIG', (args) => { + args.ref = API.updateConfig(args.json); + }); + + API.getConfig = function () { + return this.call('config', { + method: 'GET' + }).then((json) => { + var args = { + json + }; + this.$emit('CONFIG', args); + return args; + }); + }; + + API.updateConfig = function (ref) { + var ctx = { + clientApiKey: '', + ...ref + }; + this.config = ctx; + return ctx; + }; + + // API: Location + + API.parseLocation = function (tag) { + var L = { + tag: String(tag || ''), + isOffline: false, + isPrivate: false, + worldId: '', + instanceId: '', + instanceName: '', + accessType: '', + userId: null, + hiddenId: null, + privateId: null, + friendsId: null, + canRequestInvite: false + }; + if (L.tag === 'offline') { + L.isOffline = true; + } else if (L.tag === 'private') { + L.isPrivate = true; + } else if (!L.tag.startsWith('local')) { + var sep = L.tag.indexOf(':'); + if (sep >= 0) { + L.worldId = L.tag.substr(0, sep); + L.instanceId = L.tag.substr(sep + 1); + L.instanceId.split('~').forEach((s, i) => { + if (i) { + var A = s.indexOf('('); + var Z = A >= 0 + ? s.lastIndexOf(')') + : -1; + var key = Z >= 0 + ? s.substr(0, A) + : s; + var value = A < Z + ? s.substr(A + 1, Z - A - 1) + : ''; + if (key === 'hidden') { + L.hiddenId = value; + } else if (key === 'private') { + L.privateId = value; + } else if (key === 'friends') { + L.friendsId = value; + } else if (key === 'canRequestInvite') { + L.canRequestInvite = true; + } + } else { + L.instanceName = s; + } + }); + L.accessType = 'public'; + if (L.privateId !== null) { + if (L.canRequestInvite) { + // InvitePlus + L.accessType = 'invite+'; + } else { + // InviteOnly + L.accessType = 'invite'; + } + L.userId = L.privateId; + } else if (L.friendsId !== null) { + // FriendsOnly + L.accessType = 'friends'; + L.userId = L.friendsId; + } else if (L.hiddenId !== null) { + // FriendsOfGuests + L.accessType = 'friends+'; + L.userId = L.hiddenId; + } + } else { + L.worldId = L.tag; + } + } + return L; + }; + + Vue.component('location', { + template: '{{ text }}', + props: { + location: String + }, + data() { + return { + text: this.location + }; + }, + methods: { + parse() { + var L = API.parseLocation(this.location); + if (L.isOffline) { + this.text = 'Offline'; + } else if (L.isPrivate) { + this.text = 'Private'; + } else if (L.worldId) { + var ref = API.world[L.worldId]; + if (ref) { + this.text = `${ref.name} #${L.instanceName} ${L.accessType}`; + } else { + API.getWorld({ + worldId: L.worldId + }).then((args) => { + if (L.tag === this.location) { + this.text = `${args.ref.name} #${L.instanceName} ${L.accessType}`; + } + return args; + }); + } + } + } + }, + watch: { + location() { + this.parse(); + } + }, + created() { + this.parse(); + } + }); + + // API: World + + API.world = {}; + + API.$on('WORLD', (args) => { + args.ref = API.updateWorld(args.json); + }); + + /* + param: { + worldId: string + } + */ + API.getWorld = function (param) { + return this.call(`worlds/${param.worldId}?apiKey=${this.config.clientApiKey}`, { + method: 'GET' + }).then((json) => { + var args = { + param, + json + }; + this.$emit('WORLD', args); + return args; + }); + }; + + API.updateWorld = function (ref) { + var ctx = this.world[ref.id]; + if (ctx) { + Object.assign(ctx, ref); + } else { + ctx = { + id: ref.id, + name: '', + description: '', + authorId: '', + authorName: '', + capacity: 0, + tags: [], + releaseStatus: '', + imageUrl: '', + thumbnailImageUrl: '', + assetUrl: '', + assetUrlObject: {}, + pluginUrl: '', + pluginUrlObject: {}, + unityPackageUrl: '', + unityPackageUrlObject: {}, + unityPackages: [], + version: 0, + previewYoutubeId: '', + favorites: 0, + created_at: '', + updated_at: '', + publicationDate: '', + labsPublicationDate: '', + visits: 0, + popularity: 0, + heat: 0, + publicOccupants: 0, + privateOccupants: 0, + occupants: 0, + instances: [], + // custom + labs_: false, + // + ...ref + }; + this.world[ctx.id] = ctx; + } + if (ctx.tags) { + ctx.labs_ = ctx.tags.includes('system_labs'); + } + return ctx; + }; + + var $app = { + data: { + API, + VRCX, + // 1 = 대시보드랑 손목에 보이는거 + // 2 = 항상 화면에 보이는 거 + appType: location.href.substr(-1), + currentTime: new Date().toJSON(), + cpuUsage: 0, + feeds: [], + devices: [] + }, + computed: {}, + methods: {}, + watch: {}, + el: '#x-app', + mounted() { + // https://media.discordapp.net/attachments/581757976625283083/611170278218924033/unknown.png + // 현재 날짜 시간 + // 컨트롤러 배터리 상황 + // -- + // OO is Let's Just H!!!!! [GPS] + // OO has logged in [Online] + // OO has logged out [Offline] + // OO has joined [OnPlayerJoined] + // OO has left [OnPlayerLeft] + // [Moderation] + // OO has blocked you + // OO has muted you + // OO has hidden you + // -- + API.getConfig().catch((err) => { + // FIXME: 어케 복구하냐 이건 + throw err; + }).then((args) => { + setInterval(() => this.update(), 1000); + this.update(); + this.$nextTick(() => { + if (this.appType === '1') { + this.$el.style.display = ''; + } + }); + return args; + }); + } + }; + + $app.methods.update = function () { + this.currentTime = new Date().toJSON(); + VRCX.CpuUsage().then((cpuUsage) => { + this.cpuUsage = cpuUsage.toFixed(2); + }); + VRCX.GetVRDevices().then((devices) => { + devices.forEach((device) => { + device[2] = parseInt(device[2], 10); + }); + this.devices = devices; + }); + this.updateSharedFeed(); + }; + + $app.methods.updateSharedFeed = function () { + // TODO: block mute hideAvatar unfriend + var _feeds = this.feeds; + this.feeds = VRCXStorage.GetArray('sharedFeeds'); + if (this.appType === '2') { + var map = {}; + _feeds.forEach((feed) => { + if (feed.isFavorite) { + if (feed.type === 'OnPlayerJoined' || + feed.type === 'OnPlayerLeft') { + if (!map[feed.data] || + map[feed.data] < feed.created_at) { + map[feed.data] = feed.created_at; + } + } else if (feed.type === 'Online' || + feed.type === 'Offline') { + if (!map[feed.displayName] || + map[feed.displayName] < feed.created_at) { + map[feed.displayName] = feed.created_at; + } + } + } + }); + var notys = []; + this.feeds.forEach((feed) => { + if (feed.isFavorite) { + if (feed.type === 'Online' || + feed.type === 'Offline') { + if (!map[feed.displayName] || + map[feed.displayName] < feed.created_at) { + map[feed.displayName] = feed.created_at; + notys.push(feed); + } + } else if (feed.type === 'OnPlayerJoined' || + feed.type === 'OnPlayerLeft') { + if (!map[feed.data] || + map[feed.data] < feed.created_at) { + map[feed.data] = feed.created_at; + notys.push(feed); + } + } + } + }); + var bias = new Date(Date.now() - 60000).toJSON(); + notys.forEach((noty) => { + if (noty.created_at > bias) { + if (noty.type === 'OnPlayerJoined') { + new Noty({ + type: 'alert', + text: `${noty.data} has joined` + }).show(); + } else if (noty.type === 'OnPlayerLeft') { + new Noty({ + type: 'alert', + text: `${noty.data} has left` + }).show(); + } else if (noty.type === 'Online') { + new Noty({ + type: 'alert', + text: `${noty.displayName} has logged in` + }).show(); + } else if (noty.type === 'Offline') { + new Noty({ + type: 'alert', + text: `${noty.displayName} has logged out` + }).show(); + } + } + }); + } + }; + + $app.methods.userStatusClass = function (user) { + var style = {}; + if (user) { + if (user.location === 'offline') { + style.offline = true; + } else if (user.status === 'active') { + style.active = true; + } else if (user.status === 'join me') { + style.joinme = true; + } else if (user.status === 'busy') { + style.busy = true; + } + } + return style; + }; + + $app = new Vue($app); + window.$app = $app; + }); +} else { + location = 'https://github.com/pypy-vrc/vrcx'; +} diff --git a/openvr_api.cs b/openvr_api.cs new file mode 100644 index 00000000..f96ad80b --- /dev/null +++ b/openvr_api.cs @@ -0,0 +1,7141 @@ +//======= Copyright (c) Valve Corporation, All rights reserved. =============== +// +// Purpose: This file contains C#/managed code bindings for the OpenVR interfaces +// This file is auto-generated, do not edit it. +// +//============================================================================= + +using System; +using System.Runtime.InteropServices; +using Valve.VR; + +namespace Valve.VR +{ + +[StructLayout(LayoutKind.Sequential)] +public struct IVRSystem +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetRecommendedRenderTargetSize(ref uint pnWidth, ref uint pnHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRecommendedRenderTargetSize GetRecommendedRenderTargetSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix44_t _GetProjectionMatrix(EVREye eEye, float fNearZ, float fFarZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetProjectionMatrix GetProjectionMatrix; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetProjectionRaw(EVREye eEye, ref float pfLeft, ref float pfRight, ref float pfTop, ref float pfBottom); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetProjectionRaw GetProjectionRaw; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ComputeDistortion(EVREye eEye, float fU, float fV, ref DistortionCoordinates_t pDistortionCoordinates); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ComputeDistortion ComputeDistortion; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetEyeToHeadTransform(EVREye eEye); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEyeToHeadTransform GetEyeToHeadTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync, ref ulong pulFrameCounter); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTimeSinceLastVsync GetTimeSinceLastVsync; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetD3D9AdapterIndex(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetD3D9AdapterIndex GetD3D9AdapterIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDXGIOutputInfo GetDXGIOutputInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetOutputDevice(ref ulong pnDevice, ETextureType textureType, IntPtr pInstance); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOutputDevice GetOutputDevice; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsDisplayOnDesktop(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsDisplayOnDesktop IsDisplayOnDesktop; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _SetDisplayVisibility(bool bIsVisibleOnDesktop); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDisplayVisibility SetDisplayVisibility; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, [In, Out] TrackedDevicePose_t[] pTrackedDevicePoseArray, uint unTrackedDevicePoseArrayCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDeviceToAbsoluteTrackingPose GetDeviceToAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ResetSeatedZeroPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ResetSeatedZeroPose ResetSeatedZeroPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSeatedZeroPoseToStandingAbsoluteTrackingPose GetSeatedZeroPoseToStandingAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetRawZeroPoseToStandingAbsoluteTrackingPose(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRawZeroPoseToStandingAbsoluteTrackingPose GetRawZeroPoseToStandingAbsoluteTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass, [In, Out] uint[] punTrackedDeviceIndexArray, uint unTrackedDeviceIndexArrayCount, uint unRelativeToTrackedDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSortedTrackedDeviceIndicesOfClass GetSortedTrackedDeviceIndicesOfClass; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EDeviceActivityLevel _GetTrackedDeviceActivityLevel(uint unDeviceId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceActivityLevel GetTrackedDeviceActivityLevel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ApplyTransform(ref TrackedDevicePose_t pOutputPose, ref TrackedDevicePose_t pTrackedDevicePose, ref HmdMatrix34_t pTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ApplyTransform ApplyTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceIndexForControllerRole GetTrackedDeviceIndexForControllerRole; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedControllerRole _GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerRoleForTrackedDeviceIndex GetControllerRoleForTrackedDeviceIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ETrackedDeviceClass _GetTrackedDeviceClass(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTrackedDeviceClass GetTrackedDeviceClass; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsTrackedDeviceConnected(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsTrackedDeviceConnected IsTrackedDeviceConnected; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetBoolTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoolTrackedDeviceProperty GetBoolTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFloatTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFloatTrackedDeviceProperty GetFloatTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetInt32TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInt32TrackedDeviceProperty GetInt32TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetUint64TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetUint64TrackedDeviceProperty GetUint64TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HmdMatrix34_t _GetMatrix34TrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMatrix34TrackedDeviceProperty GetMatrix34TrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetArrayTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, uint propType, IntPtr pBuffer, uint unBufferSize, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetArrayTrackedDeviceProperty GetArrayTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetStringTrackedDeviceProperty(uint unDeviceIndex, ETrackedDeviceProperty prop, System.Text.StringBuilder pchValue, uint unBufferSize, ref ETrackedPropertyError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetStringTrackedDeviceProperty GetStringTrackedDeviceProperty; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetPropErrorNameFromEnum(ETrackedPropertyError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPropErrorNameFromEnum GetPropErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEvent(ref VREvent_t pEvent, uint uncbVREvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextEvent PollNextEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEventWithPose(ETrackingUniverseOrigin eOrigin, ref VREvent_t pEvent, uint uncbVREvent, ref TrackedDevicePose_t pTrackedDevicePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextEventWithPose PollNextEventWithPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetEventTypeNameFromEnum(EVREventType eType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetEventTypeNameFromEnum GetEventTypeNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate HiddenAreaMesh_t _GetHiddenAreaMesh(EVREye eEye, EHiddenAreaMeshType type); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHiddenAreaMesh GetHiddenAreaMesh; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerState(uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerState GetControllerState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin, uint unControllerDeviceIndex, ref VRControllerState_t pControllerState, uint unControllerStateSize, ref TrackedDevicePose_t pTrackedDevicePose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerStateWithPose GetControllerStateWithPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _TriggerHapticPulse(uint unControllerDeviceIndex, uint unAxisId, ushort usDurationMicroSec); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TriggerHapticPulse TriggerHapticPulse; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetButtonIdNameFromEnum(EVRButtonId eButtonId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetButtonIdNameFromEnum GetButtonIdNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetControllerAxisTypeNameFromEnum GetControllerAxisTypeNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsInputAvailable(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsInputAvailable IsInputAvailable; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsSteamVRDrawingControllers(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsSteamVRDrawingControllers IsSteamVRDrawingControllers; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldApplicationPause(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldApplicationPause ShouldApplicationPause; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldApplicationReduceRenderingWork(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldApplicationReduceRenderingWork ShouldApplicationReduceRenderingWork; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRFirmwareError _PerformFirmwareUpdate(uint unDeviceIndex); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PerformFirmwareUpdate PerformFirmwareUpdate; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _AcknowledgeQuit_Exiting(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcknowledgeQuit_Exiting AcknowledgeQuit_Exiting; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _AcknowledgeQuit_UserPrompt(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AcknowledgeQuit_UserPrompt AcknowledgeQuit_UserPrompt; + + [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; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRApplications +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _AddApplicationManifest(string pchApplicationManifestFullPath, bool bTemporary); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AddApplicationManifest AddApplicationManifest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _RemoveApplicationManifest(string pchApplicationManifestFullPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveApplicationManifest RemoveApplicationManifest; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsApplicationInstalled(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsApplicationInstalled IsApplicationInstalled; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationCount GetApplicationCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetApplicationKeyByIndex(uint unApplicationIndex, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationKeyByIndex GetApplicationKeyByIndex; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetApplicationKeyByProcessId(uint unProcessId, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationKeyByProcessId GetApplicationKeyByProcessId; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchApplication(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchApplication LaunchApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchTemplateApplication(string pchTemplateAppKey, string pchNewAppKey, [In, Out] AppOverrideKeys_t[] pKeys, uint unKeys); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchTemplateApplication LaunchTemplateApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchApplicationFromMimeType(string pchMimeType, string pchArgs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchApplicationFromMimeType LaunchApplicationFromMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchDashboardOverlay(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchDashboardOverlay LaunchDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CancelApplicationLaunch(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CancelApplicationLaunch CancelApplicationLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _IdentifyApplication(uint unProcessId, string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IdentifyApplication IdentifyApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationProcessId(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationProcessId GetApplicationProcessId; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetApplicationsErrorNameFromEnum(EVRApplicationError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsErrorNameFromEnum GetApplicationsErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationPropertyString(string pchAppKey, EVRApplicationProperty eProperty, System.Text.StringBuilder pchPropertyValueBuffer, uint unPropertyValueBufferLen, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyString GetApplicationPropertyString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationPropertyBool(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyBool GetApplicationPropertyBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetApplicationPropertyUint64(string pchAppKey, EVRApplicationProperty eProperty, ref EVRApplicationError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationPropertyUint64 GetApplicationPropertyUint64; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _SetApplicationAutoLaunch(string pchAppKey, bool bAutoLaunch); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetApplicationAutoLaunch SetApplicationAutoLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationAutoLaunch(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationAutoLaunch GetApplicationAutoLaunch; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _SetDefaultApplicationForMimeType(string pchAppKey, string pchMimeType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDefaultApplicationForMimeType SetDefaultApplicationForMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetDefaultApplicationForMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDefaultApplicationForMimeType GetDefaultApplicationForMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetApplicationSupportedMimeTypes(string pchAppKey, System.Text.StringBuilder pchMimeTypesBuffer, uint unMimeTypesBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationSupportedMimeTypes GetApplicationSupportedMimeTypes; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationsThatSupportMimeType(string pchMimeType, System.Text.StringBuilder pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsThatSupportMimeType GetApplicationsThatSupportMimeType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetApplicationLaunchArguments(uint unHandle, System.Text.StringBuilder pchArgs, uint unArgs); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationLaunchArguments GetApplicationLaunchArguments; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer, uint unAppKeyBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetStartingApplication GetStartingApplication; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationTransitionState _GetTransitionState(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTransitionState GetTransitionState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _PerformApplicationPrelaunchCheck(string pchAppKey); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PerformApplicationPrelaunchCheck PerformApplicationPrelaunchCheck; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetApplicationsTransitionStateNameFromEnum GetApplicationsTransitionStateNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsQuitUserPromptRequested(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsQuitUserPromptRequested IsQuitUserPromptRequested; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRApplicationError _LaunchInternalProcess(string pchBinaryPath, string pchArguments, string pchWorkingDirectory); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LaunchInternalProcess LaunchInternalProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetCurrentSceneProcessId(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentSceneProcessId GetCurrentSceneProcessId; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRChaperone +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ChaperoneCalibrationState _GetCalibrationState(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCalibrationState GetCalibrationState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetPlayAreaSize(ref float pSizeX, ref float pSizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPlayAreaSize GetPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetPlayAreaRect(ref HmdQuad_t rect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPlayAreaRect GetPlayAreaRect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReloadInfo(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReloadInfo ReloadInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetSceneColor(HmdColor_t color); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetSceneColor SetSceneColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetBoundsColor(ref HmdColor_t pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, ref HmdColor_t pOutputCameraColor); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBoundsColor GetBoundsColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _AreBoundsVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _AreBoundsVisible AreBoundsVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceBoundsVisible(bool bForce); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceBoundsVisible ForceBoundsVisible; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRChaperoneSetup +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CommitWorkingCopy(EChaperoneConfigFile configFile); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CommitWorkingCopy CommitWorkingCopy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RevertWorkingCopy(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RevertWorkingCopy RevertWorkingCopy; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingPlayAreaSize(ref float pSizeX, ref float pSizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingPlayAreaSize GetWorkingPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingPlayAreaRect(ref HmdQuad_t rect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingPlayAreaRect GetWorkingPlayAreaRect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingCollisionBoundsInfo GetWorkingCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetLiveCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLiveCollisionBoundsInfo GetLiveCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingSeatedZeroPoseToRawTrackingPose GetWorkingSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetWorkingStandingZeroPoseToRawTrackingPose GetWorkingStandingZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingPlayAreaSize(float sizeX, float sizeZ); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingPlayAreaSize SetWorkingPlayAreaSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingCollisionBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, uint unQuadsCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingCollisionBoundsInfo SetWorkingCollisionBoundsInfo; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingPerimeter([In, Out] HmdVector2_t[] pPointBuffer, uint unPointCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingPerimeter SetWorkingPerimeter; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingSeatedZeroPoseToRawTrackingPose SetWorkingSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetWorkingStandingZeroPoseToRawTrackingPose SetWorkingStandingZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReloadFromDisk(EChaperoneConfigFile configFile); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReloadFromDisk ReloadFromDisk; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLiveSeatedZeroPoseToRawTrackingPose GetLiveSeatedZeroPoseToRawTrackingPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ExportLiveToBuffer(System.Text.StringBuilder pBuffer, ref uint pnBufferLength); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ExportLiveToBuffer ExportLiveToBuffer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ImportFromBufferToWorking(string pBuffer, uint nImportFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ImportFromBufferToWorking ImportFromBufferToWorking; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowWorkingSetPreview(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowWorkingSetPreview ShowWorkingSetPreview; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideWorkingSetPreview(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideWorkingSetPreview HideWorkingSetPreview; + + [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 bFadeIn); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FadeGrid FadeGrid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetCurrentGridAlpha(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentGridAlpha GetCurrentGridAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SetSkyboxOverride([In, Out] Texture_t[] pTextures, uint unTextureCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetSkyboxOverride SetSkyboxOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ClearSkyboxOverride(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearSkyboxOverride ClearSkyboxOverride; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorBringToFront(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorBringToFront CompositorBringToFront; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorGoToBack(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorGoToBack CompositorGoToBack; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorQuit(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorQuit CompositorQuit; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsFullscreen(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsFullscreen IsFullscreen; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetCurrentSceneFocusProcess(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetCurrentSceneFocusProcess GetCurrentSceneFocusProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetLastFrameRenderer(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetLastFrameRenderer GetLastFrameRenderer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _CanRenderScene(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CanRenderScene CanRenderScene; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowMirrorWindow(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMirrorWindow ShowMirrorWindow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideMirrorWindow(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideMirrorWindow HideMirrorWindow; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMirrorWindowVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMirrorWindowVisible IsMirrorWindowVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CompositorDumpImages(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CompositorDumpImages CompositorDumpImages; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ShouldAppRenderWithLowResources(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShouldAppRenderWithLowResources ShouldAppRenderWithLowResources; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceInterleavedReprojectionOn(bool bOverride); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceInterleavedReprojectionOn ForceInterleavedReprojectionOn; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ForceReconnectProcess(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ForceReconnectProcess ForceReconnectProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SuspendRendering(bool bSuspend); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SuspendRendering SuspendRendering; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetMirrorTextureD3D11(EVREye eEye, IntPtr pD3D11DeviceOrResource, ref IntPtr ppD3D11ShaderResourceView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMirrorTextureD3D11 GetMirrorTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseMirrorTextureD3D11 ReleaseMirrorTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _GetMirrorTextureGL(EVREye eEye, ref uint pglTextureId, IntPtr pglSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetMirrorTextureGL GetMirrorTextureGL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ReleaseSharedGLTexture(uint glTextureId, IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseSharedGLTexture ReleaseSharedGLTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LockGLSharedTextureForAccess LockGLSharedTextureForAccess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UnlockGLSharedTextureForAccess UnlockGLSharedTextureForAccess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanInstanceExtensionsRequired GetVulkanInstanceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetVulkanDeviceExtensionsRequired GetVulkanDeviceExtensionsRequired; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetExplicitTimingMode SetExplicitTimingMode; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRCompositorError _SubmitExplicitTimingData(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SubmitExplicitTimingData SubmitExplicitTimingData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsMotionSmoothingEnabled(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsMotionSmoothingEnabled IsMotionSmoothingEnabled; + + [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; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVROverlay +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _FindOverlay(string pchOverlayKey, ref ulong pOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FindOverlay FindOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _CreateOverlay(string pchOverlayKey, string pchOverlayName, ref ulong pOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateOverlay CreateOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _DestroyOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DestroyOverlay DestroyOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetHighQualityOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetHighQualityOverlay SetHighQualityOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetHighQualityOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetHighQualityOverlay GetHighQualityOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayKey(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayKey GetOverlayKey; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayName(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayName GetOverlayName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayName(ulong ulOverlayHandle, string pchName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayName SetOverlayName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayImageData(ulong ulOverlayHandle, IntPtr pvBuffer, uint unBufferSize, ref uint punWidth, ref uint punHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayImageData GetOverlayImageData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetOverlayErrorNameFromEnum(EVROverlayError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayErrorNameFromEnum GetOverlayErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRenderingPid(ulong ulOverlayHandle, uint unPID); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRenderingPid SetOverlayRenderingPid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayRenderingPid(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayRenderingPid GetOverlayRenderingPid; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayFlag SetOverlayFlag; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlag(ulong ulOverlayHandle, VROverlayFlags eOverlayFlag, ref bool pbEnabled); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlag GetOverlayFlag; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayColor(ulong ulOverlayHandle, float fRed, float fGreen, float fBlue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayColor SetOverlayColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayColor(ulong ulOverlayHandle, ref float pfRed, ref float pfGreen, ref float pfBlue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayColor GetOverlayColor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayAlpha(ulong ulOverlayHandle, float fAlpha); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayAlpha SetOverlayAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayAlpha(ulong ulOverlayHandle, ref float pfAlpha); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayAlpha GetOverlayAlpha; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTexelAspect(ulong ulOverlayHandle, float fTexelAspect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTexelAspect SetOverlayTexelAspect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTexelAspect(ulong ulOverlayHandle, ref float pfTexelAspect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTexelAspect GetOverlayTexelAspect; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlaySortOrder(ulong ulOverlayHandle, uint unSortOrder); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlaySortOrder SetOverlaySortOrder; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlaySortOrder(ulong ulOverlayHandle, ref uint punSortOrder); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlaySortOrder GetOverlaySortOrder; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayWidthInMeters(ulong ulOverlayHandle, float fWidthInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayWidthInMeters SetOverlayWidthInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayWidthInMeters(ulong ulOverlayHandle, ref float pfWidthInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayWidthInMeters GetOverlayWidthInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayAutoCurveDistanceRangeInMeters SetOverlayAutoCurveDistanceRangeInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle, ref float pfMinDistanceInMeters, ref float pfMaxDistanceInMeters); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayAutoCurveDistanceRangeInMeters GetOverlayAutoCurveDistanceRangeInMeters; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTextureColorSpace(ulong ulOverlayHandle, EColorSpace eTextureColorSpace); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTextureColorSpace SetOverlayTextureColorSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureColorSpace(ulong ulOverlayHandle, ref EColorSpace peTextureColorSpace); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureColorSpace GetOverlayTextureColorSpace; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTextureBounds SetOverlayTextureBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureBounds(ulong ulOverlayHandle, ref VRTextureBounds_t pOverlayTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureBounds GetOverlayTextureBounds; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetOverlayRenderModel(ulong ulOverlayHandle, System.Text.StringBuilder pchValue, uint unBufferSize, ref HmdColor_t pColor, ref EVROverlayError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayRenderModel GetOverlayRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRenderModel(ulong ulOverlayHandle, string pchRenderModel, ref HmdColor_t pColor); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRenderModel SetOverlayRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformType(ulong ulOverlayHandle, ref VROverlayTransformType peTransformType); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformType GetOverlayTransformType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformAbsolute(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformAbsolute SetOverlayTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformAbsolute(ulong ulOverlayHandle, ref ETrackingUniverseOrigin peTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformAbsolute GetOverlayTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, uint unTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformTrackedDeviceRelative SetOverlayTransformTrackedDeviceRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle, ref uint punTrackedDevice, ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformTrackedDeviceRelative GetOverlayTransformTrackedDeviceRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, uint unDeviceIndex, string pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformTrackedDeviceComponent SetOverlayTransformTrackedDeviceComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle, ref uint punDeviceIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformTrackedDeviceComponent GetOverlayTransformTrackedDeviceComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ref ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTransformOverlayRelative GetOverlayTransformOverlayRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTransformOverlayRelative(ulong ulOverlayHandle, ulong ulOverlayHandleParent, ref HmdMatrix34_t pmatParentOverlayToOverlayTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTransformOverlayRelative SetOverlayTransformOverlayRelative; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowOverlay ShowOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _HideOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideOverlay HideOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsOverlayVisible(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsOverlayVisible IsOverlayVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetTransformForOverlayCoordinates(ulong ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, ref HmdMatrix34_t pmatTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetTransformForOverlayCoordinates GetTransformForOverlayCoordinates; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextOverlayEvent(ulong ulOverlayHandle, ref VREvent_t pEvent, uint uncbVREvent); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PollNextOverlayEvent PollNextOverlayEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayInputMethod(ulong ulOverlayHandle, ref VROverlayInputMethod peInputMethod); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayInputMethod GetOverlayInputMethod; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayInputMethod(ulong ulOverlayHandle, VROverlayInputMethod eInputMethod); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayInputMethod SetOverlayInputMethod; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayMouseScale GetOverlayMouseScale; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayMouseScale(ulong ulOverlayHandle, ref HmdVector2_t pvecMouseScale); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayMouseScale SetOverlayMouseScale; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _ComputeOverlayIntersection(ulong ulOverlayHandle, ref VROverlayIntersectionParams_t pParams, ref VROverlayIntersectionResults_t pResults); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ComputeOverlayIntersection ComputeOverlayIntersection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsHoverTargetOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsHoverTargetOverlay IsHoverTargetOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetGamepadFocusOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetGamepadFocusOverlay GetGamepadFocusOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetGamepadFocusOverlay(ulong ulNewFocusOverlay); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetGamepadFocusOverlay SetGamepadFocusOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayNeighbor(EOverlayDirection eDirection, ulong ulFrom, ulong ulTo); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayNeighbor SetOverlayNeighbor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _MoveGamepadFocusToNeighbor(EOverlayDirection eDirection, ulong ulFrom); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _MoveGamepadFocusToNeighbor MoveGamepadFocusToNeighbor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayDualAnalogTransform(ulong ulOverlay, EDualAnalogWhich eWhich, ref HmdVector2_t pvCenter, float fRadius); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayDualAnalogTransform SetOverlayDualAnalogTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayDualAnalogTransform(ulong ulOverlay, EDualAnalogWhich eWhich, ref HmdVector2_t pvCenter, ref float pfRadius); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayDualAnalogTransform GetOverlayDualAnalogTransform; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayTexture(ulong ulOverlayHandle, ref Texture_t pTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayTexture SetOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ClearOverlayTexture(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ClearOverlayTexture ClearOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayRaw(ulong ulOverlayHandle, IntPtr pvBuffer, uint unWidth, uint unHeight, uint unDepth); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayRaw SetOverlayRaw; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayFromFile(ulong ulOverlayHandle, string pchFilePath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayFromFile SetOverlayFromFile; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTexture(ulong ulOverlayHandle, ref IntPtr pNativeTextureHandle, IntPtr pNativeTextureRef, ref uint pWidth, ref uint pHeight, ref uint pNativeFormat, ref ETextureType pAPIType, ref EColorSpace pColorSpace, ref VRTextureBounds_t pTextureBounds); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTexture GetOverlayTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ReleaseNativeOverlayHandle(ulong ulOverlayHandle, IntPtr pNativeTextureHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ReleaseNativeOverlayHandle ReleaseNativeOverlayHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayTextureSize(ulong ulOverlayHandle, ref uint pWidth, ref uint pHeight); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayTextureSize GetOverlayTextureSize; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _CreateDashboardOverlay(string pchOverlayKey, string pchOverlayFriendlyName, ref ulong pMainHandle, ref ulong pThumbnailHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateDashboardOverlay CreateDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsDashboardVisible(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsDashboardVisible IsDashboardVisible; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _IsActiveDashboardOverlay(ulong ulOverlayHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsActiveDashboardOverlay IsActiveDashboardOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetDashboardOverlaySceneProcess(ulong ulOverlayHandle, uint unProcessId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetDashboardOverlaySceneProcess SetDashboardOverlaySceneProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetDashboardOverlaySceneProcess(ulong ulOverlayHandle, ref uint punProcessId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDashboardOverlaySceneProcess GetDashboardOverlaySceneProcess; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _ShowDashboard(string pchOverlayToShow); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowDashboard ShowDashboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetPrimaryDashboardDevice(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetPrimaryDashboardDevice GetPrimaryDashboardDevice; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowKeyboard(int eInputMode, int eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText, bool bUseMinimalMode, ulong uUserValue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowKeyboard ShowKeyboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _ShowKeyboardForOverlay(ulong ulOverlayHandle, int eInputMode, int eLineInputMode, string pchDescription, uint unCharMax, string pchExistingText, bool bUseMinimalMode, ulong uUserValue); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowKeyboardForOverlay ShowKeyboardForOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetKeyboardText(System.Text.StringBuilder pchText, uint cchText); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetKeyboardText GetKeyboardText; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _HideKeyboard(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HideKeyboard HideKeyboard; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin, ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetKeyboardTransformAbsolute SetKeyboardTransformAbsolute; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetKeyboardPositionForOverlay(ulong ulOverlayHandle, HmdRect2_t avoidRect); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetKeyboardPositionForOverlay SetKeyboardPositionForOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _SetOverlayIntersectionMask(ulong ulOverlayHandle, ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives, uint unNumMaskPrimitives, uint unPrimitiveSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetOverlayIntersectionMask SetOverlayIntersectionMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVROverlayError _GetOverlayFlags(ulong ulOverlayHandle, ref uint pFlags); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetOverlayFlags GetOverlayFlags; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate VRMessageOverlayResponse _ShowMessageOverlay(string pchText, string pchCaption, string pchButton0Text, string pchButton1Text, string pchButton2Text, string pchButton3Text); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _ShowMessageOverlay ShowMessageOverlay; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _CloseMessageOverlay(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CloseMessageOverlay CloseMessageOverlay; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRRenderModels +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadRenderModel_Async(string pchRenderModelName, ref IntPtr ppRenderModel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadRenderModel_Async LoadRenderModel_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeRenderModel(IntPtr pRenderModel); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeRenderModel FreeRenderModel; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadTexture_Async(int textureId, ref IntPtr ppTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadTexture_Async LoadTexture_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeTexture(IntPtr pTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeTexture FreeTexture; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadTextureD3D11_Async(int textureId, IntPtr pD3D11Device, ref IntPtr ppD3D11Texture2D); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadTextureD3D11_Async LoadTextureD3D11_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRRenderModelError _LoadIntoTextureD3D11_Async(int textureId, IntPtr pDstTexture); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadIntoTextureD3D11_Async LoadIntoTextureD3D11_Async; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _FreeTextureD3D11(IntPtr pD3D11Texture2D); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FreeTextureD3D11 FreeTextureD3D11; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelName(uint unRenderModelIndex, System.Text.StringBuilder pchRenderModelName, uint unRenderModelNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelName GetRenderModelName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelCount GetRenderModelCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentCount(string pchRenderModelName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentCount GetComponentCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentName(string pchRenderModelName, uint unComponentIndex, System.Text.StringBuilder pchComponentName, uint unComponentNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentName GetComponentName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetComponentButtonMask(string pchRenderModelName, string pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentButtonMask GetComponentButtonMask; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetComponentRenderModelName(string pchRenderModelName, string pchComponentName, System.Text.StringBuilder pchComponentRenderModelName, uint unComponentRenderModelNameLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentRenderModelName GetComponentRenderModelName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentStateForDevicePath(string pchRenderModelName, string pchComponentName, ulong devicePath, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentStateForDevicePath GetComponentStateForDevicePath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentState(string pchRenderModelName, string pchComponentName, ref VRControllerState_t pControllerState, ref RenderModel_ControllerMode_State_t pState, ref RenderModel_ComponentState_t pComponentState); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetComponentState GetComponentState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _RenderModelHasComponent(string pchRenderModelName, string pchComponentName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RenderModelHasComponent RenderModelHasComponent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelThumbnailURL(string pchRenderModelName, System.Text.StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelThumbnailURL GetRenderModelThumbnailURL; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetRenderModelOriginalPath(string pchRenderModelName, System.Text.StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelOriginalPath GetRenderModelOriginalPath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetRenderModelErrorNameFromEnum(EVRRenderModelError error); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetRenderModelErrorNameFromEnum GetRenderModelErrorNameFromEnum; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRNotifications +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRNotificationError _CreateNotification(ulong ulOverlayHandle, ulong ulUserValue, EVRNotificationType type, string pchText, EVRNotificationStyle style, ref NotificationBitmap_t pImage, ref uint pNotificationId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateNotification CreateNotification; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRNotificationError _RemoveNotification(uint notificationId); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveNotification RemoveNotification; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRSettings +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate IntPtr _GetSettingsErrorNameFromEnum(EVRSettingsError eError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSettingsErrorNameFromEnum GetSettingsErrorNameFromEnum; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _Sync(bool bForce, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Sync Sync; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetBool(string pchSection, string pchSettingsKey, bool bValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetBool SetBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetInt32(string pchSection, string pchSettingsKey, int nValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetInt32 SetInt32; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetFloat(string pchSection, string pchSettingsKey, float flValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetFloat SetFloat; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _SetString(string pchSection, string pchSettingsKey, string pchValue, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetString SetString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetBool(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetBool GetBool; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate int _GetInt32(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInt32 GetInt32; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate float _GetFloat(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetFloat GetFloat; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _GetString(string pchSection, string pchSettingsKey, System.Text.StringBuilder pchValue, uint unValueLen, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetString GetString; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RemoveSection(string pchSection, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveSection RemoveSection; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate void _RemoveKeyInSection(string pchSection, string pchSettingsKey, ref EVRSettingsError peError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RemoveKeyInSection RemoveKeyInSection; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRScreenshots +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _RequestScreenshot(ref uint pOutScreenshotHandle, EVRScreenshotType type, string pchPreviewFilename, string pchVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _RequestScreenshot RequestScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _HookScreenshot([In, Out] EVRScreenshotType[] pSupportedTypes, int numTypes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HookScreenshot HookScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotType _GetScreenshotPropertyType(uint screenshotHandle, ref EVRScreenshotError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetScreenshotPropertyType GetScreenshotPropertyType; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetScreenshotPropertyFilename(uint screenshotHandle, EVRScreenshotPropertyFilenames filenameType, System.Text.StringBuilder pchFilename, uint cchFilename, ref EVRScreenshotError pError); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetScreenshotPropertyFilename GetScreenshotPropertyFilename; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _UpdateScreenshotProgress(uint screenshotHandle, float flProgress); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UpdateScreenshotProgress UpdateScreenshotProgress; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _TakeStereoScreenshot(ref uint pOutScreenshotHandle, string pchPreviewFilename, string pchVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _TakeStereoScreenshot TakeStereoScreenshot; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRScreenshotError _SubmitScreenshot(uint screenshotHandle, EVRScreenshotType type, string pchSourcePreviewFilename, string pchSourceVRFilename); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SubmitScreenshot SubmitScreenshot; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRResources +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _LoadSharedResource(string pchResourceName, string pchBuffer, uint unBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _LoadSharedResource LoadSharedResource; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetResourceFullPath(string pchResourceName, string pchResourceTypeDirectory, System.Text.StringBuilder pchPathBuffer, uint unBufferLen); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetResourceFullPath GetResourceFullPath; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRDriverManager +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetDriverCount(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverCount GetDriverCount; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _GetDriverName(uint nDriver, System.Text.StringBuilder pchValue, uint unBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverName GetDriverName; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _GetDriverHandle(string pchDriverName); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDriverHandle GetDriverHandle; + + [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(string pchActionManifestPath); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _SetActionManifestPath SetActionManifestPath; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionSetHandle(string pchActionSetName, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionSetHandle GetActionSetHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetActionHandle(string pchActionName, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetActionHandle GetActionHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetInputSourceHandle(string pchInputSourcePath, ref ulong pHandle); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetInputSourceHandle GetInputSourceHandle; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _UpdateActionState([In, Out] VRActiveActionSet_t[] pSets, uint unSizeOfVRSelectedActionSet_t, uint unSetCount); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _UpdateActionState UpdateActionState; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetDigitalActionData(ulong action, ref InputDigitalActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetDigitalActionData GetDigitalActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _GetAnalogActionData(ulong action, ref InputAnalogActionData_t pActionData, uint unActionDataSize, ulong ulRestrictToDevice); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetAnalogActionData GetAnalogActionData; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRInputError _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 _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 bool _IsUsingLegacyInput(); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _IsUsingLegacyInput IsUsingLegacyInput; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRIOBuffer +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Open(string pchPath, EIOBufferMode mode, uint unElementSize, uint unElements, ref ulong pulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Open Open; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Close(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Close Close; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Read(ulong ulBuffer, IntPtr pDst, uint unBytes, ref uint punRead); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Read Read; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EIOBufferError _Write(ulong ulBuffer, IntPtr pSrc, uint unBytes); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _Write Write; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate ulong _PropertyContainer(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _PropertyContainer PropertyContainer; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _HasReaders(ulong ulBuffer); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _HasReaders HasReaders; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRSpatialAnchors +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromDescriptor(string pchDescriptor, ref uint pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateSpatialAnchorFromDescriptor CreateSpatialAnchorFromDescriptor; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _CreateSpatialAnchorFromPose(uint unDeviceIndex, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPose, ref uint pHandleOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _CreateSpatialAnchorFromPose CreateSpatialAnchorFromPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _GetSpatialAnchorPose(uint unHandle, ETrackingUniverseOrigin eOrigin, ref SpatialAnchorPose_t pPoseOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSpatialAnchorPose GetSpatialAnchorPose; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRSpatialAnchorError _GetSpatialAnchorDescriptor(uint unHandle, System.Text.StringBuilder pchDescriptorOut, ref uint punDescriptorBufferLenInOut); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _GetSpatialAnchorDescriptor GetSpatialAnchorDescriptor; + +} + +[StructLayout(LayoutKind.Sequential)] +public struct IVRDebug +{ + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate EVRDebugError _EmitVrProfilerEvent(string 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, string pchMessage); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _FinishVrProfilerEvent FinishVrProfilerEvent; + + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate uint _DriverDebugRequest(uint unDeviceIndex, string pchRequest, System.Text.StringBuilder pchResponseBuffer, uint unResponseBufferSize); + [MarshalAs(UnmanagedType.FunctionPtr)] + internal _DriverDebugRequest DriverDebugRequest; + +} + + +public class CVRSystem +{ + IVRSystem FnTable; + internal CVRSystem(IntPtr pInterface) + { + FnTable = (IVRSystem)Marshal.PtrToStructure(pInterface, typeof(IVRSystem)); + } + public void GetRecommendedRenderTargetSize(ref uint pnWidth,ref uint pnHeight) + { + pnWidth = 0; + pnHeight = 0; + FnTable.GetRecommendedRenderTargetSize(ref pnWidth,ref pnHeight); + } + public HmdMatrix44_t GetProjectionMatrix(EVREye eEye,float fNearZ,float fFarZ) + { + HmdMatrix44_t result = FnTable.GetProjectionMatrix(eEye,fNearZ,fFarZ); + return result; + } + public void GetProjectionRaw(EVREye eEye,ref float pfLeft,ref float pfRight,ref float pfTop,ref float pfBottom) + { + pfLeft = 0; + pfRight = 0; + pfTop = 0; + pfBottom = 0; + FnTable.GetProjectionRaw(eEye,ref pfLeft,ref pfRight,ref pfTop,ref pfBottom); + } + public bool ComputeDistortion(EVREye eEye,float fU,float fV,ref DistortionCoordinates_t pDistortionCoordinates) + { + bool result = FnTable.ComputeDistortion(eEye,fU,fV,ref pDistortionCoordinates); + return result; + } + public HmdMatrix34_t GetEyeToHeadTransform(EVREye eEye) + { + HmdMatrix34_t result = FnTable.GetEyeToHeadTransform(eEye); + return result; + } + public bool GetTimeSinceLastVsync(ref float pfSecondsSinceLastVsync,ref ulong pulFrameCounter) + { + pfSecondsSinceLastVsync = 0; + pulFrameCounter = 0; + bool result = FnTable.GetTimeSinceLastVsync(ref pfSecondsSinceLastVsync,ref pulFrameCounter); + return result; + } + public int GetD3D9AdapterIndex() + { + int result = FnTable.GetD3D9AdapterIndex(); + return result; + } + public void GetDXGIOutputInfo(ref int pnAdapterIndex) + { + pnAdapterIndex = 0; + FnTable.GetDXGIOutputInfo(ref pnAdapterIndex); + } + public void GetOutputDevice(ref ulong pnDevice,ETextureType textureType,IntPtr pInstance) + { + pnDevice = 0; + FnTable.GetOutputDevice(ref pnDevice,textureType,pInstance); + } + public bool IsDisplayOnDesktop() + { + bool result = FnTable.IsDisplayOnDesktop(); + return result; + } + public bool SetDisplayVisibility(bool bIsVisibleOnDesktop) + { + bool result = FnTable.SetDisplayVisibility(bIsVisibleOnDesktop); + return result; + } + public void GetDeviceToAbsoluteTrackingPose(ETrackingUniverseOrigin eOrigin,float fPredictedSecondsToPhotonsFromNow,TrackedDevicePose_t [] pTrackedDevicePoseArray) + { + FnTable.GetDeviceToAbsoluteTrackingPose(eOrigin,fPredictedSecondsToPhotonsFromNow,pTrackedDevicePoseArray,(uint) pTrackedDevicePoseArray.Length); + } + public void ResetSeatedZeroPose() + { + FnTable.ResetSeatedZeroPose(); + } + public HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() + { + HmdMatrix34_t result = FnTable.GetSeatedZeroPoseToStandingAbsoluteTrackingPose(); + return result; + } + public HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() + { + HmdMatrix34_t result = FnTable.GetRawZeroPoseToStandingAbsoluteTrackingPose(); + return result; + } + public uint GetSortedTrackedDeviceIndicesOfClass(ETrackedDeviceClass eTrackedDeviceClass,uint [] punTrackedDeviceIndexArray,uint unRelativeToTrackedDeviceIndex) + { + uint result = FnTable.GetSortedTrackedDeviceIndicesOfClass(eTrackedDeviceClass,punTrackedDeviceIndexArray,(uint) punTrackedDeviceIndexArray.Length,unRelativeToTrackedDeviceIndex); + return result; + } + public EDeviceActivityLevel GetTrackedDeviceActivityLevel(uint unDeviceId) + { + EDeviceActivityLevel result = FnTable.GetTrackedDeviceActivityLevel(unDeviceId); + return result; + } + public void ApplyTransform(ref TrackedDevicePose_t pOutputPose,ref TrackedDevicePose_t pTrackedDevicePose,ref HmdMatrix34_t pTransform) + { + FnTable.ApplyTransform(ref pOutputPose,ref pTrackedDevicePose,ref pTransform); + } + public uint GetTrackedDeviceIndexForControllerRole(ETrackedControllerRole unDeviceType) + { + uint result = FnTable.GetTrackedDeviceIndexForControllerRole(unDeviceType); + return result; + } + public ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex(uint unDeviceIndex) + { + ETrackedControllerRole result = FnTable.GetControllerRoleForTrackedDeviceIndex(unDeviceIndex); + return result; + } + public ETrackedDeviceClass GetTrackedDeviceClass(uint unDeviceIndex) + { + ETrackedDeviceClass result = FnTable.GetTrackedDeviceClass(unDeviceIndex); + return result; + } + public bool IsTrackedDeviceConnected(uint unDeviceIndex) + { + bool result = FnTable.IsTrackedDeviceConnected(unDeviceIndex); + return result; + } + public bool GetBoolTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + bool result = FnTable.GetBoolTrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public float GetFloatTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + float result = FnTable.GetFloatTrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public int GetInt32TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + int result = FnTable.GetInt32TrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public ulong GetUint64TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + ulong result = FnTable.GetUint64TrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public HmdMatrix34_t GetMatrix34TrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,ref ETrackedPropertyError pError) + { + HmdMatrix34_t result = FnTable.GetMatrix34TrackedDeviceProperty(unDeviceIndex,prop,ref pError); + return result; + } + public uint GetArrayTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,uint propType,IntPtr pBuffer,uint unBufferSize,ref ETrackedPropertyError pError) + { + uint result = FnTable.GetArrayTrackedDeviceProperty(unDeviceIndex,prop,propType,pBuffer,unBufferSize,ref pError); + return result; + } + public uint GetStringTrackedDeviceProperty(uint unDeviceIndex,ETrackedDeviceProperty prop,System.Text.StringBuilder pchValue,uint unBufferSize,ref ETrackedPropertyError pError) + { + uint result = FnTable.GetStringTrackedDeviceProperty(unDeviceIndex,prop,pchValue,unBufferSize,ref pError); + return result; + } + public string GetPropErrorNameFromEnum(ETrackedPropertyError error) + { + IntPtr result = FnTable.GetPropErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextEventPacked(ref VREvent_t_Packed pEvent,uint uncbVREvent); + [StructLayout(LayoutKind.Explicit)] + struct PollNextEventUnion + { + [FieldOffset(0)] + public IVRSystem._PollNextEvent pPollNextEvent; + [FieldOffset(0)] + public _PollNextEventPacked pPollNextEventPacked; + } + public bool PollNextEvent(ref VREvent_t pEvent,uint uncbVREvent) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + PollNextEventUnion u; + VREvent_t_Packed event_packed = new VREvent_t_Packed(); + u.pPollNextEventPacked = null; + u.pPollNextEvent = FnTable.PollNextEvent; + bool packed_result = u.pPollNextEventPacked(ref event_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed))); + + event_packed.Unpack(ref pEvent); + return packed_result; + } +#endif + bool result = FnTable.PollNextEvent(ref pEvent,uncbVREvent); + return result; + } + public bool PollNextEventWithPose(ETrackingUniverseOrigin eOrigin,ref VREvent_t pEvent,uint uncbVREvent,ref TrackedDevicePose_t pTrackedDevicePose) + { + bool result = FnTable.PollNextEventWithPose(eOrigin,ref pEvent,uncbVREvent,ref pTrackedDevicePose); + return result; + } + public string GetEventTypeNameFromEnum(EVREventType eType) + { + IntPtr result = FnTable.GetEventTypeNameFromEnum(eType); + return Marshal.PtrToStringAnsi(result); + } + public HiddenAreaMesh_t GetHiddenAreaMesh(EVREye eEye,EHiddenAreaMeshType type) + { + HiddenAreaMesh_t result = FnTable.GetHiddenAreaMesh(eEye,type); + return result; + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStatePacked(uint unControllerDeviceIndex,ref VRControllerState_t_Packed pControllerState,uint unControllerStateSize); + [StructLayout(LayoutKind.Explicit)] + struct GetControllerStateUnion + { + [FieldOffset(0)] + public IVRSystem._GetControllerState pGetControllerState; + [FieldOffset(0)] + public _GetControllerStatePacked pGetControllerStatePacked; + } + public bool GetControllerState(uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,uint unControllerStateSize) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetControllerStateUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetControllerStatePacked = null; + u.pGetControllerState = FnTable.GetControllerState; + bool packed_result = u.pGetControllerStatePacked(unControllerDeviceIndex,ref state_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed))); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetControllerState(unControllerDeviceIndex,ref pControllerState,unControllerStateSize); + return result; + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetControllerStateWithPosePacked(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t_Packed pControllerState,uint unControllerStateSize,ref TrackedDevicePose_t pTrackedDevicePose); + [StructLayout(LayoutKind.Explicit)] + struct GetControllerStateWithPoseUnion + { + [FieldOffset(0)] + public IVRSystem._GetControllerStateWithPose pGetControllerStateWithPose; + [FieldOffset(0)] + public _GetControllerStateWithPosePacked pGetControllerStateWithPosePacked; + } + public bool GetControllerStateWithPose(ETrackingUniverseOrigin eOrigin,uint unControllerDeviceIndex,ref VRControllerState_t pControllerState,uint unControllerStateSize,ref TrackedDevicePose_t pTrackedDevicePose) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetControllerStateWithPoseUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetControllerStateWithPosePacked = null; + u.pGetControllerStateWithPose = FnTable.GetControllerStateWithPose; + bool packed_result = u.pGetControllerStateWithPosePacked(eOrigin,unControllerDeviceIndex,ref state_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VRControllerState_t_Packed)),ref pTrackedDevicePose); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetControllerStateWithPose(eOrigin,unControllerDeviceIndex,ref pControllerState,unControllerStateSize,ref pTrackedDevicePose); + return result; + } + public void TriggerHapticPulse(uint unControllerDeviceIndex,uint unAxisId,ushort usDurationMicroSec) + { + FnTable.TriggerHapticPulse(unControllerDeviceIndex,unAxisId,usDurationMicroSec); + } + public string GetButtonIdNameFromEnum(EVRButtonId eButtonId) + { + IntPtr result = FnTable.GetButtonIdNameFromEnum(eButtonId); + return Marshal.PtrToStringAnsi(result); + } + public string GetControllerAxisTypeNameFromEnum(EVRControllerAxisType eAxisType) + { + IntPtr result = FnTable.GetControllerAxisTypeNameFromEnum(eAxisType); + return Marshal.PtrToStringAnsi(result); + } + public bool IsInputAvailable() + { + bool result = FnTable.IsInputAvailable(); + return result; + } + public bool IsSteamVRDrawingControllers() + { + bool result = FnTable.IsSteamVRDrawingControllers(); + return result; + } + public bool ShouldApplicationPause() + { + bool result = FnTable.ShouldApplicationPause(); + return result; + } + public bool ShouldApplicationReduceRenderingWork() + { + bool result = FnTable.ShouldApplicationReduceRenderingWork(); + return result; + } + public EVRFirmwareError PerformFirmwareUpdate(uint unDeviceIndex) + { + EVRFirmwareError result = FnTable.PerformFirmwareUpdate(unDeviceIndex); + return result; + } + public void AcknowledgeQuit_Exiting() + { + FnTable.AcknowledgeQuit_Exiting(); + } + public void AcknowledgeQuit_UserPrompt() + { + FnTable.AcknowledgeQuit_UserPrompt(); + } + public 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 class CVRApplications +{ + IVRApplications FnTable; + internal CVRApplications(IntPtr pInterface) + { + FnTable = (IVRApplications)Marshal.PtrToStructure(pInterface, typeof(IVRApplications)); + } + public EVRApplicationError AddApplicationManifest(string pchApplicationManifestFullPath,bool bTemporary) + { + EVRApplicationError result = FnTable.AddApplicationManifest(pchApplicationManifestFullPath,bTemporary); + return result; + } + public EVRApplicationError RemoveApplicationManifest(string pchApplicationManifestFullPath) + { + EVRApplicationError result = FnTable.RemoveApplicationManifest(pchApplicationManifestFullPath); + return result; + } + public bool IsApplicationInstalled(string pchAppKey) + { + bool result = FnTable.IsApplicationInstalled(pchAppKey); + return result; + } + public uint GetApplicationCount() + { + uint result = FnTable.GetApplicationCount(); + return result; + } + public EVRApplicationError GetApplicationKeyByIndex(uint unApplicationIndex,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetApplicationKeyByIndex(unApplicationIndex,pchAppKeyBuffer,unAppKeyBufferLen); + return result; + } + public EVRApplicationError GetApplicationKeyByProcessId(uint unProcessId,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetApplicationKeyByProcessId(unProcessId,pchAppKeyBuffer,unAppKeyBufferLen); + return result; + } + public EVRApplicationError LaunchApplication(string pchAppKey) + { + EVRApplicationError result = FnTable.LaunchApplication(pchAppKey); + return result; + } + public EVRApplicationError LaunchTemplateApplication(string pchTemplateAppKey,string pchNewAppKey,AppOverrideKeys_t [] pKeys) + { + EVRApplicationError result = FnTable.LaunchTemplateApplication(pchTemplateAppKey,pchNewAppKey,pKeys,(uint) pKeys.Length); + return result; + } + public EVRApplicationError LaunchApplicationFromMimeType(string pchMimeType,string pchArgs) + { + EVRApplicationError result = FnTable.LaunchApplicationFromMimeType(pchMimeType,pchArgs); + return result; + } + public EVRApplicationError LaunchDashboardOverlay(string pchAppKey) + { + EVRApplicationError result = FnTable.LaunchDashboardOverlay(pchAppKey); + return result; + } + public bool CancelApplicationLaunch(string pchAppKey) + { + bool result = FnTable.CancelApplicationLaunch(pchAppKey); + return result; + } + public EVRApplicationError IdentifyApplication(uint unProcessId,string pchAppKey) + { + EVRApplicationError result = FnTable.IdentifyApplication(unProcessId,pchAppKey); + return result; + } + public uint GetApplicationProcessId(string pchAppKey) + { + uint result = FnTable.GetApplicationProcessId(pchAppKey); + return result; + } + public string GetApplicationsErrorNameFromEnum(EVRApplicationError error) + { + IntPtr result = FnTable.GetApplicationsErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public uint GetApplicationPropertyString(string pchAppKey,EVRApplicationProperty eProperty,System.Text.StringBuilder pchPropertyValueBuffer,uint unPropertyValueBufferLen,ref EVRApplicationError peError) + { + uint result = FnTable.GetApplicationPropertyString(pchAppKey,eProperty,pchPropertyValueBuffer,unPropertyValueBufferLen,ref peError); + return result; + } + public bool GetApplicationPropertyBool(string pchAppKey,EVRApplicationProperty eProperty,ref EVRApplicationError peError) + { + bool result = FnTable.GetApplicationPropertyBool(pchAppKey,eProperty,ref peError); + return result; + } + public ulong GetApplicationPropertyUint64(string pchAppKey,EVRApplicationProperty eProperty,ref EVRApplicationError peError) + { + ulong result = FnTable.GetApplicationPropertyUint64(pchAppKey,eProperty,ref peError); + return result; + } + public EVRApplicationError SetApplicationAutoLaunch(string pchAppKey,bool bAutoLaunch) + { + EVRApplicationError result = FnTable.SetApplicationAutoLaunch(pchAppKey,bAutoLaunch); + return result; + } + public bool GetApplicationAutoLaunch(string pchAppKey) + { + bool result = FnTable.GetApplicationAutoLaunch(pchAppKey); + return result; + } + public EVRApplicationError SetDefaultApplicationForMimeType(string pchAppKey,string pchMimeType) + { + EVRApplicationError result = FnTable.SetDefaultApplicationForMimeType(pchAppKey,pchMimeType); + return result; + } + public bool GetDefaultApplicationForMimeType(string pchMimeType,System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen) + { + bool result = FnTable.GetDefaultApplicationForMimeType(pchMimeType,pchAppKeyBuffer,unAppKeyBufferLen); + return result; + } + public bool GetApplicationSupportedMimeTypes(string pchAppKey,System.Text.StringBuilder pchMimeTypesBuffer,uint unMimeTypesBuffer) + { + bool result = FnTable.GetApplicationSupportedMimeTypes(pchAppKey,pchMimeTypesBuffer,unMimeTypesBuffer); + return result; + } + public uint GetApplicationsThatSupportMimeType(string pchMimeType,System.Text.StringBuilder pchAppKeysThatSupportBuffer,uint unAppKeysThatSupportBuffer) + { + uint result = FnTable.GetApplicationsThatSupportMimeType(pchMimeType,pchAppKeysThatSupportBuffer,unAppKeysThatSupportBuffer); + return result; + } + public uint GetApplicationLaunchArguments(uint unHandle,System.Text.StringBuilder pchArgs,uint unArgs) + { + uint result = FnTable.GetApplicationLaunchArguments(unHandle,pchArgs,unArgs); + return result; + } + public EVRApplicationError GetStartingApplication(System.Text.StringBuilder pchAppKeyBuffer,uint unAppKeyBufferLen) + { + EVRApplicationError result = FnTable.GetStartingApplication(pchAppKeyBuffer,unAppKeyBufferLen); + return result; + } + public EVRApplicationTransitionState GetTransitionState() + { + EVRApplicationTransitionState result = FnTable.GetTransitionState(); + return result; + } + public EVRApplicationError PerformApplicationPrelaunchCheck(string pchAppKey) + { + EVRApplicationError result = FnTable.PerformApplicationPrelaunchCheck(pchAppKey); + return result; + } + public string GetApplicationsTransitionStateNameFromEnum(EVRApplicationTransitionState state) + { + IntPtr result = FnTable.GetApplicationsTransitionStateNameFromEnum(state); + return Marshal.PtrToStringAnsi(result); + } + public bool IsQuitUserPromptRequested() + { + bool result = FnTable.IsQuitUserPromptRequested(); + return result; + } + public EVRApplicationError LaunchInternalProcess(string pchBinaryPath,string pchArguments,string pchWorkingDirectory) + { + EVRApplicationError result = FnTable.LaunchInternalProcess(pchBinaryPath,pchArguments,pchWorkingDirectory); + return result; + } + public uint GetCurrentSceneProcessId() + { + uint result = FnTable.GetCurrentSceneProcessId(); + return result; + } +} + + +public class CVRChaperone +{ + IVRChaperone FnTable; + internal CVRChaperone(IntPtr pInterface) + { + FnTable = (IVRChaperone)Marshal.PtrToStructure(pInterface, typeof(IVRChaperone)); + } + public ChaperoneCalibrationState GetCalibrationState() + { + ChaperoneCalibrationState result = FnTable.GetCalibrationState(); + return result; + } + public bool GetPlayAreaSize(ref float pSizeX,ref float pSizeZ) + { + pSizeX = 0; + pSizeZ = 0; + bool result = FnTable.GetPlayAreaSize(ref pSizeX,ref pSizeZ); + return result; + } + public bool GetPlayAreaRect(ref HmdQuad_t rect) + { + bool result = FnTable.GetPlayAreaRect(ref rect); + return result; + } + public void ReloadInfo() + { + FnTable.ReloadInfo(); + } + public void SetSceneColor(HmdColor_t color) + { + FnTable.SetSceneColor(color); + } + public void GetBoundsColor(ref HmdColor_t pOutputColorArray,int nNumOutputColors,float flCollisionBoundsFadeDistance,ref HmdColor_t pOutputCameraColor) + { + FnTable.GetBoundsColor(ref pOutputColorArray,nNumOutputColors,flCollisionBoundsFadeDistance,ref pOutputCameraColor); + } + public bool AreBoundsVisible() + { + bool result = FnTable.AreBoundsVisible(); + return result; + } + public void ForceBoundsVisible(bool bForce) + { + FnTable.ForceBoundsVisible(bForce); + } +} + + +public class CVRChaperoneSetup +{ + IVRChaperoneSetup FnTable; + internal CVRChaperoneSetup(IntPtr pInterface) + { + FnTable = (IVRChaperoneSetup)Marshal.PtrToStructure(pInterface, typeof(IVRChaperoneSetup)); + } + public bool CommitWorkingCopy(EChaperoneConfigFile configFile) + { + bool result = FnTable.CommitWorkingCopy(configFile); + return result; + } + public void RevertWorkingCopy() + { + FnTable.RevertWorkingCopy(); + } + public bool GetWorkingPlayAreaSize(ref float pSizeX,ref float pSizeZ) + { + pSizeX = 0; + pSizeZ = 0; + bool result = FnTable.GetWorkingPlayAreaSize(ref pSizeX,ref pSizeZ); + return result; + } + public bool GetWorkingPlayAreaRect(ref HmdQuad_t rect) + { + bool result = FnTable.GetWorkingPlayAreaRect(ref rect); + return result; + } + public bool GetWorkingCollisionBoundsInfo(out HmdQuad_t [] pQuadsBuffer) + { + uint punQuadsCount = 0; + bool result = FnTable.GetWorkingCollisionBoundsInfo(null,ref punQuadsCount); + pQuadsBuffer= new HmdQuad_t[punQuadsCount]; + result = FnTable.GetWorkingCollisionBoundsInfo(pQuadsBuffer,ref punQuadsCount); + return result; + } + public bool GetLiveCollisionBoundsInfo(out HmdQuad_t [] pQuadsBuffer) + { + uint punQuadsCount = 0; + bool result = FnTable.GetLiveCollisionBoundsInfo(null,ref punQuadsCount); + pQuadsBuffer= new HmdQuad_t[punQuadsCount]; + result = FnTable.GetLiveCollisionBoundsInfo(pQuadsBuffer,ref punQuadsCount); + return result; + } + public bool GetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetWorkingSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); + return result; + } + public bool GetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatStandingZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetWorkingStandingZeroPoseToRawTrackingPose(ref pmatStandingZeroPoseToRawTrackingPose); + return result; + } + public void SetWorkingPlayAreaSize(float sizeX,float sizeZ) + { + FnTable.SetWorkingPlayAreaSize(sizeX,sizeZ); + } + public void SetWorkingCollisionBoundsInfo(HmdQuad_t [] pQuadsBuffer) + { + FnTable.SetWorkingCollisionBoundsInfo(pQuadsBuffer,(uint) pQuadsBuffer.Length); + } + public void SetWorkingPerimeter(HmdVector2_t [] pPointBuffer) + { + FnTable.SetWorkingPerimeter(pPointBuffer,(uint) pPointBuffer.Length); + } + public void SetWorkingSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatSeatedZeroPoseToRawTrackingPose) + { + FnTable.SetWorkingSeatedZeroPoseToRawTrackingPose(ref pMatSeatedZeroPoseToRawTrackingPose); + } + public void SetWorkingStandingZeroPoseToRawTrackingPose(ref HmdMatrix34_t pMatStandingZeroPoseToRawTrackingPose) + { + FnTable.SetWorkingStandingZeroPoseToRawTrackingPose(ref pMatStandingZeroPoseToRawTrackingPose); + } + public void ReloadFromDisk(EChaperoneConfigFile configFile) + { + FnTable.ReloadFromDisk(configFile); + } + public bool GetLiveSeatedZeroPoseToRawTrackingPose(ref HmdMatrix34_t pmatSeatedZeroPoseToRawTrackingPose) + { + bool result = FnTable.GetLiveSeatedZeroPoseToRawTrackingPose(ref pmatSeatedZeroPoseToRawTrackingPose); + return result; + } + public bool ExportLiveToBuffer(System.Text.StringBuilder pBuffer,ref uint pnBufferLength) + { + pnBufferLength = 0; + bool result = FnTable.ExportLiveToBuffer(pBuffer,ref pnBufferLength); + return result; + } + public bool ImportFromBufferToWorking(string pBuffer,uint nImportFlags) + { + bool result = FnTable.ImportFromBufferToWorking(pBuffer,nImportFlags); + return result; + } + public void ShowWorkingSetPreview() + { + FnTable.ShowWorkingSetPreview(); + } + public void HideWorkingSetPreview() + { + FnTable.HideWorkingSetPreview(); + } + public 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 bFadeIn) + { + FnTable.FadeGrid(fSeconds,bFadeIn); + } + public float GetCurrentGridAlpha() + { + float result = FnTable.GetCurrentGridAlpha(); + return result; + } + public EVRCompositorError SetSkyboxOverride(Texture_t [] pTextures) + { + EVRCompositorError result = FnTable.SetSkyboxOverride(pTextures,(uint) pTextures.Length); + return result; + } + public void ClearSkyboxOverride() + { + FnTable.ClearSkyboxOverride(); + } + public void CompositorBringToFront() + { + FnTable.CompositorBringToFront(); + } + public void CompositorGoToBack() + { + FnTable.CompositorGoToBack(); + } + public void CompositorQuit() + { + FnTable.CompositorQuit(); + } + public bool IsFullscreen() + { + bool result = FnTable.IsFullscreen(); + return result; + } + public uint GetCurrentSceneFocusProcess() + { + uint result = FnTable.GetCurrentSceneFocusProcess(); + return result; + } + public uint GetLastFrameRenderer() + { + uint result = FnTable.GetLastFrameRenderer(); + return result; + } + public bool CanRenderScene() + { + bool result = FnTable.CanRenderScene(); + return result; + } + public void ShowMirrorWindow() + { + FnTable.ShowMirrorWindow(); + } + public void HideMirrorWindow() + { + FnTable.HideMirrorWindow(); + } + public bool IsMirrorWindowVisible() + { + bool result = FnTable.IsMirrorWindowVisible(); + return result; + } + public void CompositorDumpImages() + { + FnTable.CompositorDumpImages(); + } + public bool ShouldAppRenderWithLowResources() + { + bool result = FnTable.ShouldAppRenderWithLowResources(); + return result; + } + public void ForceInterleavedReprojectionOn(bool bOverride) + { + FnTable.ForceInterleavedReprojectionOn(bOverride); + } + public void ForceReconnectProcess() + { + FnTable.ForceReconnectProcess(); + } + public void SuspendRendering(bool bSuspend) + { + FnTable.SuspendRendering(bSuspend); + } + public EVRCompositorError GetMirrorTextureD3D11(EVREye eEye,IntPtr pD3D11DeviceOrResource,ref IntPtr ppD3D11ShaderResourceView) + { + EVRCompositorError result = FnTable.GetMirrorTextureD3D11(eEye,pD3D11DeviceOrResource,ref ppD3D11ShaderResourceView); + return result; + } + public void ReleaseMirrorTextureD3D11(IntPtr pD3D11ShaderResourceView) + { + FnTable.ReleaseMirrorTextureD3D11(pD3D11ShaderResourceView); + } + public EVRCompositorError GetMirrorTextureGL(EVREye eEye,ref uint pglTextureId,IntPtr pglSharedTextureHandle) + { + pglTextureId = 0; + EVRCompositorError result = FnTable.GetMirrorTextureGL(eEye,ref pglTextureId,pglSharedTextureHandle); + return result; + } + public bool ReleaseSharedGLTexture(uint glTextureId,IntPtr glSharedTextureHandle) + { + bool result = FnTable.ReleaseSharedGLTexture(glTextureId,glSharedTextureHandle); + return result; + } + public void LockGLSharedTextureForAccess(IntPtr glSharedTextureHandle) + { + FnTable.LockGLSharedTextureForAccess(glSharedTextureHandle); + } + public void UnlockGLSharedTextureForAccess(IntPtr glSharedTextureHandle) + { + FnTable.UnlockGLSharedTextureForAccess(glSharedTextureHandle); + } + public uint GetVulkanInstanceExtensionsRequired(System.Text.StringBuilder pchValue,uint unBufferSize) + { + uint result = FnTable.GetVulkanInstanceExtensionsRequired(pchValue,unBufferSize); + return result; + } + public uint GetVulkanDeviceExtensionsRequired(IntPtr pPhysicalDevice,System.Text.StringBuilder pchValue,uint unBufferSize) + { + uint result = FnTable.GetVulkanDeviceExtensionsRequired(pPhysicalDevice,pchValue,unBufferSize); + return result; + } + public void SetExplicitTimingMode(EVRCompositorTimingMode eTimingMode) + { + FnTable.SetExplicitTimingMode(eTimingMode); + } + public EVRCompositorError SubmitExplicitTimingData() + { + EVRCompositorError result = FnTable.SubmitExplicitTimingData(); + return result; + } + public bool IsMotionSmoothingEnabled() + { + bool result = FnTable.IsMotionSmoothingEnabled(); + return result; + } + public bool IsMotionSmoothingSupported() + { + bool result = FnTable.IsMotionSmoothingSupported(); + return result; + } + public bool IsCurrentSceneFocusAppLoading() + { + bool result = FnTable.IsCurrentSceneFocusAppLoading(); + return result; + } +} + + +public class CVROverlay +{ + IVROverlay FnTable; + internal CVROverlay(IntPtr pInterface) + { + FnTable = (IVROverlay)Marshal.PtrToStructure(pInterface, typeof(IVROverlay)); + } + public EVROverlayError FindOverlay(string pchOverlayKey,ref ulong pOverlayHandle) + { + pOverlayHandle = 0; + EVROverlayError result = FnTable.FindOverlay(pchOverlayKey,ref pOverlayHandle); + return result; + } + public EVROverlayError CreateOverlay(string pchOverlayKey,string pchOverlayName,ref ulong pOverlayHandle) + { + pOverlayHandle = 0; + EVROverlayError result = FnTable.CreateOverlay(pchOverlayKey,pchOverlayName,ref pOverlayHandle); + return result; + } + public EVROverlayError DestroyOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.DestroyOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError SetHighQualityOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.SetHighQualityOverlay(ulOverlayHandle); + return result; + } + public ulong GetHighQualityOverlay() + { + ulong result = FnTable.GetHighQualityOverlay(); + return result; + } + public uint GetOverlayKey(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayKey(ulOverlayHandle,pchValue,unBufferSize,ref pError); + return result; + } + public uint GetOverlayName(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayName(ulOverlayHandle,pchValue,unBufferSize,ref pError); + return result; + } + public EVROverlayError SetOverlayName(ulong ulOverlayHandle,string pchName) + { + EVROverlayError result = FnTable.SetOverlayName(ulOverlayHandle,pchName); + return result; + } + public EVROverlayError GetOverlayImageData(ulong ulOverlayHandle,IntPtr pvBuffer,uint unBufferSize,ref uint punWidth,ref uint punHeight) + { + punWidth = 0; + punHeight = 0; + EVROverlayError result = FnTable.GetOverlayImageData(ulOverlayHandle,pvBuffer,unBufferSize,ref punWidth,ref punHeight); + return result; + } + public string GetOverlayErrorNameFromEnum(EVROverlayError error) + { + IntPtr result = FnTable.GetOverlayErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } + public EVROverlayError SetOverlayRenderingPid(ulong ulOverlayHandle,uint unPID) + { + EVROverlayError result = FnTable.SetOverlayRenderingPid(ulOverlayHandle,unPID); + return result; + } + public uint GetOverlayRenderingPid(ulong ulOverlayHandle) + { + uint result = FnTable.GetOverlayRenderingPid(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayFlag(ulong ulOverlayHandle,VROverlayFlags eOverlayFlag,bool bEnabled) + { + EVROverlayError result = FnTable.SetOverlayFlag(ulOverlayHandle,eOverlayFlag,bEnabled); + return result; + } + public EVROverlayError GetOverlayFlag(ulong ulOverlayHandle,VROverlayFlags eOverlayFlag,ref bool pbEnabled) + { + pbEnabled = false; + EVROverlayError result = FnTable.GetOverlayFlag(ulOverlayHandle,eOverlayFlag,ref pbEnabled); + return result; + } + public EVROverlayError SetOverlayColor(ulong ulOverlayHandle,float fRed,float fGreen,float fBlue) + { + EVROverlayError result = FnTable.SetOverlayColor(ulOverlayHandle,fRed,fGreen,fBlue); + return result; + } + public EVROverlayError GetOverlayColor(ulong ulOverlayHandle,ref float pfRed,ref float pfGreen,ref float pfBlue) + { + pfRed = 0; + pfGreen = 0; + pfBlue = 0; + EVROverlayError result = FnTable.GetOverlayColor(ulOverlayHandle,ref pfRed,ref pfGreen,ref pfBlue); + return result; + } + public EVROverlayError SetOverlayAlpha(ulong ulOverlayHandle,float fAlpha) + { + EVROverlayError result = FnTable.SetOverlayAlpha(ulOverlayHandle,fAlpha); + return result; + } + public EVROverlayError GetOverlayAlpha(ulong ulOverlayHandle,ref float pfAlpha) + { + pfAlpha = 0; + EVROverlayError result = FnTable.GetOverlayAlpha(ulOverlayHandle,ref pfAlpha); + return result; + } + public EVROverlayError SetOverlayTexelAspect(ulong ulOverlayHandle,float fTexelAspect) + { + EVROverlayError result = FnTable.SetOverlayTexelAspect(ulOverlayHandle,fTexelAspect); + return result; + } + public EVROverlayError GetOverlayTexelAspect(ulong ulOverlayHandle,ref float pfTexelAspect) + { + pfTexelAspect = 0; + EVROverlayError result = FnTable.GetOverlayTexelAspect(ulOverlayHandle,ref pfTexelAspect); + return result; + } + public EVROverlayError SetOverlaySortOrder(ulong ulOverlayHandle,uint unSortOrder) + { + EVROverlayError result = FnTable.SetOverlaySortOrder(ulOverlayHandle,unSortOrder); + return result; + } + public EVROverlayError GetOverlaySortOrder(ulong ulOverlayHandle,ref uint punSortOrder) + { + punSortOrder = 0; + EVROverlayError result = FnTable.GetOverlaySortOrder(ulOverlayHandle,ref punSortOrder); + return result; + } + public EVROverlayError SetOverlayWidthInMeters(ulong ulOverlayHandle,float fWidthInMeters) + { + EVROverlayError result = FnTable.SetOverlayWidthInMeters(ulOverlayHandle,fWidthInMeters); + return result; + } + public EVROverlayError GetOverlayWidthInMeters(ulong ulOverlayHandle,ref float pfWidthInMeters) + { + pfWidthInMeters = 0; + EVROverlayError result = FnTable.GetOverlayWidthInMeters(ulOverlayHandle,ref pfWidthInMeters); + return result; + } + public EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle,float fMinDistanceInMeters,float fMaxDistanceInMeters) + { + EVROverlayError result = FnTable.SetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle,fMinDistanceInMeters,fMaxDistanceInMeters); + return result; + } + public EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters(ulong ulOverlayHandle,ref float pfMinDistanceInMeters,ref float pfMaxDistanceInMeters) + { + pfMinDistanceInMeters = 0; + pfMaxDistanceInMeters = 0; + EVROverlayError result = FnTable.GetOverlayAutoCurveDistanceRangeInMeters(ulOverlayHandle,ref pfMinDistanceInMeters,ref pfMaxDistanceInMeters); + return result; + } + public EVROverlayError SetOverlayTextureColorSpace(ulong ulOverlayHandle,EColorSpace eTextureColorSpace) + { + EVROverlayError result = FnTable.SetOverlayTextureColorSpace(ulOverlayHandle,eTextureColorSpace); + return result; + } + public EVROverlayError GetOverlayTextureColorSpace(ulong ulOverlayHandle,ref EColorSpace peTextureColorSpace) + { + EVROverlayError result = FnTable.GetOverlayTextureColorSpace(ulOverlayHandle,ref peTextureColorSpace); + return result; + } + public EVROverlayError SetOverlayTextureBounds(ulong ulOverlayHandle,ref VRTextureBounds_t pOverlayTextureBounds) + { + EVROverlayError result = FnTable.SetOverlayTextureBounds(ulOverlayHandle,ref pOverlayTextureBounds); + return result; + } + public EVROverlayError GetOverlayTextureBounds(ulong ulOverlayHandle,ref VRTextureBounds_t pOverlayTextureBounds) + { + EVROverlayError result = FnTable.GetOverlayTextureBounds(ulOverlayHandle,ref pOverlayTextureBounds); + return result; + } + public uint GetOverlayRenderModel(ulong ulOverlayHandle,System.Text.StringBuilder pchValue,uint unBufferSize,ref HmdColor_t pColor,ref EVROverlayError pError) + { + uint result = FnTable.GetOverlayRenderModel(ulOverlayHandle,pchValue,unBufferSize,ref pColor,ref pError); + return result; + } + public EVROverlayError SetOverlayRenderModel(ulong ulOverlayHandle,string pchRenderModel,ref HmdColor_t pColor) + { + EVROverlayError result = FnTable.SetOverlayRenderModel(ulOverlayHandle,pchRenderModel,ref pColor); + return result; + } + public EVROverlayError GetOverlayTransformType(ulong ulOverlayHandle,ref VROverlayTransformType peTransformType) + { + EVROverlayError result = FnTable.GetOverlayTransformType(ulOverlayHandle,ref peTransformType); + return result; + } + public EVROverlayError SetOverlayTransformAbsolute(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformAbsolute(ulOverlayHandle,eTrackingOrigin,ref pmatTrackingOriginToOverlayTransform); + return result; + } + public EVROverlayError GetOverlayTransformAbsolute(ulong ulOverlayHandle,ref ETrackingUniverseOrigin peTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToOverlayTransform) + { + EVROverlayError result = FnTable.GetOverlayTransformAbsolute(ulOverlayHandle,ref peTrackingOrigin,ref pmatTrackingOriginToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle,uint unTrackedDevice,ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceRelative(ulOverlayHandle,unTrackedDevice,ref pmatTrackedDeviceToOverlayTransform); + return result; + } + public EVROverlayError GetOverlayTransformTrackedDeviceRelative(ulong ulOverlayHandle,ref uint punTrackedDevice,ref HmdMatrix34_t pmatTrackedDeviceToOverlayTransform) + { + punTrackedDevice = 0; + EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceRelative(ulOverlayHandle,ref punTrackedDevice,ref pmatTrackedDeviceToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,uint unDeviceIndex,string pchComponentName) + { + EVROverlayError result = FnTable.SetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,unDeviceIndex,pchComponentName); + return result; + } + public EVROverlayError GetOverlayTransformTrackedDeviceComponent(ulong ulOverlayHandle,ref uint punDeviceIndex,System.Text.StringBuilder pchComponentName,uint unComponentNameSize) + { + punDeviceIndex = 0; + EVROverlayError result = FnTable.GetOverlayTransformTrackedDeviceComponent(ulOverlayHandle,ref punDeviceIndex,pchComponentName,unComponentNameSize); + return result; + } + public EVROverlayError GetOverlayTransformOverlayRelative(ulong ulOverlayHandle,ref ulong ulOverlayHandleParent,ref HmdMatrix34_t pmatParentOverlayToOverlayTransform) + { + ulOverlayHandleParent = 0; + EVROverlayError result = FnTable.GetOverlayTransformOverlayRelative(ulOverlayHandle,ref ulOverlayHandleParent,ref pmatParentOverlayToOverlayTransform); + return result; + } + public EVROverlayError SetOverlayTransformOverlayRelative(ulong ulOverlayHandle,ulong ulOverlayHandleParent,ref HmdMatrix34_t pmatParentOverlayToOverlayTransform) + { + EVROverlayError result = FnTable.SetOverlayTransformOverlayRelative(ulOverlayHandle,ulOverlayHandleParent,ref pmatParentOverlayToOverlayTransform); + return result; + } + public EVROverlayError ShowOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ShowOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError HideOverlay(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.HideOverlay(ulOverlayHandle); + return result; + } + public bool IsOverlayVisible(ulong ulOverlayHandle) + { + bool result = FnTable.IsOverlayVisible(ulOverlayHandle); + return result; + } + public EVROverlayError GetTransformForOverlayCoordinates(ulong ulOverlayHandle,ETrackingUniverseOrigin eTrackingOrigin,HmdVector2_t coordinatesInOverlay,ref HmdMatrix34_t pmatTransform) + { + EVROverlayError result = FnTable.GetTransformForOverlayCoordinates(ulOverlayHandle,eTrackingOrigin,coordinatesInOverlay,ref pmatTransform); + return result; + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _PollNextOverlayEventPacked(ulong ulOverlayHandle,ref VREvent_t_Packed pEvent,uint uncbVREvent); + [StructLayout(LayoutKind.Explicit)] + struct PollNextOverlayEventUnion + { + [FieldOffset(0)] + public IVROverlay._PollNextOverlayEvent pPollNextOverlayEvent; + [FieldOffset(0)] + public _PollNextOverlayEventPacked pPollNextOverlayEventPacked; + } + public bool PollNextOverlayEvent(ulong ulOverlayHandle,ref VREvent_t pEvent,uint uncbVREvent) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + PollNextOverlayEventUnion u; + VREvent_t_Packed event_packed = new VREvent_t_Packed(); + u.pPollNextOverlayEventPacked = null; + u.pPollNextOverlayEvent = FnTable.PollNextOverlayEvent; + bool packed_result = u.pPollNextOverlayEventPacked(ulOverlayHandle,ref event_packed,(uint)System.Runtime.InteropServices.Marshal.SizeOf(typeof(VREvent_t_Packed))); + + event_packed.Unpack(ref pEvent); + return packed_result; + } +#endif + bool result = FnTable.PollNextOverlayEvent(ulOverlayHandle,ref pEvent,uncbVREvent); + return result; + } + public EVROverlayError GetOverlayInputMethod(ulong ulOverlayHandle,ref VROverlayInputMethod peInputMethod) + { + EVROverlayError result = FnTable.GetOverlayInputMethod(ulOverlayHandle,ref peInputMethod); + return result; + } + public EVROverlayError SetOverlayInputMethod(ulong ulOverlayHandle,VROverlayInputMethod eInputMethod) + { + EVROverlayError result = FnTable.SetOverlayInputMethod(ulOverlayHandle,eInputMethod); + return result; + } + public EVROverlayError GetOverlayMouseScale(ulong ulOverlayHandle,ref HmdVector2_t pvecMouseScale) + { + EVROverlayError result = FnTable.GetOverlayMouseScale(ulOverlayHandle,ref pvecMouseScale); + return result; + } + public EVROverlayError SetOverlayMouseScale(ulong ulOverlayHandle,ref HmdVector2_t pvecMouseScale) + { + EVROverlayError result = FnTable.SetOverlayMouseScale(ulOverlayHandle,ref pvecMouseScale); + return result; + } + public bool ComputeOverlayIntersection(ulong ulOverlayHandle,ref VROverlayIntersectionParams_t pParams,ref VROverlayIntersectionResults_t pResults) + { + bool result = FnTable.ComputeOverlayIntersection(ulOverlayHandle,ref pParams,ref pResults); + return result; + } + public bool IsHoverTargetOverlay(ulong ulOverlayHandle) + { + bool result = FnTable.IsHoverTargetOverlay(ulOverlayHandle); + return result; + } + public ulong GetGamepadFocusOverlay() + { + ulong result = FnTable.GetGamepadFocusOverlay(); + return result; + } + public EVROverlayError SetGamepadFocusOverlay(ulong ulNewFocusOverlay) + { + EVROverlayError result = FnTable.SetGamepadFocusOverlay(ulNewFocusOverlay); + return result; + } + public EVROverlayError SetOverlayNeighbor(EOverlayDirection eDirection,ulong ulFrom,ulong ulTo) + { + EVROverlayError result = FnTable.SetOverlayNeighbor(eDirection,ulFrom,ulTo); + return result; + } + public EVROverlayError MoveGamepadFocusToNeighbor(EOverlayDirection eDirection,ulong ulFrom) + { + EVROverlayError result = FnTable.MoveGamepadFocusToNeighbor(eDirection,ulFrom); + return result; + } + public EVROverlayError SetOverlayDualAnalogTransform(ulong ulOverlay,EDualAnalogWhich eWhich,ref HmdVector2_t pvCenter,float fRadius) + { + EVROverlayError result = FnTable.SetOverlayDualAnalogTransform(ulOverlay,eWhich,ref pvCenter,fRadius); + return result; + } + public EVROverlayError GetOverlayDualAnalogTransform(ulong ulOverlay,EDualAnalogWhich eWhich,ref HmdVector2_t pvCenter,ref float pfRadius) + { + pfRadius = 0; + EVROverlayError result = FnTable.GetOverlayDualAnalogTransform(ulOverlay,eWhich,ref pvCenter,ref pfRadius); + return result; + } + public EVROverlayError SetOverlayTexture(ulong ulOverlayHandle,ref Texture_t pTexture) + { + EVROverlayError result = FnTable.SetOverlayTexture(ulOverlayHandle,ref pTexture); + return result; + } + public EVROverlayError ClearOverlayTexture(ulong ulOverlayHandle) + { + EVROverlayError result = FnTable.ClearOverlayTexture(ulOverlayHandle); + return result; + } + public EVROverlayError SetOverlayRaw(ulong ulOverlayHandle,IntPtr pvBuffer,uint unWidth,uint unHeight,uint unDepth) + { + EVROverlayError result = FnTable.SetOverlayRaw(ulOverlayHandle,pvBuffer,unWidth,unHeight,unDepth); + return result; + } + public EVROverlayError SetOverlayFromFile(ulong ulOverlayHandle,string pchFilePath) + { + EVROverlayError result = FnTable.SetOverlayFromFile(ulOverlayHandle,pchFilePath); + return result; + } + public EVROverlayError GetOverlayTexture(ulong ulOverlayHandle,ref IntPtr pNativeTextureHandle,IntPtr pNativeTextureRef,ref uint pWidth,ref uint pHeight,ref uint pNativeFormat,ref ETextureType pAPIType,ref EColorSpace pColorSpace,ref VRTextureBounds_t pTextureBounds) + { + pWidth = 0; + pHeight = 0; + pNativeFormat = 0; + EVROverlayError result = FnTable.GetOverlayTexture(ulOverlayHandle,ref pNativeTextureHandle,pNativeTextureRef,ref pWidth,ref pHeight,ref pNativeFormat,ref pAPIType,ref pColorSpace,ref pTextureBounds); + return result; + } + public EVROverlayError ReleaseNativeOverlayHandle(ulong ulOverlayHandle,IntPtr pNativeTextureHandle) + { + EVROverlayError result = FnTable.ReleaseNativeOverlayHandle(ulOverlayHandle,pNativeTextureHandle); + return result; + } + public EVROverlayError GetOverlayTextureSize(ulong ulOverlayHandle,ref uint pWidth,ref uint pHeight) + { + pWidth = 0; + pHeight = 0; + EVROverlayError result = FnTable.GetOverlayTextureSize(ulOverlayHandle,ref pWidth,ref pHeight); + return result; + } + public EVROverlayError CreateDashboardOverlay(string pchOverlayKey,string pchOverlayFriendlyName,ref ulong pMainHandle,ref ulong pThumbnailHandle) + { + pMainHandle = 0; + pThumbnailHandle = 0; + EVROverlayError result = FnTable.CreateDashboardOverlay(pchOverlayKey,pchOverlayFriendlyName,ref pMainHandle,ref pThumbnailHandle); + return result; + } + public bool IsDashboardVisible() + { + bool result = FnTable.IsDashboardVisible(); + return result; + } + public bool IsActiveDashboardOverlay(ulong ulOverlayHandle) + { + bool result = FnTable.IsActiveDashboardOverlay(ulOverlayHandle); + return result; + } + public EVROverlayError SetDashboardOverlaySceneProcess(ulong ulOverlayHandle,uint unProcessId) + { + EVROverlayError result = FnTable.SetDashboardOverlaySceneProcess(ulOverlayHandle,unProcessId); + return result; + } + public EVROverlayError GetDashboardOverlaySceneProcess(ulong ulOverlayHandle,ref uint punProcessId) + { + punProcessId = 0; + EVROverlayError result = FnTable.GetDashboardOverlaySceneProcess(ulOverlayHandle,ref punProcessId); + return result; + } + public void ShowDashboard(string pchOverlayToShow) + { + FnTable.ShowDashboard(pchOverlayToShow); + } + public uint GetPrimaryDashboardDevice() + { + uint result = FnTable.GetPrimaryDashboardDevice(); + return result; + } + public EVROverlayError ShowKeyboard(int eInputMode,int eLineInputMode,string pchDescription,uint unCharMax,string pchExistingText,bool bUseMinimalMode,ulong uUserValue) + { + EVROverlayError result = FnTable.ShowKeyboard(eInputMode,eLineInputMode,pchDescription,unCharMax,pchExistingText,bUseMinimalMode,uUserValue); + return result; + } + public EVROverlayError ShowKeyboardForOverlay(ulong ulOverlayHandle,int eInputMode,int eLineInputMode,string pchDescription,uint unCharMax,string pchExistingText,bool bUseMinimalMode,ulong uUserValue) + { + EVROverlayError result = FnTable.ShowKeyboardForOverlay(ulOverlayHandle,eInputMode,eLineInputMode,pchDescription,unCharMax,pchExistingText,bUseMinimalMode,uUserValue); + return result; + } + public uint GetKeyboardText(System.Text.StringBuilder pchText,uint cchText) + { + uint result = FnTable.GetKeyboardText(pchText,cchText); + return result; + } + public void HideKeyboard() + { + FnTable.HideKeyboard(); + } + public void SetKeyboardTransformAbsolute(ETrackingUniverseOrigin eTrackingOrigin,ref HmdMatrix34_t pmatTrackingOriginToKeyboardTransform) + { + FnTable.SetKeyboardTransformAbsolute(eTrackingOrigin,ref pmatTrackingOriginToKeyboardTransform); + } + public void SetKeyboardPositionForOverlay(ulong ulOverlayHandle,HmdRect2_t avoidRect) + { + FnTable.SetKeyboardPositionForOverlay(ulOverlayHandle,avoidRect); + } + public EVROverlayError SetOverlayIntersectionMask(ulong ulOverlayHandle,ref VROverlayIntersectionMaskPrimitive_t pMaskPrimitives,uint unNumMaskPrimitives,uint unPrimitiveSize) + { + EVROverlayError result = FnTable.SetOverlayIntersectionMask(ulOverlayHandle,ref pMaskPrimitives,unNumMaskPrimitives,unPrimitiveSize); + return result; + } + public EVROverlayError GetOverlayFlags(ulong ulOverlayHandle,ref uint pFlags) + { + pFlags = 0; + EVROverlayError result = FnTable.GetOverlayFlags(ulOverlayHandle,ref pFlags); + return result; + } + public VRMessageOverlayResponse ShowMessageOverlay(string pchText,string pchCaption,string pchButton0Text,string pchButton1Text,string pchButton2Text,string pchButton3Text) + { + VRMessageOverlayResponse result = FnTable.ShowMessageOverlay(pchText,pchCaption,pchButton0Text,pchButton1Text,pchButton2Text,pchButton3Text); + return result; + } + public void CloseMessageOverlay() + { + FnTable.CloseMessageOverlay(); + } +} + + +public class CVRRenderModels +{ + IVRRenderModels FnTable; + internal CVRRenderModels(IntPtr pInterface) + { + FnTable = (IVRRenderModels)Marshal.PtrToStructure(pInterface, typeof(IVRRenderModels)); + } + public EVRRenderModelError LoadRenderModel_Async(string pchRenderModelName,ref IntPtr ppRenderModel) + { + EVRRenderModelError result = FnTable.LoadRenderModel_Async(pchRenderModelName,ref ppRenderModel); + return result; + } + public void FreeRenderModel(IntPtr pRenderModel) + { + FnTable.FreeRenderModel(pRenderModel); + } + public EVRRenderModelError LoadTexture_Async(int textureId,ref IntPtr ppTexture) + { + EVRRenderModelError result = FnTable.LoadTexture_Async(textureId,ref ppTexture); + return result; + } + public void FreeTexture(IntPtr pTexture) + { + FnTable.FreeTexture(pTexture); + } + public EVRRenderModelError LoadTextureD3D11_Async(int textureId,IntPtr pD3D11Device,ref IntPtr ppD3D11Texture2D) + { + EVRRenderModelError result = FnTable.LoadTextureD3D11_Async(textureId,pD3D11Device,ref ppD3D11Texture2D); + return result; + } + public EVRRenderModelError LoadIntoTextureD3D11_Async(int textureId,IntPtr pDstTexture) + { + EVRRenderModelError result = FnTable.LoadIntoTextureD3D11_Async(textureId,pDstTexture); + return result; + } + public void FreeTextureD3D11(IntPtr pD3D11Texture2D) + { + FnTable.FreeTextureD3D11(pD3D11Texture2D); + } + public uint GetRenderModelName(uint unRenderModelIndex,System.Text.StringBuilder pchRenderModelName,uint unRenderModelNameLen) + { + uint result = FnTable.GetRenderModelName(unRenderModelIndex,pchRenderModelName,unRenderModelNameLen); + return result; + } + public uint GetRenderModelCount() + { + uint result = FnTable.GetRenderModelCount(); + return result; + } + public uint GetComponentCount(string pchRenderModelName) + { + uint result = FnTable.GetComponentCount(pchRenderModelName); + return result; + } + public uint GetComponentName(string pchRenderModelName,uint unComponentIndex,System.Text.StringBuilder pchComponentName,uint unComponentNameLen) + { + uint result = FnTable.GetComponentName(pchRenderModelName,unComponentIndex,pchComponentName,unComponentNameLen); + return result; + } + public ulong GetComponentButtonMask(string pchRenderModelName,string pchComponentName) + { + ulong result = FnTable.GetComponentButtonMask(pchRenderModelName,pchComponentName); + return result; + } + public uint GetComponentRenderModelName(string pchRenderModelName,string pchComponentName,System.Text.StringBuilder pchComponentRenderModelName,uint unComponentRenderModelNameLen) + { + uint result = FnTable.GetComponentRenderModelName(pchRenderModelName,pchComponentName,pchComponentRenderModelName,unComponentRenderModelNameLen); + return result; + } + public bool GetComponentStateForDevicePath(string pchRenderModelName,string pchComponentName,ulong devicePath,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState) + { + bool result = FnTable.GetComponentStateForDevicePath(pchRenderModelName,pchComponentName,devicePath,ref pState,ref pComponentState); + return result; + } +// This is a terrible hack to workaround the fact that VRControllerState_t and VREvent_t were +// originally mis-compiled with the wrong packing for Linux and OSX. + [UnmanagedFunctionPointer(CallingConvention.StdCall)] + internal delegate bool _GetComponentStatePacked(string pchRenderModelName,string pchComponentName,ref VRControllerState_t_Packed pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState); + [StructLayout(LayoutKind.Explicit)] + struct GetComponentStateUnion + { + [FieldOffset(0)] + public IVRRenderModels._GetComponentState pGetComponentState; + [FieldOffset(0)] + public _GetComponentStatePacked pGetComponentStatePacked; + } + public bool GetComponentState(string pchRenderModelName,string pchComponentName,ref VRControllerState_t pControllerState,ref RenderModel_ControllerMode_State_t pState,ref RenderModel_ComponentState_t pComponentState) + { +#if !UNITY_METRO + if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) || + (System.Environment.OSVersion.Platform == System.PlatformID.Unix)) + { + GetComponentStateUnion u; + VRControllerState_t_Packed state_packed = new VRControllerState_t_Packed(pControllerState); + u.pGetComponentStatePacked = null; + u.pGetComponentState = FnTable.GetComponentState; + bool packed_result = u.pGetComponentStatePacked(pchRenderModelName,pchComponentName,ref state_packed,ref pState,ref pComponentState); + + state_packed.Unpack(ref pControllerState); + return packed_result; + } +#endif + bool result = FnTable.GetComponentState(pchRenderModelName,pchComponentName,ref pControllerState,ref pState,ref pComponentState); + return result; + } + public bool RenderModelHasComponent(string pchRenderModelName,string pchComponentName) + { + bool result = FnTable.RenderModelHasComponent(pchRenderModelName,pchComponentName); + return result; + } + public uint GetRenderModelThumbnailURL(string pchRenderModelName,System.Text.StringBuilder pchThumbnailURL,uint unThumbnailURLLen,ref EVRRenderModelError peError) + { + uint result = FnTable.GetRenderModelThumbnailURL(pchRenderModelName,pchThumbnailURL,unThumbnailURLLen,ref peError); + return result; + } + public uint GetRenderModelOriginalPath(string pchRenderModelName,System.Text.StringBuilder pchOriginalPath,uint unOriginalPathLen,ref EVRRenderModelError peError) + { + uint result = FnTable.GetRenderModelOriginalPath(pchRenderModelName,pchOriginalPath,unOriginalPathLen,ref peError); + return result; + } + public string GetRenderModelErrorNameFromEnum(EVRRenderModelError error) + { + IntPtr result = FnTable.GetRenderModelErrorNameFromEnum(error); + return Marshal.PtrToStringAnsi(result); + } +} + + +public class CVRNotifications +{ + IVRNotifications FnTable; + internal CVRNotifications(IntPtr pInterface) + { + FnTable = (IVRNotifications)Marshal.PtrToStructure(pInterface, typeof(IVRNotifications)); + } + public EVRNotificationError CreateNotification(ulong ulOverlayHandle,ulong ulUserValue,EVRNotificationType type,string pchText,EVRNotificationStyle style,ref NotificationBitmap_t pImage,ref uint pNotificationId) + { + pNotificationId = 0; + EVRNotificationError result = FnTable.CreateNotification(ulOverlayHandle,ulUserValue,type,pchText,style,ref pImage,ref pNotificationId); + return result; + } + public EVRNotificationError RemoveNotification(uint notificationId) + { + EVRNotificationError result = FnTable.RemoveNotification(notificationId); + return result; + } +} + + +public class CVRSettings +{ + IVRSettings FnTable; + internal CVRSettings(IntPtr pInterface) + { + FnTable = (IVRSettings)Marshal.PtrToStructure(pInterface, typeof(IVRSettings)); + } + public string GetSettingsErrorNameFromEnum(EVRSettingsError eError) + { + IntPtr result = FnTable.GetSettingsErrorNameFromEnum(eError); + return Marshal.PtrToStringAnsi(result); + } + public bool Sync(bool bForce,ref EVRSettingsError peError) + { + bool result = FnTable.Sync(bForce,ref peError); + return result; + } + public void SetBool(string pchSection,string pchSettingsKey,bool bValue,ref EVRSettingsError peError) + { + FnTable.SetBool(pchSection,pchSettingsKey,bValue,ref peError); + } + public void SetInt32(string pchSection,string pchSettingsKey,int nValue,ref EVRSettingsError peError) + { + FnTable.SetInt32(pchSection,pchSettingsKey,nValue,ref peError); + } + public void SetFloat(string pchSection,string pchSettingsKey,float flValue,ref EVRSettingsError peError) + { + FnTable.SetFloat(pchSection,pchSettingsKey,flValue,ref peError); + } + public void SetString(string pchSection,string pchSettingsKey,string pchValue,ref EVRSettingsError peError) + { + FnTable.SetString(pchSection,pchSettingsKey,pchValue,ref peError); + } + public bool GetBool(string pchSection,string pchSettingsKey,ref EVRSettingsError peError) + { + bool result = FnTable.GetBool(pchSection,pchSettingsKey,ref peError); + return result; + } + public int GetInt32(string pchSection,string pchSettingsKey,ref EVRSettingsError peError) + { + int result = FnTable.GetInt32(pchSection,pchSettingsKey,ref peError); + return result; + } + public float GetFloat(string pchSection,string pchSettingsKey,ref EVRSettingsError peError) + { + float result = FnTable.GetFloat(pchSection,pchSettingsKey,ref peError); + return result; + } + public void GetString(string pchSection,string pchSettingsKey,System.Text.StringBuilder pchValue,uint unValueLen,ref EVRSettingsError peError) + { + FnTable.GetString(pchSection,pchSettingsKey,pchValue,unValueLen,ref peError); + } + public void RemoveSection(string pchSection,ref EVRSettingsError peError) + { + FnTable.RemoveSection(pchSection,ref peError); + } + public void RemoveKeyInSection(string pchSection,string pchSettingsKey,ref EVRSettingsError peError) + { + FnTable.RemoveKeyInSection(pchSection,pchSettingsKey,ref peError); + } +} + + +public class CVRScreenshots +{ + IVRScreenshots FnTable; + internal CVRScreenshots(IntPtr pInterface) + { + FnTable = (IVRScreenshots)Marshal.PtrToStructure(pInterface, typeof(IVRScreenshots)); + } + public EVRScreenshotError RequestScreenshot(ref uint pOutScreenshotHandle,EVRScreenshotType type,string pchPreviewFilename,string pchVRFilename) + { + pOutScreenshotHandle = 0; + EVRScreenshotError result = FnTable.RequestScreenshot(ref pOutScreenshotHandle,type,pchPreviewFilename,pchVRFilename); + return result; + } + public EVRScreenshotError HookScreenshot(EVRScreenshotType [] pSupportedTypes) + { + EVRScreenshotError result = FnTable.HookScreenshot(pSupportedTypes,(int) pSupportedTypes.Length); + return result; + } + public EVRScreenshotType GetScreenshotPropertyType(uint screenshotHandle,ref EVRScreenshotError pError) + { + EVRScreenshotType result = FnTable.GetScreenshotPropertyType(screenshotHandle,ref pError); + return result; + } + public uint GetScreenshotPropertyFilename(uint screenshotHandle,EVRScreenshotPropertyFilenames filenameType,System.Text.StringBuilder pchFilename,uint cchFilename,ref EVRScreenshotError pError) + { + uint result = FnTable.GetScreenshotPropertyFilename(screenshotHandle,filenameType,pchFilename,cchFilename,ref pError); + return result; + } + public EVRScreenshotError UpdateScreenshotProgress(uint screenshotHandle,float flProgress) + { + EVRScreenshotError result = FnTable.UpdateScreenshotProgress(screenshotHandle,flProgress); + return result; + } + public EVRScreenshotError TakeStereoScreenshot(ref uint pOutScreenshotHandle,string pchPreviewFilename,string pchVRFilename) + { + pOutScreenshotHandle = 0; + EVRScreenshotError result = FnTable.TakeStereoScreenshot(ref pOutScreenshotHandle,pchPreviewFilename,pchVRFilename); + return result; + } + public EVRScreenshotError SubmitScreenshot(uint screenshotHandle,EVRScreenshotType type,string pchSourcePreviewFilename,string pchSourceVRFilename) + { + EVRScreenshotError result = FnTable.SubmitScreenshot(screenshotHandle,type,pchSourcePreviewFilename,pchSourceVRFilename); + return result; + } +} + + +public class CVRResources +{ + IVRResources FnTable; + internal CVRResources(IntPtr pInterface) + { + FnTable = (IVRResources)Marshal.PtrToStructure(pInterface, typeof(IVRResources)); + } + public uint LoadSharedResource(string pchResourceName,string pchBuffer,uint unBufferLen) + { + uint result = FnTable.LoadSharedResource(pchResourceName,pchBuffer,unBufferLen); + return result; + } + public uint GetResourceFullPath(string pchResourceName,string pchResourceTypeDirectory,System.Text.StringBuilder pchPathBuffer,uint unBufferLen) + { + uint result = FnTable.GetResourceFullPath(pchResourceName,pchResourceTypeDirectory,pchPathBuffer,unBufferLen); + return result; + } +} + + +public class CVRDriverManager +{ + IVRDriverManager FnTable; + internal CVRDriverManager(IntPtr pInterface) + { + FnTable = (IVRDriverManager)Marshal.PtrToStructure(pInterface, typeof(IVRDriverManager)); + } + public uint GetDriverCount() + { + uint result = FnTable.GetDriverCount(); + return result; + } + public uint GetDriverName(uint nDriver,System.Text.StringBuilder pchValue,uint unBufferSize) + { + uint result = FnTable.GetDriverName(nDriver,pchValue,unBufferSize); + return result; + } + public ulong GetDriverHandle(string pchDriverName) + { + ulong result = FnTable.GetDriverHandle(pchDriverName); + return result; + } + public 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) + { + EVRInputError result = FnTable.SetActionManifestPath(pchActionManifestPath); + return result; + } + public EVRInputError GetActionSetHandle(string pchActionSetName,ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetActionSetHandle(pchActionSetName,ref pHandle); + return result; + } + public EVRInputError GetActionHandle(string pchActionName,ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetActionHandle(pchActionName,ref pHandle); + return result; + } + public EVRInputError GetInputSourceHandle(string pchInputSourcePath,ref ulong pHandle) + { + pHandle = 0; + EVRInputError result = FnTable.GetInputSourceHandle(pchInputSourcePath,ref pHandle); + return result; + } + public EVRInputError UpdateActionState(VRActiveActionSet_t [] pSets,uint unSizeOfVRSelectedActionSet_t) + { + EVRInputError result = FnTable.UpdateActionState(pSets,unSizeOfVRSelectedActionSet_t,(uint) pSets.Length); + return result; + } + public EVRInputError GetDigitalActionData(ulong action,ref InputDigitalActionData_t pActionData,uint unActionDataSize,ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetDigitalActionData(action,ref pActionData,unActionDataSize,ulRestrictToDevice); + return result; + } + public EVRInputError GetAnalogActionData(ulong action,ref InputAnalogActionData_t pActionData,uint unActionDataSize,ulong ulRestrictToDevice) + { + EVRInputError result = FnTable.GetAnalogActionData(action,ref pActionData,unActionDataSize,ulRestrictToDevice); + return result; + } + public EVRInputError 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 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 bool IsUsingLegacyInput() + { + bool result = FnTable.IsUsingLegacyInput(); + return result; + } +} + + +public class CVRIOBuffer +{ + IVRIOBuffer FnTable; + internal CVRIOBuffer(IntPtr pInterface) + { + FnTable = (IVRIOBuffer)Marshal.PtrToStructure(pInterface, typeof(IVRIOBuffer)); + } + public EIOBufferError Open(string pchPath,EIOBufferMode mode,uint unElementSize,uint unElements,ref ulong pulBuffer) + { + pulBuffer = 0; + EIOBufferError result = FnTable.Open(pchPath,mode,unElementSize,unElements,ref pulBuffer); + return result; + } + public EIOBufferError Close(ulong ulBuffer) + { + EIOBufferError result = FnTable.Close(ulBuffer); + return result; + } + public EIOBufferError Read(ulong ulBuffer,IntPtr pDst,uint unBytes,ref uint punRead) + { + punRead = 0; + EIOBufferError result = FnTable.Read(ulBuffer,pDst,unBytes,ref punRead); + return result; + } + public EIOBufferError Write(ulong ulBuffer,IntPtr pSrc,uint unBytes) + { + EIOBufferError result = FnTable.Write(ulBuffer,pSrc,unBytes); + return result; + } + public ulong PropertyContainer(ulong ulBuffer) + { + ulong result = FnTable.PropertyContainer(ulBuffer); + return result; + } + public bool HasReaders(ulong ulBuffer) + { + bool result = FnTable.HasReaders(ulBuffer); + return result; + } +} + + +public class CVRSpatialAnchors +{ + IVRSpatialAnchors FnTable; + internal CVRSpatialAnchors(IntPtr pInterface) + { + FnTable = (IVRSpatialAnchors)Marshal.PtrToStructure(pInterface, typeof(IVRSpatialAnchors)); + } + public EVRSpatialAnchorError CreateSpatialAnchorFromDescriptor(string pchDescriptor,ref uint pHandleOut) + { + pHandleOut = 0; + EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromDescriptor(pchDescriptor,ref pHandleOut); + return result; + } + public EVRSpatialAnchorError CreateSpatialAnchorFromPose(uint unDeviceIndex,ETrackingUniverseOrigin eOrigin,ref SpatialAnchorPose_t pPose,ref uint pHandleOut) + { + pHandleOut = 0; + EVRSpatialAnchorError result = FnTable.CreateSpatialAnchorFromPose(unDeviceIndex,eOrigin,ref pPose,ref pHandleOut); + return result; + } + public EVRSpatialAnchorError GetSpatialAnchorPose(uint unHandle,ETrackingUniverseOrigin eOrigin,ref SpatialAnchorPose_t pPoseOut) + { + EVRSpatialAnchorError result = FnTable.GetSpatialAnchorPose(unHandle,eOrigin,ref pPoseOut); + return result; + } + public EVRSpatialAnchorError GetSpatialAnchorDescriptor(uint unHandle,System.Text.StringBuilder pchDescriptorOut,ref uint punDescriptorBufferLenInOut) + { + punDescriptorBufferLenInOut = 0; + EVRSpatialAnchorError result = FnTable.GetSpatialAnchorDescriptor(unHandle,pchDescriptorOut,ref punDescriptorBufferLenInOut); + return result; + } +} + + +public class CVRDebug +{ + IVRDebug FnTable; + internal CVRDebug(IntPtr pInterface) + { + FnTable = (IVRDebug)Marshal.PtrToStructure(pInterface, typeof(IVRDebug)); + } + public EVRDebugError EmitVrProfilerEvent(string pchMessage) + { + EVRDebugError result = FnTable.EmitVrProfilerEvent(pchMessage); + 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) + { + EVRDebugError result = FnTable.FinishVrProfilerEvent(hHandle,pchMessage); + return result; + } + public uint DriverDebugRequest(uint unDeviceIndex,string pchRequest,System.Text.StringBuilder pchResponseBuffer,uint unResponseBufferSize) + { + uint result = FnTable.DriverDebugRequest(unDeviceIndex,pchRequest,pchResponseBuffer,unResponseBufferSize); + return result; + } +} + + +public class OpenVRInterop +{ + [DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType); + [DllImportAttribute("openvr_api", EntryPoint = "VR_InitInternal2", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType,[In, MarshalAs(UnmanagedType.LPStr)] string pStartupInfo); + [DllImportAttribute("openvr_api", EntryPoint = "VR_ShutdownInternal", CallingConvention = CallingConvention.Cdecl)] + internal static extern void ShutdownInternal(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsHmdPresent", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsHmdPresent(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsRuntimeInstalled", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsRuntimeInstalled(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_RuntimePath", CallingConvention = CallingConvention.Cdecl)] + internal static extern string RuntimePath(); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetStringForHmdError", CallingConvention = CallingConvention.Cdecl)] + internal static extern IntPtr GetStringForHmdError(EVRInitError error); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetGenericInterface", CallingConvention = CallingConvention.Cdecl)] + internal static extern IntPtr GetGenericInterface([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion, ref EVRInitError peError); + [DllImportAttribute("openvr_api", EntryPoint = "VR_IsInterfaceVersionValid", CallingConvention = CallingConvention.Cdecl)] + internal static extern bool IsInterfaceVersionValid([In, MarshalAs(UnmanagedType.LPStr)] string pchInterfaceVersion); + [DllImportAttribute("openvr_api", EntryPoint = "VR_GetInitToken", CallingConvention = CallingConvention.Cdecl)] + internal static extern uint GetInitToken(); +} + + +public enum EVREye +{ + Eye_Left = 0, + Eye_Right = 1, +} +public enum ETextureType +{ + Invalid = -1, + DirectX = 0, + OpenGL = 1, + Vulkan = 2, + IOSurface = 3, + DirectX12 = 4, + DXGISharedHandle = 5, + Metal = 6, +} +public enum EColorSpace +{ + Auto = 0, + Gamma = 1, + Linear = 2, +} +public enum ETrackingResult +{ + Uninitialized = 1, + Calibrating_InProgress = 100, + Calibrating_OutOfRange = 101, + Running_OK = 200, + Running_OutOfRange = 201, + Fallback_RotationOnly = 300, +} +public enum ETrackedDeviceClass +{ + Invalid = 0, + HMD = 1, + Controller = 2, + GenericTracker = 3, + TrackingReference = 4, + DisplayRedirect = 5, + Max = 6, +} +public enum ETrackedControllerRole +{ + Invalid = 0, + LeftHand = 1, + RightHand = 2, + OptOut = 3, + Treadmill = 4, + Max = 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_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_DisplayAvailableFrameRates_Float_Array = 2080, + Prop_DisplaySupportsMultipleFramerates_Bool = 2081, + Prop_DisplayColorMultLeft_Vector3 = 2082, + Prop_DisplayColorMultRight_Vector3 = 2083, + Prop_DashboardLayoutPathName_String = 2090, + Prop_DriverRequestedMuraCorrectionMode_Int32 = 2200, + Prop_DriverRequestedMuraFeather_InnerLeft_Int32 = 2201, + Prop_DriverRequestedMuraFeather_InnerRight_Int32 = 2202, + Prop_DriverRequestedMuraFeather_InnerTop_Int32 = 2203, + Prop_DriverRequestedMuraFeather_InnerBottom_Int32 = 2204, + Prop_DriverRequestedMuraFeather_OuterLeft_Int32 = 2205, + Prop_DriverRequestedMuraFeather_OuterRight_Int32 = 2206, + Prop_DriverRequestedMuraFeather_OuterTop_Int32 = 2207, + Prop_DriverRequestedMuraFeather_OuterBottom_Int32 = 2208, + Prop_AttachedDeviceId_String = 3000, + Prop_SupportedButtons_Uint64 = 3001, + Prop_Axis0Type_Int32 = 3002, + Prop_Axis1Type_Int32 = 3003, + Prop_Axis2Type_Int32 = 3004, + Prop_Axis3Type_Int32 = 3005, + Prop_Axis4Type_Int32 = 3006, + Prop_ControllerRoleHint_Int32 = 3007, + Prop_FieldOfViewLeftDegrees_Float = 4000, + Prop_FieldOfViewRightDegrees_Float = 4001, + Prop_FieldOfViewTopDegrees_Float = 4002, + Prop_FieldOfViewBottomDegrees_Float = 4003, + Prop_TrackingRangeMinimumMeters_Float = 4004, + Prop_TrackingRangeMaximumMeters_Float = 4005, + Prop_ModeLabel_String = 4006, + Prop_CanWirelessIdentify_Bool = 4007, + Prop_Nonce_Int32 = 4008, + Prop_IconPathName_String = 5000, + Prop_NamedIconPathDeviceOff_String = 5001, + Prop_NamedIconPathDeviceSearching_String = 5002, + Prop_NamedIconPathDeviceSearchingAlert_String = 5003, + Prop_NamedIconPathDeviceReady_String = 5004, + Prop_NamedIconPathDeviceReadyAlert_String = 5005, + Prop_NamedIconPathDeviceNotReady_String = 5006, + Prop_NamedIconPathDeviceStandby_String = 5007, + Prop_NamedIconPathDeviceAlertLow_String = 5008, + Prop_DisplayHiddenArea_Binary_Start = 5100, + Prop_DisplayHiddenArea_Binary_End = 5150, + Prop_ParentContainer = 5151, + Prop_UserConfigPath_String = 6000, + Prop_InstallPath_String = 6001, + Prop_HasDisplayComponent_Bool = 6002, + Prop_HasControllerComponent_Bool = 6003, + Prop_HasCameraComponent_Bool = 6004, + Prop_HasDriverDirectModeComponent_Bool = 6005, + Prop_HasVirtualDisplayComponent_Bool = 6006, + Prop_HasSpatialAnchorsSupport_Bool = 6007, + Prop_ControllerType_String = 7000, + Prop_ControllerHandSelectionPriority_Int32 = 7002, + Prop_VendorSpecific_Reserved_Start = 10000, + Prop_VendorSpecific_Reserved_End = 10999, + Prop_TrackedDeviceProperty_Max = 1000000, +} +public enum ETrackedPropertyError +{ + TrackedProp_Success = 0, + TrackedProp_WrongDataType = 1, + TrackedProp_WrongDeviceClass = 2, + TrackedProp_BufferTooSmall = 3, + TrackedProp_UnknownProperty = 4, + TrackedProp_InvalidDevice = 5, + TrackedProp_CouldNotContactServer = 6, + TrackedProp_ValueNotProvidedByDevice = 7, + TrackedProp_StringExceedsMaximumLength = 8, + TrackedProp_NotYetAvailable = 9, + TrackedProp_PermissionDenied = 10, + TrackedProp_InvalidOperation = 11, + TrackedProp_CannotWriteToWildcards = 12, + TrackedProp_IPCReadFailure = 13, +} +public enum 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, +} +public enum EVRState +{ + Undefined = -1, + Off = 0, + Searching = 1, + Searching_Alert = 2, + Ready = 3, + Ready_Alert = 4, + NotReady = 5, + Standby = 6, + Ready_Alert_Low = 7, +} +public enum EVREventType +{ + VREvent_None = 0, + VREvent_TrackedDeviceActivated = 100, + VREvent_TrackedDeviceDeactivated = 101, + VREvent_TrackedDeviceUpdated = 102, + VREvent_TrackedDeviceUserInteractionStarted = 103, + VREvent_TrackedDeviceUserInteractionEnded = 104, + VREvent_IpdChanged = 105, + VREvent_EnterStandbyMode = 106, + VREvent_LeaveStandbyMode = 107, + VREvent_TrackedDeviceRoleChanged = 108, + VREvent_WatchdogWakeUpRequested = 109, + VREvent_LensDistortionChanged = 110, + VREvent_PropertyChanged = 111, + VREvent_WirelessDisconnect = 112, + VREvent_WirelessReconnect = 113, + VREvent_ButtonPress = 200, + VREvent_ButtonUnpress = 201, + VREvent_ButtonTouch = 202, + VREvent_ButtonUntouch = 203, + VREvent_DualAnalog_Press = 250, + VREvent_DualAnalog_Unpress = 251, + VREvent_DualAnalog_Touch = 252, + VREvent_DualAnalog_Untouch = 253, + VREvent_DualAnalog_Move = 254, + VREvent_DualAnalog_ModeSwitch1 = 255, + VREvent_DualAnalog_ModeSwitch2 = 256, + VREvent_DualAnalog_Cancel = 257, + VREvent_MouseMove = 300, + VREvent_MouseButtonDown = 301, + VREvent_MouseButtonUp = 302, + VREvent_FocusEnter = 303, + VREvent_FocusLeave = 304, + VREvent_ScrollDiscrete = 305, + VREvent_TouchPadMove = 306, + VREvent_OverlayFocusChanged = 307, + VREvent_ReloadOverlays = 308, + VREvent_ScrollSmooth = 309, + VREvent_InputFocusCaptured = 400, + VREvent_InputFocusReleased = 401, + VREvent_SceneFocusLost = 402, + VREvent_SceneFocusGained = 403, + VREvent_SceneApplicationChanged = 404, + VREvent_SceneFocusChanged = 405, + VREvent_InputFocusChanged = 406, + VREvent_SceneApplicationSecondaryRenderingStarted = 407, + VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408, + VREvent_ActionBindingReloaded = 409, + VREvent_HideRenderModels = 410, + VREvent_ShowRenderModels = 411, + VREvent_ConsoleOpened = 420, + VREvent_ConsoleClosed = 421, + VREvent_OverlayShown = 500, + VREvent_OverlayHidden = 501, + VREvent_DashboardActivated = 502, + VREvent_DashboardDeactivated = 503, + VREvent_DashboardRequested = 505, + VREvent_ResetDashboard = 506, + VREvent_RenderToast = 507, + VREvent_ImageLoaded = 508, + VREvent_ShowKeyboard = 509, + VREvent_HideKeyboard = 510, + VREvent_OverlayGamepadFocusGained = 511, + VREvent_OverlayGamepadFocusLost = 512, + VREvent_OverlaySharedTextureChanged = 513, + VREvent_ScreenshotTriggered = 516, + VREvent_ImageFailed = 517, + VREvent_DashboardOverlayCreated = 518, + VREvent_SwitchGamepadFocus = 519, + VREvent_RequestScreenshot = 520, + VREvent_ScreenshotTaken = 521, + VREvent_ScreenshotFailed = 522, + VREvent_SubmitScreenshotToDashboard = 523, + VREvent_ScreenshotProgressToDashboard = 524, + VREvent_PrimaryDashboardDeviceChanged = 525, + VREvent_RoomViewShown = 526, + VREvent_RoomViewHidden = 527, + VREvent_ShowUI = 528, + VREvent_ShowDevTools = 529, + VREvent_Notification_Shown = 600, + VREvent_Notification_Hidden = 601, + VREvent_Notification_BeginInteraction = 602, + VREvent_Notification_Destroyed = 603, + VREvent_Quit = 700, + VREvent_ProcessQuit = 701, + VREvent_QuitAborted_UserPrompt = 702, + VREvent_QuitAcknowledged = 703, + VREvent_DriverRequestedQuit = 704, + VREvent_RestartRequested = 705, + VREvent_ChaperoneDataHasChanged = 800, + VREvent_ChaperoneUniverseHasChanged = 801, + VREvent_ChaperoneTempDataHasChanged = 802, + VREvent_ChaperoneSettingsHaveChanged = 803, + VREvent_SeatedZeroPoseReset = 804, + VREvent_ChaperoneFlushCache = 805, + VREvent_ChaperoneRoomSetupStarting = 806, + VREvent_ChaperoneRoomSetupFinished = 807, + VREvent_AudioSettingsHaveChanged = 820, + VREvent_BackgroundSettingHasChanged = 850, + VREvent_CameraSettingsHaveChanged = 851, + VREvent_ReprojectionSettingHasChanged = 852, + VREvent_ModelSkinSettingsHaveChanged = 853, + VREvent_EnvironmentSettingsHaveChanged = 854, + VREvent_PowerSettingsHaveChanged = 855, + VREvent_EnableHomeAppSettingsHaveChanged = 856, + VREvent_SteamVRSectionSettingChanged = 857, + VREvent_LighthouseSectionSettingChanged = 858, + VREvent_NullSectionSettingChanged = 859, + VREvent_UserInterfaceSectionSettingChanged = 860, + VREvent_NotificationsSectionSettingChanged = 861, + VREvent_KeyboardSectionSettingChanged = 862, + VREvent_PerfSectionSettingChanged = 863, + VREvent_DashboardSectionSettingChanged = 864, + VREvent_WebInterfaceSectionSettingChanged = 865, + VREvent_TrackersSectionSettingChanged = 866, + VREvent_LastKnownSectionSettingChanged = 867, + VREvent_DismissedWarningsSectionSettingChanged = 868, + VREvent_StatusUpdate = 900, + VREvent_WebInterface_InstallDriverCompleted = 950, + VREvent_MCImageUpdated = 1000, + VREvent_FirmwareUpdateStarted = 1100, + VREvent_FirmwareUpdateFinished = 1101, + VREvent_KeyboardClosed = 1200, + VREvent_KeyboardCharInput = 1201, + VREvent_KeyboardDone = 1202, + VREvent_ApplicationTransitionStarted = 1300, + VREvent_ApplicationTransitionAborted = 1301, + VREvent_ApplicationTransitionNewAppStarted = 1302, + VREvent_ApplicationListUpdated = 1303, + VREvent_ApplicationMimeTypeLoad = 1304, + VREvent_ApplicationTransitionNewAppLaunchComplete = 1305, + VREvent_ProcessConnected = 1306, + VREvent_ProcessDisconnected = 1307, + VREvent_Compositor_MirrorWindowShown = 1400, + VREvent_Compositor_MirrorWindowHidden = 1401, + VREvent_Compositor_ChaperoneBoundsShown = 1410, + VREvent_Compositor_ChaperoneBoundsHidden = 1411, + VREvent_Compositor_DisplayDisconnected = 1412, + VREvent_Compositor_DisplayReconnected = 1413, + VREvent_Compositor_HDCPError = 1414, + VREvent_Compositor_ApplicationNotResponding = 1415, + VREvent_Compositor_ApplicationResumed = 1416, + VREvent_Compositor_OutOfVideoMemory = 1417, + VREvent_TrackedCamera_StartVideoStream = 1500, + VREvent_TrackedCamera_StopVideoStream = 1501, + VREvent_TrackedCamera_PauseVideoStream = 1502, + VREvent_TrackedCamera_ResumeVideoStream = 1503, + VREvent_TrackedCamera_EditingSurface = 1550, + VREvent_PerformanceTest_EnableCapture = 1600, + VREvent_PerformanceTest_DisableCapture = 1601, + VREvent_PerformanceTest_FidelityLevel = 1602, + VREvent_MessageOverlay_Closed = 1650, + VREvent_MessageOverlayCloseRequested = 1651, + VREvent_Input_HapticVibration = 1700, + VREvent_Input_BindingLoadFailed = 1701, + VREvent_Input_BindingLoadSuccessful = 1702, + VREvent_Input_ActionManifestReloaded = 1703, + VREvent_Input_ActionManifestLoadFailed = 1704, + VREvent_Input_ProgressUpdate = 1705, + VREvent_Input_TrackerActivated = 1706, + VREvent_Input_BindingsUpdated = 1707, + VREvent_SpatialAnchors_PoseUpdated = 1800, + VREvent_SpatialAnchors_DescriptorUpdated = 1801, + VREvent_SpatialAnchors_RequestPoseUpdate = 1802, + VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803, + VREvent_SystemReport_Started = 1900, + VREvent_VendorSpecific_Reserved_Start = 10000, + VREvent_VendorSpecific_Reserved_End = 19999, +} +public enum EDeviceActivityLevel +{ + k_EDeviceActivityLevel_Unknown = -1, + k_EDeviceActivityLevel_Idle = 0, + k_EDeviceActivityLevel_UserInteraction = 1, + k_EDeviceActivityLevel_UserInteraction_Timeout = 2, + k_EDeviceActivityLevel_Standby = 3, +} +public enum EVRButtonId +{ + k_EButton_System = 0, + k_EButton_ApplicationMenu = 1, + k_EButton_Grip = 2, + k_EButton_DPad_Left = 3, + k_EButton_DPad_Up = 4, + k_EButton_DPad_Right = 5, + k_EButton_DPad_Down = 6, + k_EButton_A = 7, + k_EButton_ProximitySensor = 31, + k_EButton_Axis0 = 32, + k_EButton_Axis1 = 33, + k_EButton_Axis2 = 34, + k_EButton_Axis3 = 35, + k_EButton_Axis4 = 36, + k_EButton_SteamVR_Touchpad = 32, + k_EButton_SteamVR_Trigger = 33, + k_EButton_Dashboard_Back = 2, + k_EButton_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 EDualAnalogWhich +{ + k_EDualAnalog_Left = 0, + k_EDualAnalog_Right = 1, +} +public enum EShowUIType +{ + ShowUI_ControllerBinding = 0, + ShowUI_ManageTrackers = 1, + ShowUI_Pairing = 3, + ShowUI_Settings = 4, + ShowUI_DebugCommands = 5, +} +public enum EHDCPError +{ + None = 0, + LinkLost = 1, + Tampered = 2, + DeviceRevoked = 3, + Unknown = 4, +} +public enum EVRInputError +{ + None = 0, + NameNotFound = 1, + WrongType = 2, + InvalidHandle = 3, + InvalidParam = 4, + NoSteam = 5, + MaxCapacityReached = 6, + IPCError = 7, + NoActiveActionSet = 8, + InvalidDevice = 9, + InvalidSkeleton = 10, + InvalidBoneCount = 11, + InvalidCompressedData = 12, + NoData = 13, + BufferTooSmall = 14, + MismatchedActionManifest = 15, + MissingSkeletonData = 16, + InvalidBoneIndex = 17, +} +public enum EVRSpatialAnchorError +{ + Success = 0, + Internal = 1, + UnknownHandle = 2, + ArrayTooSmall = 3, + InvalidDescriptorChar = 4, + NotYetAvailable = 5, + NotAvailableInThisUniverse = 6, + PermanentlyUnavailable = 7, + WrongDriver = 8, + DescriptorTooLong = 9, + Unknown = 10, + NoRoomCalibration = 11, + InvalidArgument = 12, + UnknownDriver = 13, +} +public enum EHiddenAreaMeshType +{ + k_eHiddenAreaMesh_Standard = 0, + k_eHiddenAreaMesh_Inverse = 1, + k_eHiddenAreaMesh_LineLoop = 2, + k_eHiddenAreaMesh_Max = 3, +} +public enum EVRControllerAxisType +{ + k_eControllerAxis_None = 0, + k_eControllerAxis_TrackPad = 1, + k_eControllerAxis_Joystick = 2, + k_eControllerAxis_Trigger = 3, +} +public enum EVRControllerEventOutputType +{ + ControllerEventOutput_OSEvents = 0, + ControllerEventOutput_VREvents = 1, +} +public enum ECollisionBoundsStyle +{ + COLLISION_BOUNDS_STYLE_BEGINNER = 0, + COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1, + COLLISION_BOUNDS_STYLE_SQUARES = 2, + COLLISION_BOUNDS_STYLE_ADVANCED = 3, + COLLISION_BOUNDS_STYLE_NONE = 4, + COLLISION_BOUNDS_STYLE_COUNT = 5, +} +public enum EVROverlayError +{ + None = 0, + UnknownOverlay = 10, + InvalidHandle = 11, + PermissionDenied = 12, + OverlayLimitExceeded = 13, + WrongVisibilityType = 14, + KeyTooLong = 15, + NameTooLong = 16, + KeyInUse = 17, + WrongTransformType = 18, + InvalidTrackedDevice = 19, + InvalidParameter = 20, + ThumbnailCantBeDestroyed = 21, + ArrayTooSmall = 22, + RequestFailed = 23, + InvalidTexture = 24, + UnableToLoadFile = 25, + KeyboardAlreadyInUse = 26, + NoNeighbor = 27, + TooManyMaskPrimitives = 29, + BadMaskPrimitive = 30, + TextureAlreadyLocked = 31, + TextureLockCapacityReached = 32, + TextureNotLocked = 33, +} +public enum EVRApplicationType +{ + VRApplication_Other = 0, + VRApplication_Scene = 1, + VRApplication_Overlay = 2, + VRApplication_Background = 3, + VRApplication_Utility = 4, + VRApplication_VRMonitor = 5, + VRApplication_SteamWatchdog = 6, + VRApplication_Bootstrapper = 7, + VRApplication_WebHelper = 8, + VRApplication_Max = 9, +} +public enum EVRFirmwareError +{ + None = 0, + Success = 1, + Fail = 2, +} +public enum EVRNotificationError +{ + OK = 0, + InvalidNotificationId = 100, + NotificationQueueFull = 101, + InvalidOverlayHandle = 102, + SystemWithUserValueAlreadyExists = 103, +} +public enum EVRSkeletalMotionRange +{ + WithController = 0, + WithoutController = 1, +} +public enum EVRSkeletalTrackingLevel +{ + VRSkeletalTracking_Estimated = 0, + VRSkeletalTracking_Partial = 1, + VRSkeletalTracking_Full = 2, + Count = 3, + Max = 2, +} +public enum EVRInitError +{ + None = 0, + Unknown = 1, + Init_InstallationNotFound = 100, + Init_InstallationCorrupt = 101, + Init_VRClientDLLNotFound = 102, + Init_FileNotFound = 103, + Init_FactoryNotFound = 104, + Init_InterfaceNotFound = 105, + Init_InvalidInterface = 106, + Init_UserConfigDirectoryInvalid = 107, + Init_HmdNotFound = 108, + Init_NotInitialized = 109, + Init_PathRegistryNotFound = 110, + Init_NoConfigPath = 111, + Init_NoLogPath = 112, + Init_PathRegistryNotWritable = 113, + Init_AppInfoInitFailed = 114, + Init_Retry = 115, + Init_InitCanceledByUser = 116, + Init_AnotherAppLaunching = 117, + Init_SettingsInitFailed = 118, + Init_ShuttingDown = 119, + Init_TooManyObjects = 120, + Init_NoServerForBackgroundApp = 121, + Init_NotSupportedWithCompositor = 122, + Init_NotAvailableToUtilityApps = 123, + Init_Internal = 124, + Init_HmdDriverIdIsNone = 125, + Init_HmdNotFoundPresenceFailed = 126, + Init_VRMonitorNotFound = 127, + Init_VRMonitorStartupFailed = 128, + Init_LowPowerWatchdogNotSupported = 129, + Init_InvalidApplicationType = 130, + Init_NotAvailableToWatchdogApps = 131, + Init_WatchdogDisabledInSettings = 132, + Init_VRDashboardNotFound = 133, + Init_VRDashboardStartupFailed = 134, + Init_VRHomeNotFound = 135, + Init_VRHomeStartupFailed = 136, + Init_RebootingBusy = 137, + Init_FirmwareUpdateBusy = 138, + Init_FirmwareRecoveryBusy = 139, + Init_USBServiceBusy = 140, + Init_VRWebHelperStartupFailed = 141, + Init_TrackerManagerInitFailed = 142, + Init_AlreadyRunning = 143, + Init_FailedForVrMonitor = 144, + Init_PropertyManagerInitFailed = 145, + 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_CreateOverlayVertextBuffer = 480, + Compositor_CreateTextVertexBuffer = 481, + Compositor_CreateTextIndexBuffer = 482, + Compositor_CreateMirrorTextures = 483, + Compositor_CreateLastFrameRenderTexture = 484, + Compositor_CreateMirrorOverlay = 485, + Compositor_FailedToCreateVirtualDisplayBackbuffer = 486, + 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, +} +public enum EVRApplicationProperty +{ + Name_String = 0, + LaunchType_String = 11, + WorkingDirectory_String = 12, + BinaryPath_String = 13, + Arguments_String = 14, + URL_String = 15, + Description_String = 50, + NewsURL_String = 51, + ImagePath_String = 52, + Source_String = 53, + ActionManifestURL_String = 54, + IsDashboardOverlay_Bool = 60, + IsTemplate_Bool = 61, + IsInstanced_Bool = 62, + IsInternal_Bool = 63, + WantsCompositorPauseInStandby_Bool = 64, + LastLaunchTime_Uint64 = 70, +} +public enum EVRApplicationTransitionState +{ + VRApplicationTransition_None = 0, + VRApplicationTransition_OldAppQuitSent = 10, + VRApplicationTransition_WaitingForExternalLaunch = 11, + VRApplicationTransition_NewAppLaunched = 20, +} +public enum ChaperoneCalibrationState +{ + OK = 1, + Warning = 100, + Warning_BaseStationMayHaveMoved = 101, + Warning_BaseStationRemoved = 102, + Warning_SeatedBoundsInvalid = 103, + Error = 200, + Error_BaseStationUninitialized = 201, + Error_BaseStationConflict = 202, + Error_PlayAreaInvalid = 203, + Error_CollisionBoundsInvalid = 204, +} +public enum EChaperoneConfigFile +{ + Live = 1, + Temp = 2, +} +public enum EChaperoneImportFlags +{ + EChaperoneImport_BoundsOnly = 1, +} +public enum EVRCompositorError +{ + None = 0, + RequestFailed = 1, + IncompatibleVersion = 100, + DoNotHaveFocus = 101, + InvalidTexture = 102, + IsNotSceneApplication = 103, + TextureIsOnWrongDevice = 104, + TextureUsesUnsupportedFormat = 105, + SharedTexturesNotSupported = 106, + IndexOutOfRange = 107, + AlreadySubmitted = 108, + InvalidBounds = 109, +} +public enum EVRCompositorTimingMode +{ + Implicit = 0, + Explicit_RuntimePerformsPostPresentHandoff = 1, + Explicit_ApplicationPerformsPostPresentHandoff = 2, +} +public enum VROverlayInputMethod +{ + None = 0, + Mouse = 1, + DualAnalog = 2, +} +public enum VROverlayTransformType +{ + VROverlayTransform_Absolute = 0, + VROverlayTransform_TrackedDeviceRelative = 1, + VROverlayTransform_SystemOverlay = 2, + VROverlayTransform_TrackedComponent = 3, +} +public enum VROverlayFlags +{ + None = 0, + Curved = 1, + RGSS4X = 2, + NoDashboardTab = 3, + AcceptsGamepadEvents = 4, + ShowGamepadFocus = 5, + SendVRDiscreteScrollEvents = 6, + SendVRTouchpadEvents = 7, + ShowTouchPadScrollWheel = 8, + TransferOwnershipToInternalProcess = 9, + SideBySide_Parallel = 10, + SideBySide_Crossed = 11, + Panorama = 12, + StereoPanorama = 13, + SortWithNonSceneOverlays = 14, + VisibleInDashboard = 15, + MakeOverlaysInteractiveIfVisible = 16, + SendVRSmoothScrollEvents = 17, + ProtectedContent = 18, +} +public enum VRMessageOverlayResponse +{ + ButtonPress_0 = 0, + ButtonPress_1 = 1, + ButtonPress_2 = 2, + ButtonPress_3 = 3, + CouldntFindSystemOverlay = 4, + CouldntFindOrCreateClientOverlay = 5, + ApplicationQuit = 6, +} +public enum EGamepadTextInputMode +{ + k_EGamepadTextInputModeNormal = 0, + k_EGamepadTextInputModePassword = 1, + k_EGamepadTextInputModeSubmit = 2, +} +public enum EGamepadTextInputLineMode +{ + k_EGamepadTextInputLineModeSingleLine = 0, + k_EGamepadTextInputLineModeMultipleLines = 1, +} +public enum EOverlayDirection +{ + Up = 0, + Down = 1, + Left = 2, + Right = 3, + Count = 4, +} +public enum EVROverlayIntersectionMaskPrimitiveType +{ + OverlayIntersectionPrimitiveType_Rectangle = 0, + OverlayIntersectionPrimitiveType_Circle = 1, +} +public enum EVRRenderModelError +{ + None = 0, + Loading = 100, + NotSupported = 200, + InvalidArg = 300, + InvalidModel = 301, + NoShapes = 302, + MultipleShapes = 303, + TooManyVertices = 304, + MultipleTextures = 305, + BufferTooSmall = 306, + NotEnoughNormals = 307, + NotEnoughTexCoords = 308, + InvalidTexture = 400, +} +public enum EVRComponentProperty +{ + IsStatic = 1, + IsVisible = 2, + IsTouched = 4, + IsPressed = 8, + IsScrolled = 16, +} +public enum EVRNotificationType +{ + Transient = 0, + Persistent = 1, + Transient_SystemWithUserValue = 2, +} +public enum EVRNotificationStyle +{ + None = 0, + Application = 100, + Contact_Disabled = 200, + Contact_Enabled = 201, + Contact_Active = 202, +} +public enum EVRSettingsError +{ + None = 0, + IPCFailed = 1, + WriteFailed = 2, + ReadFailed = 3, + JsonParseFailed = 4, + UnsetSettingHasNoDefault = 5, +} +public enum EVRScreenshotError +{ + None = 0, + RequestFailed = 1, + IncompatibleVersion = 100, + NotFound = 101, + BufferTooSmall = 102, + ScreenshotAlreadyInProgress = 108, +} +public enum EVRSkeletalTransformSpace +{ + Model = 0, + Parent = 1, +} +public enum EVRSkeletalReferencePose +{ + BindPose = 0, + OpenHand = 1, + Fist = 2, + GripLimit = 3, +} +public enum EVRFinger +{ + Thumb = 0, + Index = 1, + Middle = 2, + Ring = 3, + Pinky = 4, + Count = 5, +} +public enum EVRFingerSplay +{ + Thumb_Index = 0, + Index_Middle = 1, + Middle_Ring = 2, + Ring_Pinky = 3, + Count = 4, +} +public enum 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, +} + +[StructLayout(LayoutKind.Explicit)] public struct VREvent_Data_t +{ + [FieldOffset(0)] public VREvent_Reserved_t reserved; + [FieldOffset(0)] public VREvent_Controller_t controller; + [FieldOffset(0)] public VREvent_Mouse_t mouse; + [FieldOffset(0)] public VREvent_Scroll_t scroll; + [FieldOffset(0)] public VREvent_Process_t process; + [FieldOffset(0)] public VREvent_Notification_t notification; + [FieldOffset(0)] public VREvent_Overlay_t overlay; + [FieldOffset(0)] public VREvent_Status_t status; + [FieldOffset(0)] public VREvent_Ipd_t ipd; + [FieldOffset(0)] public VREvent_Chaperone_t chaperone; + [FieldOffset(0)] public VREvent_PerformanceTest_t performanceTest; + [FieldOffset(0)] public VREvent_TouchPadMove_t touchPadMove; + [FieldOffset(0)] public VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset; + [FieldOffset(0)] public VREvent_Screenshot_t screenshot; + [FieldOffset(0)] public VREvent_ScreenshotProgress_t screenshotProgress; + [FieldOffset(0)] public VREvent_ApplicationLaunch_t applicationLaunch; + [FieldOffset(0)] public VREvent_EditingCameraSurface_t cameraSurface; + [FieldOffset(0)] public VREvent_MessageOverlay_t messageOverlay; + [FieldOffset(0)] public VREvent_Property_t property; + [FieldOffset(0)] public VREvent_DualAnalog_t dualAnalog; + [FieldOffset(0)] public VREvent_HapticVibration_t hapticVibration; + [FieldOffset(0)] public VREvent_WebConsole_t webConsole; + [FieldOffset(0)] public VREvent_InputBindingLoad_t inputBinding; + [FieldOffset(0)] public VREvent_SpatialAnchor_t spatialAnchor; + [FieldOffset(0)] public VREvent_InputActionManifestLoad_t actionManifest; + [FieldOffset(0)] public VREvent_ProgressUpdate_t progressUpdate; + [FieldOffset(0)] public VREvent_ShowUI_t showUi; + [FieldOffset(0)] public VREvent_ShowDevTools_t showDevTools; + [FieldOffset(0)] public VREvent_HDCPError_t hdcpError; + [FieldOffset(0)] public VREvent_Keyboard_t keyboard; // This has to be at the end due to a mono bug +} + + +[StructLayout(LayoutKind.Explicit)] public struct VROverlayIntersectionMaskPrimitive_Data_t +{ + [FieldOffset(0)] public IntersectionMaskRectangle_t m_Rectangle; + [FieldOffset(0)] public IntersectionMaskCircle_t m_Circle; +} + +[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix34_t +{ + public float m0; //float[3][4] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + public float m9; + public float m10; + public float m11; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix33_t +{ + public float m0; //float[3][3] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdMatrix44_t +{ + public float m0; //float[4][4] + public float m1; + public float m2; + public float m3; + public float m4; + public float m5; + public float m6; + public float m7; + public float m8; + public float m9; + public float m10; + public float m11; + public float m12; + public float m13; + public float m14; + public float m15; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdVector3_t +{ + public float v0; //float[3] + public float v1; + public float v2; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdVector4_t +{ + public float v0; //float[4] + public float v1; + public float v2; + public float v3; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdVector3d_t +{ + public double v0; //double[3] + public double v1; + public double v2; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdVector2_t +{ + public float v0; //float[2] + public float v1; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdQuaternion_t +{ + public double w; + public double x; + public double y; + public double z; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdQuaternionf_t +{ + public float w; + public float x; + public float y; + public float z; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdColor_t +{ + public float r; + public float g; + public float b; + public float a; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdQuad_t +{ + public HmdVector3_t vCorners0; //HmdVector3_t[4] + public HmdVector3_t vCorners1; + public HmdVector3_t vCorners2; + public HmdVector3_t vCorners3; +} +[StructLayout(LayoutKind.Sequential)] public struct HmdRect2_t +{ + public HmdVector2_t vTopLeft; + public HmdVector2_t vBottomRight; +} +[StructLayout(LayoutKind.Sequential)] public struct DistortionCoordinates_t +{ + public float rfRed0; //float[2] + public float rfRed1; + public float rfGreen0; //float[2] + public float rfGreen1; + public float rfBlue0; //float[2] + public float rfBlue1; +} +[StructLayout(LayoutKind.Sequential)] public struct Texture_t +{ + public IntPtr handle; // void * + public ETextureType eType; + public EColorSpace eColorSpace; +} +[StructLayout(LayoutKind.Sequential)] public struct TrackedDevicePose_t +{ + public HmdMatrix34_t mDeviceToAbsoluteTracking; + public HmdVector3_t vVelocity; + public HmdVector3_t vAngularVelocity; + public ETrackingResult eTrackingResult; + [MarshalAs(UnmanagedType.I1)] + public bool bPoseIsValid; + [MarshalAs(UnmanagedType.I1)] + public bool bDeviceIsConnected; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureBounds_t +{ + public float uMin; + public float vMin; + public float uMax; + public float vMax; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithPose_t +{ + public HmdMatrix34_t mDeviceToAbsoluteTracking; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureDepthInfo_t +{ + public IntPtr handle; // void * + public HmdMatrix44_t mProjection; + public HmdVector2_t vRange; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithDepth_t +{ + public VRTextureDepthInfo_t depth; +} +[StructLayout(LayoutKind.Sequential)] public struct VRTextureWithPoseAndDepth_t +{ + public VRTextureDepthInfo_t depth; +} +[StructLayout(LayoutKind.Sequential)] public struct VRVulkanTextureData_t +{ + public ulong m_nImage; + public IntPtr m_pDevice; // struct VkDevice_T * + public IntPtr m_pPhysicalDevice; // struct VkPhysicalDevice_T * + public IntPtr m_pInstance; // struct VkInstance_T * + public IntPtr m_pQueue; // struct VkQueue_T * + public uint m_nQueueFamilyIndex; + public uint m_nWidth; + public uint m_nHeight; + public uint m_nFormat; + public uint m_nSampleCount; +} +[StructLayout(LayoutKind.Sequential)] public struct D3D12TextureData_t +{ + public IntPtr m_pResource; // struct ID3D12Resource * + public IntPtr m_pCommandQueue; // struct ID3D12CommandQueue * + public uint m_nNodeMask; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Controller_t +{ + public uint button; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Mouse_t +{ + public float x; + public float y; + public uint button; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Scroll_t +{ + public float xdelta; + public float ydelta; + public uint unused; + public float viewportscale; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_TouchPadMove_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bFingerDown; + public float flSecondsFingerDown; + public float fValueXFirst; + public float fValueYFirst; + public float fValueXRaw; + public float fValueYRaw; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Notification_t +{ + public ulong ulUserValue; + public uint notificationId; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Process_t +{ + public uint pid; + public uint oldPid; + [MarshalAs(UnmanagedType.I1)] + public bool bForced; + [MarshalAs(UnmanagedType.I1)] + public bool bConnectionLost; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Overlay_t +{ + public ulong overlayHandle; + public ulong devicePath; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Status_t +{ + public uint statusState; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Keyboard_t +{ + public byte cNewInput0,cNewInput1,cNewInput2,cNewInput3,cNewInput4,cNewInput5,cNewInput6,cNewInput7; + public string cNewInput + { + get + { + return new string(new char[] { + (char)cNewInput0, + (char)cNewInput1, + (char)cNewInput2, + (char)cNewInput3, + (char)cNewInput4, + (char)cNewInput5, + (char)cNewInput6, + (char)cNewInput7 + }).TrimEnd('\0'); + } + } + public ulong uUserValue; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Ipd_t +{ + public float ipdMeters; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Chaperone_t +{ + public ulong m_nPreviousUniverse; + public ulong m_nCurrentUniverse; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Reserved_t +{ + public ulong reserved0; + public ulong reserved1; + public ulong reserved2; + public ulong reserved3; + public ulong reserved4; + public ulong reserved5; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_PerformanceTest_t +{ + public uint m_nFidelityLevel; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_SeatedZeroPoseReset_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bResetBySystemMenu; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Screenshot_t +{ + public uint handle; + public uint type; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ScreenshotProgress_t +{ + public float progress; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ApplicationLaunch_t +{ + public uint pid; + public uint unArgsHandle; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_EditingCameraSurface_t +{ + public ulong overlayHandle; + public uint nVisualMode; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_MessageOverlay_t +{ + public uint unVRMessageOverlayResponse; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_Property_t +{ + public ulong container; + public ETrackedDeviceProperty prop; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_DualAnalog_t +{ + public float x; + public float y; + public float transformedX; + public float transformedY; + public EDualAnalogWhich which; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_HapticVibration_t +{ + public ulong containerHandle; + public ulong componentHandle; + public float fDurationSeconds; + public float fFrequency; + public float fAmplitude; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_WebConsole_t +{ + public ulong webConsoleHandle; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_InputBindingLoad_t +{ + public ulong ulAppContainer; + public ulong pathMessage; + public ulong pathUrl; + public ulong pathControllerType; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_InputActionManifestLoad_t +{ + public ulong pathAppKey; + public ulong pathMessage; + public ulong pathMessageParam; + public ulong pathManifestPath; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_SpatialAnchor_t +{ + public uint unHandle; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ProgressUpdate_t +{ + public ulong ulApplicationPropertyContainer; + public ulong pathDevice; + public ulong pathInputSource; + public ulong pathProgressAction; + public ulong pathIcon; + public float fProgress; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ShowUI_t +{ + public EShowUIType eType; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_ShowDevTools_t +{ + public int nBrowserIdentifier; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_HDCPError_t +{ + public EHDCPError eCode; +} +[StructLayout(LayoutKind.Sequential)] public struct VREvent_t +{ + public uint eventType; + public uint trackedDeviceIndex; + public float eventAgeSeconds; + public VREvent_Data_t data; +} +// This structure is for backwards binary compatibility on Linux and OSX only +[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct VREvent_t_Packed +{ + public uint eventType; + public uint trackedDeviceIndex; + public float eventAgeSeconds; + public VREvent_Data_t data; + public VREvent_t_Packed(VREvent_t unpacked) + { + this.eventType = unpacked.eventType; + this.trackedDeviceIndex = unpacked.trackedDeviceIndex; + this.eventAgeSeconds = unpacked.eventAgeSeconds; + this.data = unpacked.data; + } + public void Unpack(ref VREvent_t unpacked) + { + unpacked.eventType = this.eventType; + unpacked.trackedDeviceIndex = this.trackedDeviceIndex; + unpacked.eventAgeSeconds = this.eventAgeSeconds; + unpacked.data = this.data; + } +} +[StructLayout(LayoutKind.Sequential)] public struct HiddenAreaMesh_t +{ + public IntPtr pVertexData; // const struct vr::HmdVector2_t * + public uint unTriangleCount; +} +[StructLayout(LayoutKind.Sequential)] public struct VRControllerAxis_t +{ + public float x; + public float y; +} +[StructLayout(LayoutKind.Sequential)] public struct VRControllerState_t +{ + public uint unPacketNum; + public ulong ulButtonPressed; + public ulong ulButtonTouched; + public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5] + public VRControllerAxis_t rAxis1; + public VRControllerAxis_t rAxis2; + public VRControllerAxis_t rAxis3; + public VRControllerAxis_t rAxis4; +} +// This structure is for backwards binary compatibility on Linux and OSX only +[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct VRControllerState_t_Packed +{ + public uint unPacketNum; + public ulong ulButtonPressed; + public ulong ulButtonTouched; + public VRControllerAxis_t rAxis0; //VRControllerAxis_t[5] + public VRControllerAxis_t rAxis1; + public VRControllerAxis_t rAxis2; + public VRControllerAxis_t rAxis3; + public VRControllerAxis_t rAxis4; + public VRControllerState_t_Packed(VRControllerState_t unpacked) + { + this.unPacketNum = unpacked.unPacketNum; + this.ulButtonPressed = unpacked.ulButtonPressed; + this.ulButtonTouched = unpacked.ulButtonTouched; + this.rAxis0 = unpacked.rAxis0; + this.rAxis1 = unpacked.rAxis1; + this.rAxis2 = unpacked.rAxis2; + this.rAxis3 = unpacked.rAxis3; + this.rAxis4 = unpacked.rAxis4; + } + public void Unpack(ref VRControllerState_t unpacked) + { + unpacked.unPacketNum = this.unPacketNum; + unpacked.ulButtonPressed = this.ulButtonPressed; + unpacked.ulButtonTouched = this.ulButtonTouched; + unpacked.rAxis0 = this.rAxis0; + unpacked.rAxis1 = this.rAxis1; + unpacked.rAxis2 = this.rAxis2; + unpacked.rAxis3 = this.rAxis3; + unpacked.rAxis4 = this.rAxis4; + } +} +[StructLayout(LayoutKind.Sequential)] public struct Compositor_OverlaySettings +{ + public uint size; + [MarshalAs(UnmanagedType.I1)] + public bool curved; + [MarshalAs(UnmanagedType.I1)] + public bool antialias; + public float scale; + public float distance; + public float alpha; + public float uOffset; + public float vOffset; + public float uScale; + public float vScale; + public float gridDivs; + public float gridWidth; + public float gridScale; + public HmdMatrix44_t transform; +} +[StructLayout(LayoutKind.Sequential)] public struct VRBoneTransform_t +{ + public HmdVector4_t position; + public HmdQuaternionf_t orientation; +} +[StructLayout(LayoutKind.Sequential)] public struct CameraVideoStreamFrameHeader_t +{ + public EVRTrackedCameraFrameType eFrameType; + public uint nWidth; + public uint nHeight; + public uint nBytesPerPixel; + public uint nFrameSequence; + public TrackedDevicePose_t standingTrackedDevicePose; + public ulong ulFrameExposureTime; +} +[StructLayout(LayoutKind.Sequential)] public struct 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 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 VROverlayIntersectionParams_t +{ + public HmdVector3_t vSource; + public HmdVector3_t vDirection; + public ETrackingUniverseOrigin eOrigin; +} +[StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionResults_t +{ + public HmdVector3_t vPoint; + public HmdVector3_t vNormal; + public HmdVector2_t vUVs; + public float fDistance; +} +[StructLayout(LayoutKind.Sequential)] public struct IntersectionMaskRectangle_t +{ + public float m_flTopLeftX; + public float m_flTopLeftY; + public float m_flWidth; + public float m_flHeight; +} +[StructLayout(LayoutKind.Sequential)] public struct IntersectionMaskCircle_t +{ + public float m_flCenterX; + public float m_flCenterY; + public float m_flRadius; +} +[StructLayout(LayoutKind.Sequential)] public struct VROverlayIntersectionMaskPrimitive_t +{ + public EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType; + public VROverlayIntersectionMaskPrimitive_Data_t m_Primitive; +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_ComponentState_t +{ + public HmdMatrix34_t mTrackingToComponentRenderModel; + public HmdMatrix34_t mTrackingToComponentLocal; + public uint uProperties; +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_Vertex_t +{ + public HmdVector3_t vPosition; + public HmdVector3_t vNormal; + public float rfTextureCoord0; //float[2] + public float rfTextureCoord1; +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_TextureMap_t +{ + public ushort unWidth; + public ushort unHeight; + public IntPtr rubTextureMapData; // const uint8_t * +} +// This structure is for backwards binary compatibility on Linux and OSX only +[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct RenderModel_TextureMap_t_Packed +{ + public ushort unWidth; + public ushort unHeight; + public IntPtr rubTextureMapData; // const uint8_t * + public RenderModel_TextureMap_t_Packed(RenderModel_TextureMap_t unpacked) + { + this.unWidth = unpacked.unWidth; + this.unHeight = unpacked.unHeight; + this.rubTextureMapData = unpacked.rubTextureMapData; + } + public void Unpack(ref RenderModel_TextureMap_t unpacked) + { + unpacked.unWidth = this.unWidth; + unpacked.unHeight = this.unHeight; + unpacked.rubTextureMapData = this.rubTextureMapData; + } +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_t +{ + public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t * + public uint unVertexCount; + public IntPtr rIndexData; // const uint16_t * + public uint unTriangleCount; + public int diffuseTextureId; +} +// This structure is for backwards binary compatibility on Linux and OSX only +[StructLayout(LayoutKind.Sequential, Pack = 4)] public struct RenderModel_t_Packed +{ + public IntPtr rVertexData; // const struct vr::RenderModel_Vertex_t * + public uint unVertexCount; + public IntPtr rIndexData; // const uint16_t * + public uint unTriangleCount; + public int diffuseTextureId; + public RenderModel_t_Packed(RenderModel_t unpacked) + { + this.rVertexData = unpacked.rVertexData; + this.unVertexCount = unpacked.unVertexCount; + this.rIndexData = unpacked.rIndexData; + this.unTriangleCount = unpacked.unTriangleCount; + this.diffuseTextureId = unpacked.diffuseTextureId; + } + public void Unpack(ref RenderModel_t unpacked) + { + unpacked.rVertexData = this.rVertexData; + unpacked.unVertexCount = this.unVertexCount; + unpacked.rIndexData = this.rIndexData; + unpacked.unTriangleCount = this.unTriangleCount; + unpacked.diffuseTextureId = this.diffuseTextureId; + } +} +[StructLayout(LayoutKind.Sequential)] public struct RenderModel_ControllerMode_State_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bScrollWheelVisible; +} +[StructLayout(LayoutKind.Sequential)] public struct NotificationBitmap_t +{ + public IntPtr m_pImageData; // void * + public int m_nWidth; + public int m_nHeight; + public int m_nBytesPerPixel; +} +[StructLayout(LayoutKind.Sequential)] public struct CVRSettingHelper +{ + public IntPtr m_pSettings; // class vr::IVRSettings * +} +[StructLayout(LayoutKind.Sequential)] public struct InputAnalogActionData_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + public float x; + public float y; + public float z; + public float deltaX; + public float deltaY; + public float deltaZ; + public float fUpdateTime; +} +[StructLayout(LayoutKind.Sequential)] public struct InputDigitalActionData_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + [MarshalAs(UnmanagedType.I1)] + public bool bState; + [MarshalAs(UnmanagedType.I1)] + public bool bChanged; + public float fUpdateTime; +} +[StructLayout(LayoutKind.Sequential)] public struct InputPoseActionData_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; + public TrackedDevicePose_t pose; +} +[StructLayout(LayoutKind.Sequential)] public struct InputSkeletalActionData_t +{ + [MarshalAs(UnmanagedType.I1)] + public bool bActive; + public ulong activeOrigin; +} +[StructLayout(LayoutKind.Sequential)] public struct InputOriginInfo_t +{ + public ulong devicePath; + public uint trackedDeviceIndex; + public byte rchRenderModelComponentName0,rchRenderModelComponentName1,rchRenderModelComponentName2,rchRenderModelComponentName3,rchRenderModelComponentName4,rchRenderModelComponentName5,rchRenderModelComponentName6,rchRenderModelComponentName7,rchRenderModelComponentName8,rchRenderModelComponentName9,rchRenderModelComponentName10,rchRenderModelComponentName11,rchRenderModelComponentName12,rchRenderModelComponentName13,rchRenderModelComponentName14,rchRenderModelComponentName15,rchRenderModelComponentName16,rchRenderModelComponentName17,rchRenderModelComponentName18,rchRenderModelComponentName19,rchRenderModelComponentName20,rchRenderModelComponentName21,rchRenderModelComponentName22,rchRenderModelComponentName23,rchRenderModelComponentName24,rchRenderModelComponentName25,rchRenderModelComponentName26,rchRenderModelComponentName27,rchRenderModelComponentName28,rchRenderModelComponentName29,rchRenderModelComponentName30,rchRenderModelComponentName31,rchRenderModelComponentName32,rchRenderModelComponentName33,rchRenderModelComponentName34,rchRenderModelComponentName35,rchRenderModelComponentName36,rchRenderModelComponentName37,rchRenderModelComponentName38,rchRenderModelComponentName39,rchRenderModelComponentName40,rchRenderModelComponentName41,rchRenderModelComponentName42,rchRenderModelComponentName43,rchRenderModelComponentName44,rchRenderModelComponentName45,rchRenderModelComponentName46,rchRenderModelComponentName47,rchRenderModelComponentName48,rchRenderModelComponentName49,rchRenderModelComponentName50,rchRenderModelComponentName51,rchRenderModelComponentName52,rchRenderModelComponentName53,rchRenderModelComponentName54,rchRenderModelComponentName55,rchRenderModelComponentName56,rchRenderModelComponentName57,rchRenderModelComponentName58,rchRenderModelComponentName59,rchRenderModelComponentName60,rchRenderModelComponentName61,rchRenderModelComponentName62,rchRenderModelComponentName63,rchRenderModelComponentName64,rchRenderModelComponentName65,rchRenderModelComponentName66,rchRenderModelComponentName67,rchRenderModelComponentName68,rchRenderModelComponentName69,rchRenderModelComponentName70,rchRenderModelComponentName71,rchRenderModelComponentName72,rchRenderModelComponentName73,rchRenderModelComponentName74,rchRenderModelComponentName75,rchRenderModelComponentName76,rchRenderModelComponentName77,rchRenderModelComponentName78,rchRenderModelComponentName79,rchRenderModelComponentName80,rchRenderModelComponentName81,rchRenderModelComponentName82,rchRenderModelComponentName83,rchRenderModelComponentName84,rchRenderModelComponentName85,rchRenderModelComponentName86,rchRenderModelComponentName87,rchRenderModelComponentName88,rchRenderModelComponentName89,rchRenderModelComponentName90,rchRenderModelComponentName91,rchRenderModelComponentName92,rchRenderModelComponentName93,rchRenderModelComponentName94,rchRenderModelComponentName95,rchRenderModelComponentName96,rchRenderModelComponentName97,rchRenderModelComponentName98,rchRenderModelComponentName99,rchRenderModelComponentName100,rchRenderModelComponentName101,rchRenderModelComponentName102,rchRenderModelComponentName103,rchRenderModelComponentName104,rchRenderModelComponentName105,rchRenderModelComponentName106,rchRenderModelComponentName107,rchRenderModelComponentName108,rchRenderModelComponentName109,rchRenderModelComponentName110,rchRenderModelComponentName111,rchRenderModelComponentName112,rchRenderModelComponentName113,rchRenderModelComponentName114,rchRenderModelComponentName115,rchRenderModelComponentName116,rchRenderModelComponentName117,rchRenderModelComponentName118,rchRenderModelComponentName119,rchRenderModelComponentName120,rchRenderModelComponentName121,rchRenderModelComponentName122,rchRenderModelComponentName123,rchRenderModelComponentName124,rchRenderModelComponentName125,rchRenderModelComponentName126,rchRenderModelComponentName127; + public string rchRenderModelComponentName + { + get + { + return new string(new char[] { + (char)rchRenderModelComponentName0, + (char)rchRenderModelComponentName1, + (char)rchRenderModelComponentName2, + (char)rchRenderModelComponentName3, + (char)rchRenderModelComponentName4, + (char)rchRenderModelComponentName5, + (char)rchRenderModelComponentName6, + (char)rchRenderModelComponentName7, + (char)rchRenderModelComponentName8, + (char)rchRenderModelComponentName9, + (char)rchRenderModelComponentName10, + (char)rchRenderModelComponentName11, + (char)rchRenderModelComponentName12, + (char)rchRenderModelComponentName13, + (char)rchRenderModelComponentName14, + (char)rchRenderModelComponentName15, + (char)rchRenderModelComponentName16, + (char)rchRenderModelComponentName17, + (char)rchRenderModelComponentName18, + (char)rchRenderModelComponentName19, + (char)rchRenderModelComponentName20, + (char)rchRenderModelComponentName21, + (char)rchRenderModelComponentName22, + (char)rchRenderModelComponentName23, + (char)rchRenderModelComponentName24, + (char)rchRenderModelComponentName25, + (char)rchRenderModelComponentName26, + (char)rchRenderModelComponentName27, + (char)rchRenderModelComponentName28, + (char)rchRenderModelComponentName29, + (char)rchRenderModelComponentName30, + (char)rchRenderModelComponentName31, + (char)rchRenderModelComponentName32, + (char)rchRenderModelComponentName33, + (char)rchRenderModelComponentName34, + (char)rchRenderModelComponentName35, + (char)rchRenderModelComponentName36, + (char)rchRenderModelComponentName37, + (char)rchRenderModelComponentName38, + (char)rchRenderModelComponentName39, + (char)rchRenderModelComponentName40, + (char)rchRenderModelComponentName41, + (char)rchRenderModelComponentName42, + (char)rchRenderModelComponentName43, + (char)rchRenderModelComponentName44, + (char)rchRenderModelComponentName45, + (char)rchRenderModelComponentName46, + (char)rchRenderModelComponentName47, + (char)rchRenderModelComponentName48, + (char)rchRenderModelComponentName49, + (char)rchRenderModelComponentName50, + (char)rchRenderModelComponentName51, + (char)rchRenderModelComponentName52, + (char)rchRenderModelComponentName53, + (char)rchRenderModelComponentName54, + (char)rchRenderModelComponentName55, + (char)rchRenderModelComponentName56, + (char)rchRenderModelComponentName57, + (char)rchRenderModelComponentName58, + (char)rchRenderModelComponentName59, + (char)rchRenderModelComponentName60, + (char)rchRenderModelComponentName61, + (char)rchRenderModelComponentName62, + (char)rchRenderModelComponentName63, + (char)rchRenderModelComponentName64, + (char)rchRenderModelComponentName65, + (char)rchRenderModelComponentName66, + (char)rchRenderModelComponentName67, + (char)rchRenderModelComponentName68, + (char)rchRenderModelComponentName69, + (char)rchRenderModelComponentName70, + (char)rchRenderModelComponentName71, + (char)rchRenderModelComponentName72, + (char)rchRenderModelComponentName73, + (char)rchRenderModelComponentName74, + (char)rchRenderModelComponentName75, + (char)rchRenderModelComponentName76, + (char)rchRenderModelComponentName77, + (char)rchRenderModelComponentName78, + (char)rchRenderModelComponentName79, + (char)rchRenderModelComponentName80, + (char)rchRenderModelComponentName81, + (char)rchRenderModelComponentName82, + (char)rchRenderModelComponentName83, + (char)rchRenderModelComponentName84, + (char)rchRenderModelComponentName85, + (char)rchRenderModelComponentName86, + (char)rchRenderModelComponentName87, + (char)rchRenderModelComponentName88, + (char)rchRenderModelComponentName89, + (char)rchRenderModelComponentName90, + (char)rchRenderModelComponentName91, + (char)rchRenderModelComponentName92, + (char)rchRenderModelComponentName93, + (char)rchRenderModelComponentName94, + (char)rchRenderModelComponentName95, + (char)rchRenderModelComponentName96, + (char)rchRenderModelComponentName97, + (char)rchRenderModelComponentName98, + (char)rchRenderModelComponentName99, + (char)rchRenderModelComponentName100, + (char)rchRenderModelComponentName101, + (char)rchRenderModelComponentName102, + (char)rchRenderModelComponentName103, + (char)rchRenderModelComponentName104, + (char)rchRenderModelComponentName105, + (char)rchRenderModelComponentName106, + (char)rchRenderModelComponentName107, + (char)rchRenderModelComponentName108, + (char)rchRenderModelComponentName109, + (char)rchRenderModelComponentName110, + (char)rchRenderModelComponentName111, + (char)rchRenderModelComponentName112, + (char)rchRenderModelComponentName113, + (char)rchRenderModelComponentName114, + (char)rchRenderModelComponentName115, + (char)rchRenderModelComponentName116, + (char)rchRenderModelComponentName117, + (char)rchRenderModelComponentName118, + (char)rchRenderModelComponentName119, + (char)rchRenderModelComponentName120, + (char)rchRenderModelComponentName121, + (char)rchRenderModelComponentName122, + (char)rchRenderModelComponentName123, + (char)rchRenderModelComponentName124, + (char)rchRenderModelComponentName125, + (char)rchRenderModelComponentName126, + (char)rchRenderModelComponentName127 + }).TrimEnd('\0'); + } + } +} +[StructLayout(LayoutKind.Sequential)] public struct 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'); + } + } +} +[StructLayout(LayoutKind.Sequential)] public struct VRActiveActionSet_t +{ + public ulong ulActionSet; + public ulong ulRestrictedToDevice; + public ulong ulSecondaryActionSet; + public uint unPadding; + public int nPriority; +} +[StructLayout(LayoutKind.Sequential)] public struct VRSkeletalSummaryData_t +{ + public float flFingerCurl0; //float[5] + public float flFingerCurl1; + public float flFingerCurl2; + public float flFingerCurl3; + public float flFingerCurl4; + public float flFingerSplay0; //float[4] + public float flFingerSplay1; + public float flFingerSplay2; + public float flFingerSplay3; +} +[StructLayout(LayoutKind.Sequential)] public struct SpatialAnchorPose_t +{ + public HmdMatrix34_t mAnchorToAbsoluteTracking; +} +[StructLayout(LayoutKind.Sequential)] public struct COpenVRContext +{ + public IntPtr m_pVRSystem; // class vr::IVRSystem * + public IntPtr m_pVRChaperone; // class vr::IVRChaperone * + public IntPtr m_pVRChaperoneSetup; // class vr::IVRChaperoneSetup * + public IntPtr m_pVRCompositor; // class vr::IVRCompositor * + public IntPtr m_pVROverlay; // class vr::IVROverlay * + public IntPtr m_pVRResources; // class vr::IVRResources * + public IntPtr m_pVRRenderModels; // class vr::IVRRenderModels * + public IntPtr m_pVRExtendedDisplay; // class vr::IVRExtendedDisplay * + public IntPtr m_pVRSettings; // class vr::IVRSettings * + public IntPtr m_pVRApplications; // class vr::IVRApplications * + public IntPtr m_pVRTrackedCamera; // class vr::IVRTrackedCamera * + public IntPtr m_pVRScreenshots; // class vr::IVRScreenshots * + public IntPtr m_pVRDriverManager; // class vr::IVRDriverManager * + public IntPtr m_pVRInput; // class vr::IVRInput * + public IntPtr m_pVRIOBuffer; // class vr::IVRIOBuffer * + public IntPtr m_pVRSpatialAnchors; // class vr::IVRSpatialAnchors * + public IntPtr m_pVRDebug; // class vr::IVRDebug * + public IntPtr m_pVRNotifications; // class vr::IVRNotifications * +} + +public class OpenVR +{ + + public static uint InitInternal(ref EVRInitError peError, EVRApplicationType eApplicationType) + { + return OpenVRInterop.InitInternal(ref peError, eApplicationType); + } + + public static uint InitInternal2(ref EVRInitError peError, EVRApplicationType eApplicationType, string pchStartupInfo) + { + return OpenVRInterop.InitInternal2(ref peError, eApplicationType, pchStartupInfo); + } + + public static void ShutdownInternal() + { + OpenVRInterop.ShutdownInternal(); + } + + public static bool IsHmdPresent() + { + return OpenVRInterop.IsHmdPresent(); + } + + public static bool IsRuntimeInstalled() + { + return OpenVRInterop.IsRuntimeInstalled(); + } + + public static string RuntimePath() + { + return OpenVRInterop.RuntimePath(); + } + + public static string GetStringForHmdError(EVRInitError error) + { + return Marshal.PtrToStringAnsi(OpenVRInterop.GetStringForHmdError(error)); + } + + public static IntPtr GetGenericInterface(string pchInterfaceVersion, ref EVRInitError peError) + { + return OpenVRInterop.GetGenericInterface(pchInterfaceVersion, ref peError); + } + + public static bool IsInterfaceVersionValid(string pchInterfaceVersion) + { + return OpenVRInterop.IsInterfaceVersionValid(pchInterfaceVersion); + } + + public static uint GetInitToken() + { + return OpenVRInterop.GetInitToken(); + } + + public const uint k_nDriverNone = 4294967295; + public const uint k_unMaxDriverDebugResponseSize = 32768; + public const uint k_unTrackedDeviceIndex_Hmd = 0; + public const uint k_unMaxTrackedDeviceCount = 64; + public const uint k_unTrackedDeviceIndexOther = 4294967294; + public const uint k_unTrackedDeviceIndexInvalid = 4294967295; + public const ulong k_ulInvalidPropertyContainer = 0; + public const uint k_unInvalidPropertyTag = 0; + public const ulong k_ulInvalidDriverHandle = 0; + public const uint k_unFloatPropertyTag = 1; + public const uint k_unInt32PropertyTag = 2; + public const uint k_unUint64PropertyTag = 3; + public const uint k_unBoolPropertyTag = 4; + public const uint k_unStringPropertyTag = 5; + public const uint k_unHmdMatrix34PropertyTag = 20; + public const uint k_unHmdMatrix44PropertyTag = 21; + public const uint k_unHmdVector3PropertyTag = 22; + public const uint k_unHmdVector4PropertyTag = 23; + public const uint k_unHmdVector2PropertyTag = 24; + public const uint k_unHmdQuadPropertyTag = 25; + public const uint k_unHiddenAreaPropertyTag = 30; + public const uint k_unPathHandleInfoTag = 31; + public const uint k_unActionPropertyTag = 32; + public const uint k_unInputValuePropertyTag = 33; + public const uint k_unWildcardPropertyTag = 34; + public const uint k_unHapticVibrationPropertyTag = 35; + public const uint k_unSkeletonPropertyTag = 36; + public const uint k_unSpatialAnchorPosePropertyTag = 40; + public const uint k_unJsonPropertyTag = 41; + public const uint k_unActiveActionSetPropertyTag = 42; + public const uint k_unOpenVRInternalReserved_Start = 1000; + public const uint k_unOpenVRInternalReserved_End = 10000; + public const uint k_unMaxPropertyStringSize = 32768; + public const ulong k_ulInvalidActionHandle = 0; + public const ulong k_ulInvalidActionSetHandle = 0; + public const ulong k_ulInvalidInputValueHandle = 0; + public const uint k_unControllerStateAxisCount = 5; + public const ulong k_ulOverlayHandleInvalid = 0; + public const uint k_unMaxDistortionFunctionParameters = 8; + public const uint k_unScreenshotHandleInvalid = 0; + public const string IVRSystem_Version = "IVRSystem_020"; + public const string IVRExtendedDisplay_Version = "IVRExtendedDisplay_001"; + public const string IVRTrackedCamera_Version = "IVRTrackedCamera_005"; + public const uint k_unMaxApplicationKeyLength = 128; + public const string k_pch_MimeType_HomeApp = "vr/home"; + public const string k_pch_MimeType_GameTheater = "vr/game_theater"; + public const string IVRApplications_Version = "IVRApplications_006"; + public const string IVRChaperone_Version = "IVRChaperone_003"; + public const string IVRChaperoneSetup_Version = "IVRChaperoneSetup_006"; + public const string IVRCompositor_Version = "IVRCompositor_022"; + public const uint k_unVROverlayMaxKeyLength = 128; + public const uint k_unVROverlayMaxNameLength = 128; + public const uint k_unMaxOverlayCount = 64; + public const uint k_unMaxOverlayIntersectionMaskPrimitivesCount = 32; + public const string IVROverlay_Version = "IVROverlay_019"; + public const string k_pch_Controller_Component_GDC2015 = "gdc2015"; + public const string k_pch_Controller_Component_Base = "base"; + public const string k_pch_Controller_Component_Tip = "tip"; + public const string k_pch_Controller_Component_HandGrip = "handgrip"; + public const string k_pch_Controller_Component_Status = "status"; + public const string IVRRenderModels_Version = "IVRRenderModels_006"; + public const uint k_unNotificationTextMaxSize = 256; + public const string IVRNotifications_Version = "IVRNotifications_002"; + public const uint k_unMaxSettingsKeyLength = 128; + public const string IVRSettings_Version = "IVRSettings_002"; + public const string k_pch_SteamVR_Section = "steamvr"; + public const string k_pch_SteamVR_RequireHmd_String = "requireHmd"; + public const string k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver"; + public const string k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd"; + public const string k_pch_SteamVR_DisplayDebug_Bool = "displayDebug"; + public const string k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe"; + public const string k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX"; + public const string k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY"; + public const string k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps"; + public const string k_pch_SteamVR_LogLevel_Int32 = "loglevel"; + public const string k_pch_SteamVR_IPD_Float = "ipd"; + public const string k_pch_SteamVR_Background_String = "background"; + public const string k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection"; + public const string k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight"; + public const string k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius"; + public const string k_pch_SteamVR_GridColor_String = "gridColor"; + public const string k_pch_SteamVR_PlayAreaColor_String = "playAreaColor"; + public const string k_pch_SteamVR_ShowStage_Bool = "showStage"; + public const string k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers"; + public const string k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers"; + public const string k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees"; + public const string k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement"; + public const string k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses"; + public const string k_pch_SteamVR_SupersampleScale_Float = "supersampleScale"; + public const string k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution"; + public const string k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing"; + public const string k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride"; + public const string k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking"; + public const string k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView"; + public const string k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView"; + public const string k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry"; + public const string k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized"; + public const string k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch"; + public const string k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch"; + public const string k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch"; + public const string k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard"; + public const string k_pch_SteamVR_EnableHomeApp = "enableHomeApp"; + public const string k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec"; + public const string k_pch_SteamVR_RetailDemo_Bool = "retailDemo"; + public const string k_pch_SteamVR_IpdOffset_Float = "ipdOffset"; + public const string k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering"; + public const string k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride"; + public const string k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync"; + public const string k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode"; + public const string k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver"; + public const string k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor"; + public const string k_pch_SteamVR_DebugInput = "debugInput"; + public const string k_pch_SteamVR_DebugInputBinding = "debugInputBinding"; + public const string k_pch_SteamVR_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_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_Lighthouse_NewPairing_Bool = "newPairing"; + public const string k_pch_Null_Section = "driver_null"; + public const string k_pch_Null_SerialNumber_String = "serialNumber"; + public const string k_pch_Null_ModelNumber_String = "modelNumber"; + public const string k_pch_Null_WindowX_Int32 = "windowX"; + public const string k_pch_Null_WindowY_Int32 = "windowY"; + public const string k_pch_Null_WindowWidth_Int32 = "windowWidth"; + public const string k_pch_Null_WindowHeight_Int32 = "windowHeight"; + public const string k_pch_Null_RenderWidth_Int32 = "renderWidth"; + public const string k_pch_Null_RenderHeight_Int32 = "renderHeight"; + public const string k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons"; + public const string k_pch_Null_DisplayFrequency_Float = "displayFrequency"; + public const string k_pch_UserInterface_Section = "userinterface"; + public const string k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop"; + public const string k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray"; + public const string k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized"; + public const string k_pch_UserInterface_Screenshots_Bool = "screenshots"; + public const string k_pch_UserInterface_ScreenshotType_Int = "screenshotType"; + public const string k_pch_Notifications_Section = "notifications"; + public const string k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb"; + public const string k_pch_Keyboard_Section = "keyboard"; + public const string k_pch_Keyboard_TutorialCompletions = "TutorialCompletions"; + public const string k_pch_Keyboard_ScaleX = "ScaleX"; + public const string k_pch_Keyboard_ScaleY = "ScaleY"; + public const string k_pch_Keyboard_OffsetLeftX = "OffsetLeftX"; + public const string k_pch_Keyboard_OffsetRightX = "OffsetRightX"; + public const string k_pch_Keyboard_OffsetY = "OffsetY"; + public const string k_pch_Keyboard_Smoothing = "Smoothing"; + public const string k_pch_Perf_Section = "perfcheck"; + public const string k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD"; + public const string k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore"; + public const string k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit"; + public const string k_pch_Perf_TestData_Float = "perfTestData"; + public const string k_pch_Perf_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_ColorGammaR_Int32 = "CollisionBoundsColorGammaR"; + public const string k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG"; + public const string k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB"; + public const string k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA"; + public const string k_pch_Camera_Section = "camera"; + public const string k_pch_Camera_EnableCamera_Bool = "enableCamera"; + public const string k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard"; + public const string k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds"; + public const string k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView"; + public const string k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR"; + public const string k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG"; + public const string k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB"; + public const string k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA"; + public const string k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength"; + public const string k_pch_Camera_RoomViewMode_Int32 = "cameraRoomViewMode"; + public const string k_pch_audio_Section = "audio"; + public const string k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice"; + public const string k_pch_audio_OnRecordDevice_String = "onRecordDevice"; + public const string k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice"; + public const string k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice"; + public const string k_pch_audio_OffRecordDevice_String = "offRecordDevice"; + public const string k_pch_audio_VIVEHDMIGain = "viveHDMIGain"; + public const string k_pch_Power_Section = "power"; + public const string k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit"; + public const string k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout"; + public const string k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout"; + public const string k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout"; + public const string k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress"; + public const string k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby"; + public const string k_pch_Dashboard_Section = "dashboard"; + public const string k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard"; + public const string k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode"; + public const string k_pch_Dashboard_UseWebDashboard = "useWebDashboard"; + public const string k_pch_Dashboard_UseWebSettings = "useWebSettings"; + public const string k_pch_Dashboard_UseWebIPD = "useWebIPD"; + public const string k_pch_Dashboard_UseWebPowerMenu = "useWebPowerMenu"; + public const string k_pch_modelskin_Section = "modelskins"; + public const string k_pch_Driver_Enable_Bool = "enable"; + public const string k_pch_Driver_LoadPriority_Int32 = "loadPriority"; + public const string k_pch_WebInterface_Section = "WebInterface"; + public const string k_pch_WebInterface_WebEnable_Bool = "WebEnable"; + public const string k_pch_WebInterface_WebPort_String = "WebPort"; + public const string k_pch_VRWebHelper_Section = "VRWebHelper"; + public const string k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled"; + public const string k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort"; + public const string k_pch_TrackingOverride_Section = "TrackingOverrides"; + public const string k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL"; + public const string k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL"; + public const string k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave"; + public const string k_pch_Trackers_Section = "trackers"; + public const string k_pch_DesktopUI_Section = "DesktopUI"; + public const string k_pch_LastKnown_Section = "LastKnown"; + public const string k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer"; + public const string k_pch_LastKnown_HMDModel_String = "HMDModel"; + public const string k_pch_DismissedWarnings_Section = "DismissedWarnings"; + public const string 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 IVRScreenshots_Version = "IVRScreenshots_001"; + public const string IVRResources_Version = "IVRResources_001"; + public const string IVRDriverManager_Version = "IVRDriverManager_001"; + public const uint k_unMaxActionNameLength = 64; + public const uint k_unMaxActionSetNameLength = 64; + public const uint k_unMaxActionOriginCount = 16; + public const uint k_unMaxBoneNameLength = 32; + public const string IVRInput_Version = "IVRInput_007"; + 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"; + + static uint VRToken { get; set; } + + const string FnTable_Prefix = "FnTable:"; + + class COpenVRContext + { + public COpenVRContext() { Clear(); } + + public void Clear() + { + m_pVRSystem = null; + m_pVRChaperone = null; + m_pVRChaperoneSetup = null; + m_pVRCompositor = null; + m_pVROverlay = null; + m_pVRRenderModels = null; + m_pVRExtendedDisplay = null; + m_pVRSettings = null; + m_pVRApplications = null; + m_pVRScreenshots = null; + m_pVRTrackedCamera = null; + m_pVRInput = null; + m_pVRIOBuffer = null; + m_pVRSpatialAnchors = null; + m_pVRNotifications = null; + 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 CVROverlay VROverlay() + { + CheckClear(); + if (m_pVROverlay == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVROverlay_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVROverlay = new CVROverlay(pInterface); + } + return m_pVROverlay; + } + + public CVRRenderModels VRRenderModels() + { + CheckClear(); + if (m_pVRRenderModels == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRRenderModels_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRRenderModels = new CVRRenderModels(pInterface); + } + return m_pVRRenderModels; + } + + public CVRExtendedDisplay VRExtendedDisplay() + { + CheckClear(); + if (m_pVRExtendedDisplay == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRExtendedDisplay_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRExtendedDisplay = new CVRExtendedDisplay(pInterface); + } + return m_pVRExtendedDisplay; + } + + public CVRSettings VRSettings() + { + CheckClear(); + if (m_pVRSettings == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRSettings_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSettings = new CVRSettings(pInterface); + } + return m_pVRSettings; + } + + public CVRApplications VRApplications() + { + CheckClear(); + if (m_pVRApplications == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRApplications_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRApplications = new CVRApplications(pInterface); + } + return m_pVRApplications; + } + + public CVRScreenshots VRScreenshots() + { + CheckClear(); + if (m_pVRScreenshots == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRScreenshots_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRScreenshots = new CVRScreenshots(pInterface); + } + return m_pVRScreenshots; + } + + public CVRTrackedCamera VRTrackedCamera() + { + CheckClear(); + if (m_pVRTrackedCamera == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRTrackedCamera_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRTrackedCamera = new CVRTrackedCamera(pInterface); + } + return m_pVRTrackedCamera; + } + + public CVRInput VRInput() + { + CheckClear(); + if (m_pVRInput == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix+IVRInput_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRInput = new CVRInput(pInterface); + } + return m_pVRInput; + } + + public CVRIOBuffer VRIOBuffer() + { + CheckClear(); + if (m_pVRIOBuffer == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRIOBuffer_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRIOBuffer = new CVRIOBuffer(pInterface); + } + return m_pVRIOBuffer; + } + + public CVRSpatialAnchors VRSpatialAnchors() + { + CheckClear(); + if (m_pVRSpatialAnchors == null) + { + var eError = EVRInitError.None; + var pInterface = OpenVRInterop.GetGenericInterface(FnTable_Prefix + IVRSpatialAnchors_Version, ref eError); + if (pInterface != IntPtr.Zero && eError == EVRInitError.None) + m_pVRSpatialAnchors = new CVRSpatialAnchors(pInterface); + } + return m_pVRSpatialAnchors; + } + + public 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 CVROverlay m_pVROverlay; + private CVRRenderModels m_pVRRenderModels; + private CVRExtendedDisplay m_pVRExtendedDisplay; + private CVRSettings m_pVRSettings; + private CVRApplications m_pVRApplications; + private CVRScreenshots m_pVRScreenshots; + private CVRTrackedCamera m_pVRTrackedCamera; + private CVRInput m_pVRInput; + private CVRIOBuffer m_pVRIOBuffer; + private CVRSpatialAnchors m_pVRSpatialAnchors; + private CVRNotifications m_pVRNotifications; + private 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 CVROverlay Overlay { get { return OpenVRInternal_ModuleContext.VROverlay(); } } + public static CVRRenderModels RenderModels { get { return OpenVRInternal_ModuleContext.VRRenderModels(); } } + public static CVRExtendedDisplay ExtendedDisplay { get { return OpenVRInternal_ModuleContext.VRExtendedDisplay(); } } + public static CVRSettings Settings { get { return OpenVRInternal_ModuleContext.VRSettings(); } } + public static CVRApplications Applications { get { return OpenVRInternal_ModuleContext.VRApplications(); } } + public static CVRScreenshots Screenshots { get { return OpenVRInternal_ModuleContext.VRScreenshots(); } } + public static CVRTrackedCamera TrackedCamera { get { return OpenVRInternal_ModuleContext.VRTrackedCamera(); } } + public static CVRInput Input { get { return OpenVRInternal_ModuleContext.VRInput(); } } + public static CVRIOBuffer IOBuffer { get { return OpenVRInternal_ModuleContext.VRIOBuffer(); } } + public static CVRSpatialAnchors SpatialAnchors { get { return OpenVRInternal_ModuleContext.VRSpatialAnchors(); } } + public static CVRNotifications Notifications { get { return OpenVRInternal_ModuleContext.VRNotifications(); } } + public static CVRDebug Debug { get { return OpenVRInternal_ModuleContext.VRDebug(); } } + + + /** Finds the active installation of vrclient.dll and initializes it */ + public static CVRSystem Init(ref EVRInitError peError, EVRApplicationType eApplicationType = EVRApplicationType.VRApplication_Scene, string pchStartupInfo= "") + { + try + { + VRToken = InitInternal2(ref peError, eApplicationType, pchStartupInfo); + } + catch (EntryPointNotFoundException) + { + VRToken = InitInternal(ref peError, eApplicationType); + } + + OpenVRInternal_ModuleContext.Clear(); + + if (peError != EVRInitError.None) + return null; + + bool bInterfaceValid = IsInterfaceVersionValid(IVRSystem_Version); + if (!bInterfaceValid) + { + ShutdownInternal(); + peError = EVRInitError.Init_InterfaceNotFound; + return null; + } + + return OpenVR.System; + } + + /** unloads vrclient.dll. Any interface pointers from the interface are + * invalid after this point */ + public static void Shutdown() + { + ShutdownInternal(); + } + +} + + + +} + diff --git a/packages.config b/packages.config new file mode 100644 index 00000000..332a1bab --- /dev/null +++ b/packages.config @@ -0,0 +1,17 @@ + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/vrchat.ico b/vrchat.ico new file mode 100644 index 0000000000000000000000000000000000000000..b1dcb438f6a68092eb77afc489074c3d994c66a6 GIT binary patch literal 372526 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