[WebVR] Add OpenVR to the tree and to the build
authorsvillar@igalia.com <svillar@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 24 Jan 2018 15:04:34 +0000 (15:04 +0000)
committersvillar@igalia.com <svillar@igalia.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 24 Jan 2018 15:04:34 +0000 (15:04 +0000)
https://bugs.webkit.org/show_bug.cgi?id=177298

Reviewed by Žan Doberšek.

.:

* Source/CMakeLists.txt:
* Source/cmake/OptionsGTK.cmake: Enable USE_OPENVR.
* Source/cmake/OptionsWPE.cmake: Ditto.

Source/ThirdParty:

Adding the required parts of OpenVR library to the tree. This will be used as a backend for
the eventual WebVR implementation.

* openvr/CMakeLists.txt: Added.
* openvr/LICENSE: Added.
* openvr/README.md: Added.
* openvr/README.webkit: Added. Includes specifics changes made to the original library to
accommodate it to the WebKit build system.
* openvr/Toolchain-clang.cmake: Added.
* openvr/headers/openvr.h: Added.
(vr::ButtonMaskFromId):
(vr::NotificationBitmap_t::NotificationBitmap_t):
(vr::VRToken):
(vr::COpenVRContext::COpenVRContext):
(vr::COpenVRContext::CheckClear):
(vr::COpenVRContext::VRSystem):
(vr::COpenVRContext::VRChaperone):
(vr::COpenVRContext::VRChaperoneSetup):
(vr::COpenVRContext::VRCompositor):
(vr::COpenVRContext::VROverlay):
(vr::COpenVRContext::VRResources):
(vr::COpenVRContext::VRScreenshots):
(vr::COpenVRContext::VRRenderModels):
(vr::COpenVRContext::VRExtendedDisplay):
(vr::COpenVRContext::VRSettings):
(vr::COpenVRContext::VRApplications):
(vr::COpenVRContext::VRTrackedCamera):
(vr::COpenVRContext::VRDriverManager):
(vr::OpenVRInternal_ModuleContext):
(vr::VRSystem):
(vr::VRChaperone):
(vr::VRChaperoneSetup):
(vr::VRCompositor):
(vr::VROverlay):
(vr::VRScreenshots):
(vr::VRRenderModels):
(vr::VRApplications):
(vr::VRSettings):
(vr::VRResources):
(vr::VRExtendedDisplay):
(vr::VRTrackedCamera):
(vr::VRDriverManager):
(vr::COpenVRContext::Clear):
(vr::VR_Init):
(vr::VR_Shutdown):
* openvr/headers/openvr_api.cs: Added.
* openvr/headers/openvr_api.json: Added.
* openvr/headers/openvr_capi.h: Added.
* openvr/headers/openvr_driver.h: Added.
(vr::ButtonMaskFromId):
(vr::IVRDriverDirectModeComponent::CreateSwapTextureSet):
(vr::IVRDriverDirectModeComponent::DestroySwapTextureSet):
(vr::IVRDriverDirectModeComponent::DestroyAllSwapTextureSets):
(vr::IVRDriverDirectModeComponent::GetNextSwapTextureSetIndex):
(vr::IVRDriverDirectModeComponent::SubmitLayer):
(vr::IVRDriverDirectModeComponent::Present):
(vr::CVRPropertyHelpers::CVRPropertyHelpers):
(vr::CVRPropertyHelpers::TrackedDeviceToPropertyContainer):
(vr::CVRPropertyHelpers::GetProperty):
(vr::CVRPropertyHelpers::SetProperty):
(vr::CVRPropertyHelpers::GetStringProperty):
(vr::CVRPropertyHelpers::SetStringProperty):
(vr::CVRPropertyHelpers::GetPropertyHelper):
(vr::CVRPropertyHelpers::GetBoolProperty):
(vr::CVRPropertyHelpers::GetFloatProperty):
(vr::CVRPropertyHelpers::GetInt32Property):
(vr::CVRPropertyHelpers::GetUint64Property):
(vr::CVRPropertyHelpers::SetBoolProperty):
(vr::CVRPropertyHelpers::SetFloatProperty):
(vr::CVRPropertyHelpers::SetInt32Property):
(vr::CVRPropertyHelpers::SetUint64Property):
(vr::CVRPropertyHelpers::SetPropertyError):
(vr::CVRPropertyHelpers::EraseProperty):
(vr::CVRHiddenAreaHelpers::CVRHiddenAreaHelpers):
(vr::CVRHiddenAreaHelpers::GetPropertyEnum):
(vr::CVRHiddenAreaHelpers::SetHiddenArea):
(vr::CVRHiddenAreaHelpers::GetHiddenArea):
(vr::VRDriverContext):
(vr::COpenVRDriverContext::COpenVRDriverContext):
(vr::COpenVRDriverContext::VRSettings):
(vr::COpenVRDriverContext::VRPropertiesRaw):
(vr::COpenVRDriverContext::VRProperties):
(vr::COpenVRDriverContext::VRHiddenArea):
(vr::COpenVRDriverContext::VRServerDriverHost):
(vr::COpenVRDriverContext::VRWatchdogHost):
(vr::COpenVRDriverContext::VRDriverLog):
(vr::COpenVRDriverContext::VRDriverHandle):
(vr::OpenVRInternal_ModuleServerDriverContext):
(vr::VRSettings):
(vr::VRPropertiesRaw):
(vr::VRProperties):
(vr::VRHiddenArea):
(vr::VRDriverLog):
(vr::VRServerDriverHost):
(vr::VRWatchdogHost):
(vr::VRDriverHandle):
(vr::COpenVRDriverContext::Clear):
(vr::COpenVRDriverContext::InitServer):
(vr::COpenVRDriverContext::InitWatchdog):
(vr::InitServerDriverContext):
(vr::InitWatchdogDriverContext):
(vr::CleanupDriverContext):
* openvr/patches/cmake-build.patch: Added.
* openvr/src/CMakeLists.txt: Added.
* openvr/src/Info.plist: Added.
* openvr/src/README: Added.
* openvr/src/ivrclientcore.h: Added.
* openvr/src/json/json-forwards.h: Added.
* openvr/src/json/json.h: Added.
(std::swap):
* openvr/src/jsoncpp.cpp: Added.
(Json::codePointToUTF8):
(Json::isControlCharacter):
(Json::uintToString):
(Json::fixNumericLocale):
(Json::Features::Features):
(Json::Features::all):
(Json::Features::strictMode):
(Json::containsNewLine):
(Json::Reader::Reader):
(Json::Reader::parse):
(Json::Reader::readValue):
(Json::Reader::skipCommentTokens):
(Json::Reader::readToken):
(Json::Reader::skipSpaces):
(Json::Reader::match):
(Json::Reader::readComment):
(Json::normalizeEOL):
(Json::Reader::addComment):
(Json::Reader::readCStyleComment):
(Json::Reader::readCppStyleComment):
(Json::Reader::readNumber):
(Json::Reader::readString):
(Json::Reader::readObject):
(Json::Reader::readArray):
(Json::Reader::decodeNumber):
(Json::Reader::decodeDouble):
(Json::Reader::decodeString):
(Json::Reader::decodeUnicodeCodePoint):
(Json::Reader::decodeUnicodeEscapeSequence):
(Json::Reader::addError):
(Json::Reader::recoverFromError):
(Json::Reader::addErrorAndRecover):
(Json::Reader::currentValue):
(Json::Reader::getNextChar):
(Json::Reader::getLocationLineAndColumn const):
(Json::Reader::getLocationSnippet const):
(Json::Reader::getFormatedErrorMessages const):
(Json::Reader::getFormattedErrorMessages const):
(Json::Reader::getStructuredErrors const):
(Json::Reader::pushError):
(Json::Reader::good const):
(Json::OurFeatures::all):
(Json::OurReader::OurReader):
(Json::OurReader::parse):
(Json::OurReader::readValue):
(Json::OurReader::skipCommentTokens):
(Json::OurReader::readToken):
(Json::OurReader::skipSpaces):
(Json::OurReader::match):
(Json::OurReader::readComment):
(Json::OurReader::addComment):
(Json::OurReader::readCStyleComment):
(Json::OurReader::readCppStyleComment):
(Json::OurReader::readNumber):
(Json::OurReader::readString):
(Json::OurReader::readStringSingleQuote):
(Json::OurReader::readObject):
(Json::OurReader::readArray):
(Json::OurReader::decodeNumber):
(Json::OurReader::decodeDouble):
(Json::OurReader::decodeString):
(Json::OurReader::decodeUnicodeCodePoint):
(Json::OurReader::decodeUnicodeEscapeSequence):
(Json::OurReader::addError):
(Json::OurReader::recoverFromError):
(Json::OurReader::addErrorAndRecover):
(Json::OurReader::currentValue):
(Json::OurReader::getNextChar):
(Json::OurReader::getLocationLineAndColumn const):
(Json::OurReader::getFormattedErrorMessages const):
(Json::OurReader::getStructuredErrors const):
(Json::OurReader::pushError):
(Json::OurReader::good const):
(Json::OurCharReader::OurCharReader):
(Json::OurCharReader::parse):
(Json::CharReaderBuilder::CharReaderBuilder):
(Json::CharReaderBuilder::~CharReaderBuilder):
(Json::CharReaderBuilder::newCharReader const):
(Json::getValidReaderKeys):
(Json::CharReaderBuilder::validate const):
(Json::CharReaderBuilder::operator[]):
(Json::CharReaderBuilder::strictMode):
(Json::CharReaderBuilder::setDefaults):
(Json::parseFromStream):
(Json::operator>>):
(Json::ValueIteratorBase::ValueIteratorBase):
(Json::ValueIteratorBase::deref const):
(Json::ValueIteratorBase::increment):
(Json::ValueIteratorBase::decrement):
(Json::ValueIteratorBase::computeDistance const):
(Json::ValueIteratorBase::isEqual const):
(Json::ValueIteratorBase::copy):
(Json::ValueIteratorBase::key const):
(Json::ValueIteratorBase::index const):
(Json::ValueIteratorBase::name const):
(Json::ValueIteratorBase::memberName const):
(Json::ValueConstIterator::ValueConstIterator):
(Json::operator=):
(Json::ValueIterator::ValueIterator):
(Json::ValueIterator::operator=):
(Json::InRange):
(Json::integerToDouble):
(Json::duplicateStringValue):
(Json::duplicateAndPrefixStringValue):
(Json::decodePrefixedString):
(Json::releaseStringValue):
(Json::Exception::Exception):
(Json::throw):
(Json::RuntimeError::RuntimeError):
(Json::LogicError::LogicError):
(Json::throwRuntimeError):
(Json::throwLogicError):
(Json::Value::CommentInfo::CommentInfo):
(Json::Value::CommentInfo::~CommentInfo):
(Json::Value::CommentInfo::setComment):
(Json::Value::CZString::CZString):
(Json::Value::CZString::~CZString):
(Json::Value::CZString::swap):
(Json::Value::CZString::operator=):
(Json::Value::CZString::operator< const):
(Json::Value::CZString::operator== const):
(Json::Value::CZString::index const):
(Json::Value::CZString::data const):
(Json::Value::CZString::length const):
(Json::Value::CZString::isStaticString const):
(Json::Value::Value):
(Json::Value::~Value):
(Json::Value::operator=):
(Json::Value::swapPayload):
(Json::Value::swap):
(Json::Value::type const):
(Json::Value::compare const):
(Json::Value::operator< const):
(Json::Value::operator<= const):
(Json::Value::operator>= const):
(Json::Value::operator> const):
(Json::Value::operator== const):
(Json::Value::operator!= const):
(Json::Value::asCString const):
(Json::Value::getString const):
(Json::Value::asString const):
(Json::Value::asConstString const):
(Json::Value::asInt const):
(Json::Value::asUInt const):
(Json::Value::asInt64 const):
(Json::Value::asUInt64 const):
(Json::Value::asLargestInt const):
(Json::Value::asLargestUInt const):
(Json::Value::asDouble const):
(Json::Value::asFloat const):
(Json::Value::asBool const):
(Json::Value::isConvertibleTo const):
(Json::Value::size const):
(Json::Value::empty const):
(Json::Value::operator! const):
(Json::Value::clear):
(Json::Value::resize):
(Json::Value::operator[]):
(Json::Value::operator[] const):
(Json::Value::initBasic):
(Json::Value::resolveReference):
(Json::Value::get const):
(Json::Value::isValidIndex const):
(Json::Value::find const):
(Json::Value::append):
(Json::Value::removeMember):
(Json::Value::removeIndex):
(Json::Value::isMember const):
(Json::Value::getMemberNames const):
(Json::IsIntegral):
(Json::Value::isNull const):
(Json::Value::isBool const):
(Json::Value::isInt const):
(Json::Value::isUInt const):
(Json::Value::isInt64 const):
(Json::Value::isUInt64 const):
(Json::Value::isIntegral const):
(Json::Value::isDouble const):
(Json::Value::isNumeric const):
(Json::Value::isString const):
(Json::Value::isArray const):
(Json::Value::isObject const):
(Json::Value::setComment):
(Json::Value::hasComment const):
(Json::Value::getComment const):
(Json::Value::setOffsetStart):
(Json::Value::setOffsetLimit):
(Json::Value::getOffsetStart const):
(Json::Value::getOffsetLimit const):
(Json::Value::toStyledString const):
(Json::Value::begin const):
(Json::Value::end const):
(Json::Value::begin):
(Json::Value::end):
(Json::PathArgument::PathArgument):
(Json::Path::Path):
(Json::Path::makePath):
(Json::Path::addPathInArg):
(Json::Path::invalidPath):
(Json::Path::resolve const):
(Json::Path::make const):
(Json::containsControlCharacter):
(Json::containsControlCharacter0):
(Json::valueToString):
(Json::valueToQuotedString):
(Json::strnpbrk):
(Json::valueToQuotedStringN):
(Json::Writer::~Writer):
(Json::FastWriter::FastWriter):
(Json::FastWriter::enableYAMLCompatibility):
(Json::FastWriter::dropNullPlaceholders):
(Json::FastWriter::omitEndingLineFeed):
(Json::FastWriter::write):
(Json::FastWriter::writeValue):
(Json::StyledWriter::StyledWriter):
(Json::StyledWriter::write):
(Json::StyledWriter::writeValue):
(Json::StyledWriter::writeArrayValue):
(Json::StyledWriter::isMultineArray):
(Json::StyledWriter::pushValue):
(Json::StyledWriter::writeIndent):
(Json::StyledWriter::writeWithIndent):
(Json::StyledWriter::indent):
(Json::StyledWriter::unindent):
(Json::StyledWriter::writeCommentBeforeValue):
(Json::StyledWriter::writeCommentAfterValueOnSameLine):
(Json::StyledWriter::hasCommentForValue):
(Json::StyledStreamWriter::StyledStreamWriter):
(Json::StyledStreamWriter::write):
(Json::StyledStreamWriter::writeValue):
(Json::StyledStreamWriter::writeArrayValue):
(Json::StyledStreamWriter::isMultineArray):
(Json::StyledStreamWriter::pushValue):
(Json::StyledStreamWriter::writeIndent):
(Json::StyledStreamWriter::writeWithIndent):
(Json::StyledStreamWriter::indent):
(Json::StyledStreamWriter::unindent):
(Json::StyledStreamWriter::writeCommentBeforeValue):
(Json::StyledStreamWriter::writeCommentAfterValueOnSameLine):
(Json::StyledStreamWriter::hasCommentForValue):
(Json::BuiltStyledStreamWriter::BuiltStyledStreamWriter):
(Json::BuiltStyledStreamWriter::write):
(Json::BuiltStyledStreamWriter::writeValue):
(Json::BuiltStyledStreamWriter::writeArrayValue):
(Json::BuiltStyledStreamWriter::isMultineArray):
(Json::BuiltStyledStreamWriter::pushValue):
(Json::BuiltStyledStreamWriter::writeIndent):
(Json::BuiltStyledStreamWriter::writeWithIndent):
(Json::BuiltStyledStreamWriter::indent):
(Json::BuiltStyledStreamWriter::unindent):
(Json::BuiltStyledStreamWriter::writeCommentBeforeValue):
(Json::BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine):
(Json::BuiltStyledStreamWriter::hasCommentForValue):
(Json::StreamWriter::StreamWriter):
(Json::StreamWriter::~StreamWriter):
(Json::StreamWriter::Factory::~Factory):
(Json::StreamWriterBuilder::StreamWriterBuilder):
(Json::StreamWriterBuilder::~StreamWriterBuilder):
(Json::StreamWriterBuilder::newStreamWriter const):
(Json::getValidWriterKeys):
(Json::StreamWriterBuilder::validate const):
(Json::StreamWriterBuilder::operator[]):
(Json::StreamWriterBuilder::setDefaults):
(Json::writeString):
(Json::operator<<):
* openvr/src/openvr_api_public.cpp: Added.
(vr::VR_GetInitToken):
(vr::VR_InitInternal2):
(vr::VR_InitInternal):
(vr::VR_ShutdownInternal):
(vr::VR_LoadHmdSystemInternal):
(vr::VR_GetGenericInterface):
(vr::VR_IsInterfaceVersionValid):
(vr::VR_IsHmdPresent):
(vr::VR_IsRuntimeInstalled):
(vr::VR_RuntimePath):
(vr::VR_GetVRInitErrorAsSymbol):
(vr::VR_GetVRInitErrorAsEnglishDescription):
(vr::VR_GetStringForHmdError):
* openvr/src/vrcommon/dirtools_public.cpp: Added.
(BCreateDirectoryRecursive):
(BCreateDirectory):
* openvr/src/vrcommon/dirtools_public.h: Added.
* openvr/src/vrcommon/envvartools_public.cpp: Added.
(GetEnvironmentVariable):
(SetEnvironmentVariable):
* openvr/src/vrcommon/envvartools_public.h: Added.
* openvr/src/vrcommon/hmderrors_public.cpp: Added.
(GetEnglishStringForHmdError):
(GetIDForVRInitError):
* openvr/src/vrcommon/hmderrors_public.h: Added.
* openvr/src/vrcommon/pathtools_public.cpp: Added.
(Path_GetExecutablePath):
(Path_GetWorkingDirectory):
(Path_SetWorkingDirectory):
(Path_StripFilename):
(Path_StripDirectory):
(Path_StripExtension):
(Path_GetExtension):
(Path_IsAbsolute):
(Path_MakeAbsolute):
(Path_FixSlashes):
(Path_GetSlash):
(Path_Join):
(Path_RemoveTrailingSlash):
(Path_Compact):
(Path_GetThisModulePath):
(Path_IsDirectory):
(Path_IsAppBundle):
(Path_Exists):
(Path_FindParentDirectoryRecursively):
(Path_FindParentSubDirectoryRecursively):
(Path_ReadBinaryFile):
(Path_WriteBinaryFile):
(Path_ReadTextFile):
(Path_WriteStringToTextFile):
(Path_WriteStringToTextFileAtomic):
(Path_FilePathToUrl):
(Path_UrlToFilePath):
(GetUserDocumentsPath):
* openvr/src/vrcommon/pathtools_public.h: Added.
* openvr/src/vrcommon/sharedlibtools_public.cpp: Added.
(SharedLib_Load):
(SharedLib_GetFunction):
(SharedLib_Unload):
* openvr/src/vrcommon/sharedlibtools_public.h: Added.
* openvr/src/vrcommon/strtools_public.cpp: Added.
(StringHasPrefix):
(StringHasPrefixCaseSensitive):
(StringHasSuffix):
(StringHasSuffixCaseSensitive):
(UTF16to8):
(UTF8to16):
(strcpy_safe):
(StringToUpper):
(StringToLower):
(ReturnStdString):
(BufferToStdString):
(Uint64ToString):
(StringToUint64):
(cIntToHexDigit):
(iHexCharToInt):
(V_URLEncodeInternal):
(V_URLDecodeInternal):
(V_URLEncode):
(V_URLDecode):
(V_StripExtension):
* openvr/src/vrcommon/strtools_public.h: Added.
(stricmp):
(strnicmp):
(wcsncpy_s):
(strncpy_s):
(strtoull):
* openvr/src/vrcommon/vrpathregistry_public.cpp: Added.
(GetAppSettingsPath):
(CVRPathRegistry_Public::CVRPathRegistry_Public):
(CVRPathRegistry_Public::GetOpenVRConfigPath):
(CVRPathRegistry_Public::GetVRPathRegistryFilename):
(ParseStringListFromJson):
(StringListToJson):
(CVRPathRegistry_Public::ToJsonString):
(CVRPathRegistry_Public::BLoadFromFile):
(CVRPathRegistry_Public::BSaveToFile const):
(CVRPathRegistry_Public::GetRuntimePath const):
(CVRPathRegistry_Public::GetConfigPath const):
(CVRPathRegistry_Public::GetLogPath const):
(CVRPathRegistry_Public::GetPaths):
* openvr/src/vrcommon/vrpathregistry_public.h: Added.

Source/WebCore:

Added build dependencies with the OpenVR library.

* CMakeLists.txt:

Tools:

* Scripts/webkitpy/style/checker.py: Added openvr to the list of third party libraries
with reduced style checks.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@227518 268f45cc-cd09-0410-ab3c-d52691b4dbfc

46 files changed:
ChangeLog
Source/CMakeLists.txt
Source/ThirdParty/ChangeLog
Source/ThirdParty/openvr/CMakeLists.txt [new file with mode: 0644]
Source/ThirdParty/openvr/LICENSE [new file with mode: 0644]
Source/ThirdParty/openvr/README.md [new file with mode: 0644]
Source/ThirdParty/openvr/README.webkit [new file with mode: 0644]
Source/ThirdParty/openvr/Toolchain-clang.cmake [new file with mode: 0644]
Source/ThirdParty/openvr/headers/openvr.h [new file with mode: 0644]
Source/ThirdParty/openvr/headers/openvr_api.cs [new file with mode: 0644]
Source/ThirdParty/openvr/headers/openvr_api.json [new file with mode: 0644]
Source/ThirdParty/openvr/headers/openvr_capi.h [new file with mode: 0644]
Source/ThirdParty/openvr/headers/openvr_driver.h [new file with mode: 0644]
Source/ThirdParty/openvr/patches/cmake-build.patch [new file with mode: 0644]
Source/ThirdParty/openvr/src/CMakeLists.txt [new file with mode: 0644]
Source/ThirdParty/openvr/src/Info.plist [new file with mode: 0644]
Source/ThirdParty/openvr/src/README [new file with mode: 0644]
Source/ThirdParty/openvr/src/ivrclientcore.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/json/json-forwards.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/json/json.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/jsoncpp.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/openvr_api_public.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/dirtools_public.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/dirtools_public.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/envvartools_public.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/envvartools_public.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/hmderrors_public.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/hmderrors_public.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/pathtools_public.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/pathtools_public.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/sharedlibtools_public.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/sharedlibtools_public.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/strtools_public.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/strtools_public.h [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/vrpathregistry_public.cpp [new file with mode: 0644]
Source/ThirdParty/openvr/src/vrcommon/vrpathregistry_public.h [new file with mode: 0644]
Source/WebCore/CMakeLists.txt
Source/WebCore/ChangeLog
Source/WebKit/UIProcess/API/glib/WebKitSettings.cpp
Source/WebKit/UIProcess/API/gtk/WebKitSettings.h
Source/WebKit/UIProcess/API/gtk/docs/webkit2gtk-4.0-sections.txt
Source/cmake/OptionsGTK.cmake
Source/cmake/OptionsWPE.cmake
Tools/ChangeLog
Tools/MiniBrowser/gtk/main.c
Tools/Scripts/webkitpy/style/checker.py

index cfe5b90..ee2d93b 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,14 @@
+2018-01-18  Sergio Villar Senin  <svillar@igalia.com>
+
+        [WebVR] Add OpenVR to the tree and to the build
+        https://bugs.webkit.org/show_bug.cgi?id=177298
+
+        Reviewed by Žan Doberšek.
+
+        * Source/CMakeLists.txt:
+        * Source/cmake/OptionsGTK.cmake: Enable USE_OPENVR.
+        * Source/cmake/OptionsWPE.cmake: Ditto.
+
 2018-01-18  Dan Bernstein  <mitz@apple.com>
 
         [Xcode] Shared schemes in the WebKit workspace still have build pre-actions that invoke copy-webkitlibraries-to-product-directory
index 8a26be2..140bf0b 100644 (file)
@@ -17,6 +17,10 @@ if (ENABLE_API_TESTS)
     add_subdirectory(ThirdParty/gtest)
 endif ()
 
+if (USE_OPENVR)
+    add_subdirectory(ThirdParty/openvr)
+endif ()
+
 if (USE_XDGMIME)
     add_subdirectory(ThirdParty/xdgmime)
 endif ()
index 08aa729..64e18f0 100644 (file)
@@ -1,3 +1,490 @@
+2018-01-18  Sergio Villar Senin  <svillar@igalia.com>
+
+        [WebVR] Add OpenVR to the tree and to the build
+        https://bugs.webkit.org/show_bug.cgi?id=177298
+
+        Reviewed by Žan Doberšek.
+
+        Adding the required parts of OpenVR library to the tree. This will be used as a backend for
+        the eventual WebVR implementation.
+
+        * openvr/CMakeLists.txt: Added.
+        * openvr/LICENSE: Added.
+        * openvr/README.md: Added.
+        * openvr/README.webkit: Added. Includes specifics changes made to the original library to
+        accommodate it to the WebKit build system.
+        * openvr/Toolchain-clang.cmake: Added.
+        * openvr/headers/openvr.h: Added.
+        (vr::ButtonMaskFromId):
+        (vr::NotificationBitmap_t::NotificationBitmap_t):
+        (vr::VRToken):
+        (vr::COpenVRContext::COpenVRContext):
+        (vr::COpenVRContext::CheckClear):
+        (vr::COpenVRContext::VRSystem):
+        (vr::COpenVRContext::VRChaperone):
+        (vr::COpenVRContext::VRChaperoneSetup):
+        (vr::COpenVRContext::VRCompositor):
+        (vr::COpenVRContext::VROverlay):
+        (vr::COpenVRContext::VRResources):
+        (vr::COpenVRContext::VRScreenshots):
+        (vr::COpenVRContext::VRRenderModels):
+        (vr::COpenVRContext::VRExtendedDisplay):
+        (vr::COpenVRContext::VRSettings):
+        (vr::COpenVRContext::VRApplications):
+        (vr::COpenVRContext::VRTrackedCamera):
+        (vr::COpenVRContext::VRDriverManager):
+        (vr::OpenVRInternal_ModuleContext):
+        (vr::VRSystem):
+        (vr::VRChaperone):
+        (vr::VRChaperoneSetup):
+        (vr::VRCompositor):
+        (vr::VROverlay):
+        (vr::VRScreenshots):
+        (vr::VRRenderModels):
+        (vr::VRApplications):
+        (vr::VRSettings):
+        (vr::VRResources):
+        (vr::VRExtendedDisplay):
+        (vr::VRTrackedCamera):
+        (vr::VRDriverManager):
+        (vr::COpenVRContext::Clear):
+        (vr::VR_Init):
+        (vr::VR_Shutdown):
+        * openvr/headers/openvr_api.cs: Added.
+        * openvr/headers/openvr_api.json: Added.
+        * openvr/headers/openvr_capi.h: Added.
+        * openvr/headers/openvr_driver.h: Added.
+        (vr::ButtonMaskFromId):
+        (vr::IVRDriverDirectModeComponent::CreateSwapTextureSet):
+        (vr::IVRDriverDirectModeComponent::DestroySwapTextureSet):
+        (vr::IVRDriverDirectModeComponent::DestroyAllSwapTextureSets):
+        (vr::IVRDriverDirectModeComponent::GetNextSwapTextureSetIndex):
+        (vr::IVRDriverDirectModeComponent::SubmitLayer):
+        (vr::IVRDriverDirectModeComponent::Present):
+        (vr::CVRPropertyHelpers::CVRPropertyHelpers):
+        (vr::CVRPropertyHelpers::TrackedDeviceToPropertyContainer):
+        (vr::CVRPropertyHelpers::GetProperty):
+        (vr::CVRPropertyHelpers::SetProperty):
+        (vr::CVRPropertyHelpers::GetStringProperty):
+        (vr::CVRPropertyHelpers::SetStringProperty):
+        (vr::CVRPropertyHelpers::GetPropertyHelper):
+        (vr::CVRPropertyHelpers::GetBoolProperty):
+        (vr::CVRPropertyHelpers::GetFloatProperty):
+        (vr::CVRPropertyHelpers::GetInt32Property):
+        (vr::CVRPropertyHelpers::GetUint64Property):
+        (vr::CVRPropertyHelpers::SetBoolProperty):
+        (vr::CVRPropertyHelpers::SetFloatProperty):
+        (vr::CVRPropertyHelpers::SetInt32Property):
+        (vr::CVRPropertyHelpers::SetUint64Property):
+        (vr::CVRPropertyHelpers::SetPropertyError):
+        (vr::CVRPropertyHelpers::EraseProperty):
+        (vr::CVRHiddenAreaHelpers::CVRHiddenAreaHelpers):
+        (vr::CVRHiddenAreaHelpers::GetPropertyEnum):
+        (vr::CVRHiddenAreaHelpers::SetHiddenArea):
+        (vr::CVRHiddenAreaHelpers::GetHiddenArea):
+        (vr::VRDriverContext):
+        (vr::COpenVRDriverContext::COpenVRDriverContext):
+        (vr::COpenVRDriverContext::VRSettings):
+        (vr::COpenVRDriverContext::VRPropertiesRaw):
+        (vr::COpenVRDriverContext::VRProperties):
+        (vr::COpenVRDriverContext::VRHiddenArea):
+        (vr::COpenVRDriverContext::VRServerDriverHost):
+        (vr::COpenVRDriverContext::VRWatchdogHost):
+        (vr::COpenVRDriverContext::VRDriverLog):
+        (vr::COpenVRDriverContext::VRDriverHandle):
+        (vr::OpenVRInternal_ModuleServerDriverContext):
+        (vr::VRSettings):
+        (vr::VRPropertiesRaw):
+        (vr::VRProperties):
+        (vr::VRHiddenArea):
+        (vr::VRDriverLog):
+        (vr::VRServerDriverHost):
+        (vr::VRWatchdogHost):
+        (vr::VRDriverHandle):
+        (vr::COpenVRDriverContext::Clear):
+        (vr::COpenVRDriverContext::InitServer):
+        (vr::COpenVRDriverContext::InitWatchdog):
+        (vr::InitServerDriverContext):
+        (vr::InitWatchdogDriverContext):
+        (vr::CleanupDriverContext):
+        * openvr/patches/cmake-build.patch: Added.
+        * openvr/src/CMakeLists.txt: Added.
+        * openvr/src/Info.plist: Added.
+        * openvr/src/README: Added.
+        * openvr/src/ivrclientcore.h: Added.
+        * openvr/src/json/json-forwards.h: Added.
+        * openvr/src/json/json.h: Added.
+        (std::swap):
+        * openvr/src/jsoncpp.cpp: Added.
+        (Json::codePointToUTF8):
+        (Json::isControlCharacter):
+        (Json::uintToString):
+        (Json::fixNumericLocale):
+        (Json::Features::Features):
+        (Json::Features::all):
+        (Json::Features::strictMode):
+        (Json::containsNewLine):
+        (Json::Reader::Reader):
+        (Json::Reader::parse):
+        (Json::Reader::readValue):
+        (Json::Reader::skipCommentTokens):
+        (Json::Reader::readToken):
+        (Json::Reader::skipSpaces):
+        (Json::Reader::match):
+        (Json::Reader::readComment):
+        (Json::normalizeEOL):
+        (Json::Reader::addComment):
+        (Json::Reader::readCStyleComment):
+        (Json::Reader::readCppStyleComment):
+        (Json::Reader::readNumber):
+        (Json::Reader::readString):
+        (Json::Reader::readObject):
+        (Json::Reader::readArray):
+        (Json::Reader::decodeNumber):
+        (Json::Reader::decodeDouble):
+        (Json::Reader::decodeString):
+        (Json::Reader::decodeUnicodeCodePoint):
+        (Json::Reader::decodeUnicodeEscapeSequence):
+        (Json::Reader::addError):
+        (Json::Reader::recoverFromError):
+        (Json::Reader::addErrorAndRecover):
+        (Json::Reader::currentValue):
+        (Json::Reader::getNextChar):
+        (Json::Reader::getLocationLineAndColumn const):
+        (Json::Reader::getLocationSnippet const):
+        (Json::Reader::getFormatedErrorMessages const):
+        (Json::Reader::getFormattedErrorMessages const):
+        (Json::Reader::getStructuredErrors const):
+        (Json::Reader::pushError):
+        (Json::Reader::good const):
+        (Json::OurFeatures::all):
+        (Json::OurReader::OurReader):
+        (Json::OurReader::parse):
+        (Json::OurReader::readValue):
+        (Json::OurReader::skipCommentTokens):
+        (Json::OurReader::readToken):
+        (Json::OurReader::skipSpaces):
+        (Json::OurReader::match):
+        (Json::OurReader::readComment):
+        (Json::OurReader::addComment):
+        (Json::OurReader::readCStyleComment):
+        (Json::OurReader::readCppStyleComment):
+        (Json::OurReader::readNumber):
+        (Json::OurReader::readString):
+        (Json::OurReader::readStringSingleQuote):
+        (Json::OurReader::readObject):
+        (Json::OurReader::readArray):
+        (Json::OurReader::decodeNumber):
+        (Json::OurReader::decodeDouble):
+        (Json::OurReader::decodeString):
+        (Json::OurReader::decodeUnicodeCodePoint):
+        (Json::OurReader::decodeUnicodeEscapeSequence):
+        (Json::OurReader::addError):
+        (Json::OurReader::recoverFromError):
+        (Json::OurReader::addErrorAndRecover):
+        (Json::OurReader::currentValue):
+        (Json::OurReader::getNextChar):
+        (Json::OurReader::getLocationLineAndColumn const):
+        (Json::OurReader::getFormattedErrorMessages const):
+        (Json::OurReader::getStructuredErrors const):
+        (Json::OurReader::pushError):
+        (Json::OurReader::good const):
+        (Json::OurCharReader::OurCharReader):
+        (Json::OurCharReader::parse):
+        (Json::CharReaderBuilder::CharReaderBuilder):
+        (Json::CharReaderBuilder::~CharReaderBuilder):
+        (Json::CharReaderBuilder::newCharReader const):
+        (Json::getValidReaderKeys):
+        (Json::CharReaderBuilder::validate const):
+        (Json::CharReaderBuilder::operator[]):
+        (Json::CharReaderBuilder::strictMode):
+        (Json::CharReaderBuilder::setDefaults):
+        (Json::parseFromStream):
+        (Json::operator>>):
+        (Json::ValueIteratorBase::ValueIteratorBase):
+        (Json::ValueIteratorBase::deref const):
+        (Json::ValueIteratorBase::increment):
+        (Json::ValueIteratorBase::decrement):
+        (Json::ValueIteratorBase::computeDistance const):
+        (Json::ValueIteratorBase::isEqual const):
+        (Json::ValueIteratorBase::copy):
+        (Json::ValueIteratorBase::key const):
+        (Json::ValueIteratorBase::index const):
+        (Json::ValueIteratorBase::name const):
+        (Json::ValueIteratorBase::memberName const):
+        (Json::ValueConstIterator::ValueConstIterator):
+        (Json::operator=):
+        (Json::ValueIterator::ValueIterator):
+        (Json::ValueIterator::operator=):
+        (Json::InRange):
+        (Json::integerToDouble):
+        (Json::duplicateStringValue):
+        (Json::duplicateAndPrefixStringValue):
+        (Json::decodePrefixedString):
+        (Json::releaseStringValue):
+        (Json::Exception::Exception):
+        (Json::throw):
+        (Json::RuntimeError::RuntimeError):
+        (Json::LogicError::LogicError):
+        (Json::throwRuntimeError):
+        (Json::throwLogicError):
+        (Json::Value::CommentInfo::CommentInfo):
+        (Json::Value::CommentInfo::~CommentInfo):
+        (Json::Value::CommentInfo::setComment):
+        (Json::Value::CZString::CZString):
+        (Json::Value::CZString::~CZString):
+        (Json::Value::CZString::swap):
+        (Json::Value::CZString::operator=):
+        (Json::Value::CZString::operator< const):
+        (Json::Value::CZString::operator== const):
+        (Json::Value::CZString::index const):
+        (Json::Value::CZString::data const):
+        (Json::Value::CZString::length const):
+        (Json::Value::CZString::isStaticString const):
+        (Json::Value::Value):
+        (Json::Value::~Value):
+        (Json::Value::operator=):
+        (Json::Value::swapPayload):
+        (Json::Value::swap):
+        (Json::Value::type const):
+        (Json::Value::compare const):
+        (Json::Value::operator< const):
+        (Json::Value::operator<= const):
+        (Json::Value::operator>= const):
+        (Json::Value::operator> const):
+        (Json::Value::operator== const):
+        (Json::Value::operator!= const):
+        (Json::Value::asCString const):
+        (Json::Value::getString const):
+        (Json::Value::asString const):
+        (Json::Value::asConstString const):
+        (Json::Value::asInt const):
+        (Json::Value::asUInt const):
+        (Json::Value::asInt64 const):
+        (Json::Value::asUInt64 const):
+        (Json::Value::asLargestInt const):
+        (Json::Value::asLargestUInt const):
+        (Json::Value::asDouble const):
+        (Json::Value::asFloat const):
+        (Json::Value::asBool const):
+        (Json::Value::isConvertibleTo const):
+        (Json::Value::size const):
+        (Json::Value::empty const):
+        (Json::Value::operator! const):
+        (Json::Value::clear):
+        (Json::Value::resize):
+        (Json::Value::operator[]):
+        (Json::Value::operator[] const):
+        (Json::Value::initBasic):
+        (Json::Value::resolveReference):
+        (Json::Value::get const):
+        (Json::Value::isValidIndex const):
+        (Json::Value::find const):
+        (Json::Value::append):
+        (Json::Value::removeMember):
+        (Json::Value::removeIndex):
+        (Json::Value::isMember const):
+        (Json::Value::getMemberNames const):
+        (Json::IsIntegral):
+        (Json::Value::isNull const):
+        (Json::Value::isBool const):
+        (Json::Value::isInt const):
+        (Json::Value::isUInt const):
+        (Json::Value::isInt64 const):
+        (Json::Value::isUInt64 const):
+        (Json::Value::isIntegral const):
+        (Json::Value::isDouble const):
+        (Json::Value::isNumeric const):
+        (Json::Value::isString const):
+        (Json::Value::isArray const):
+        (Json::Value::isObject const):
+        (Json::Value::setComment):
+        (Json::Value::hasComment const):
+        (Json::Value::getComment const):
+        (Json::Value::setOffsetStart):
+        (Json::Value::setOffsetLimit):
+        (Json::Value::getOffsetStart const):
+        (Json::Value::getOffsetLimit const):
+        (Json::Value::toStyledString const):
+        (Json::Value::begin const):
+        (Json::Value::end const):
+        (Json::Value::begin):
+        (Json::Value::end):
+        (Json::PathArgument::PathArgument):
+        (Json::Path::Path):
+        (Json::Path::makePath):
+        (Json::Path::addPathInArg):
+        (Json::Path::invalidPath):
+        (Json::Path::resolve const):
+        (Json::Path::make const):
+        (Json::containsControlCharacter):
+        (Json::containsControlCharacter0):
+        (Json::valueToString):
+        (Json::valueToQuotedString):
+        (Json::strnpbrk):
+        (Json::valueToQuotedStringN):
+        (Json::Writer::~Writer):
+        (Json::FastWriter::FastWriter):
+        (Json::FastWriter::enableYAMLCompatibility):
+        (Json::FastWriter::dropNullPlaceholders):
+        (Json::FastWriter::omitEndingLineFeed):
+        (Json::FastWriter::write):
+        (Json::FastWriter::writeValue):
+        (Json::StyledWriter::StyledWriter):
+        (Json::StyledWriter::write):
+        (Json::StyledWriter::writeValue):
+        (Json::StyledWriter::writeArrayValue):
+        (Json::StyledWriter::isMultineArray):
+        (Json::StyledWriter::pushValue):
+        (Json::StyledWriter::writeIndent):
+        (Json::StyledWriter::writeWithIndent):
+        (Json::StyledWriter::indent):
+        (Json::StyledWriter::unindent):
+        (Json::StyledWriter::writeCommentBeforeValue):
+        (Json::StyledWriter::writeCommentAfterValueOnSameLine):
+        (Json::StyledWriter::hasCommentForValue):
+        (Json::StyledStreamWriter::StyledStreamWriter):
+        (Json::StyledStreamWriter::write):
+        (Json::StyledStreamWriter::writeValue):
+        (Json::StyledStreamWriter::writeArrayValue):
+        (Json::StyledStreamWriter::isMultineArray):
+        (Json::StyledStreamWriter::pushValue):
+        (Json::StyledStreamWriter::writeIndent):
+        (Json::StyledStreamWriter::writeWithIndent):
+        (Json::StyledStreamWriter::indent):
+        (Json::StyledStreamWriter::unindent):
+        (Json::StyledStreamWriter::writeCommentBeforeValue):
+        (Json::StyledStreamWriter::writeCommentAfterValueOnSameLine):
+        (Json::StyledStreamWriter::hasCommentForValue):
+        (Json::BuiltStyledStreamWriter::BuiltStyledStreamWriter):
+        (Json::BuiltStyledStreamWriter::write):
+        (Json::BuiltStyledStreamWriter::writeValue):
+        (Json::BuiltStyledStreamWriter::writeArrayValue):
+        (Json::BuiltStyledStreamWriter::isMultineArray):
+        (Json::BuiltStyledStreamWriter::pushValue):
+        (Json::BuiltStyledStreamWriter::writeIndent):
+        (Json::BuiltStyledStreamWriter::writeWithIndent):
+        (Json::BuiltStyledStreamWriter::indent):
+        (Json::BuiltStyledStreamWriter::unindent):
+        (Json::BuiltStyledStreamWriter::writeCommentBeforeValue):
+        (Json::BuiltStyledStreamWriter::writeCommentAfterValueOnSameLine):
+        (Json::BuiltStyledStreamWriter::hasCommentForValue):
+        (Json::StreamWriter::StreamWriter):
+        (Json::StreamWriter::~StreamWriter):
+        (Json::StreamWriter::Factory::~Factory):
+        (Json::StreamWriterBuilder::StreamWriterBuilder):
+        (Json::StreamWriterBuilder::~StreamWriterBuilder):
+        (Json::StreamWriterBuilder::newStreamWriter const):
+        (Json::getValidWriterKeys):
+        (Json::StreamWriterBuilder::validate const):
+        (Json::StreamWriterBuilder::operator[]):
+        (Json::StreamWriterBuilder::setDefaults):
+        (Json::writeString):
+        (Json::operator<<):
+        * openvr/src/openvr_api_public.cpp: Added.
+        (vr::VR_GetInitToken):
+        (vr::VR_InitInternal2):
+        (vr::VR_InitInternal):
+        (vr::VR_ShutdownInternal):
+        (vr::VR_LoadHmdSystemInternal):
+        (vr::VR_GetGenericInterface):
+        (vr::VR_IsInterfaceVersionValid):
+        (vr::VR_IsHmdPresent):
+        (vr::VR_IsRuntimeInstalled):
+        (vr::VR_RuntimePath):
+        (vr::VR_GetVRInitErrorAsSymbol):
+        (vr::VR_GetVRInitErrorAsEnglishDescription):
+        (vr::VR_GetStringForHmdError):
+        * openvr/src/vrcommon/dirtools_public.cpp: Added.
+        (BCreateDirectoryRecursive):
+        (BCreateDirectory):
+        * openvr/src/vrcommon/dirtools_public.h: Added.
+        * openvr/src/vrcommon/envvartools_public.cpp: Added.
+        (GetEnvironmentVariable):
+        (SetEnvironmentVariable):
+        * openvr/src/vrcommon/envvartools_public.h: Added.
+        * openvr/src/vrcommon/hmderrors_public.cpp: Added.
+        (GetEnglishStringForHmdError):
+        (GetIDForVRInitError):
+        * openvr/src/vrcommon/hmderrors_public.h: Added.
+        * openvr/src/vrcommon/pathtools_public.cpp: Added.
+        (Path_GetExecutablePath):
+        (Path_GetWorkingDirectory):
+        (Path_SetWorkingDirectory):
+        (Path_StripFilename):
+        (Path_StripDirectory):
+        (Path_StripExtension):
+        (Path_GetExtension):
+        (Path_IsAbsolute):
+        (Path_MakeAbsolute):
+        (Path_FixSlashes):
+        (Path_GetSlash):
+        (Path_Join):
+        (Path_RemoveTrailingSlash):
+        (Path_Compact):
+        (Path_GetThisModulePath):
+        (Path_IsDirectory):
+        (Path_IsAppBundle):
+        (Path_Exists):
+        (Path_FindParentDirectoryRecursively):
+        (Path_FindParentSubDirectoryRecursively):
+        (Path_ReadBinaryFile):
+        (Path_WriteBinaryFile):
+        (Path_ReadTextFile):
+        (Path_WriteStringToTextFile):
+        (Path_WriteStringToTextFileAtomic):
+        (Path_FilePathToUrl):
+        (Path_UrlToFilePath):
+        (GetUserDocumentsPath):
+        * openvr/src/vrcommon/pathtools_public.h: Added.
+        * openvr/src/vrcommon/sharedlibtools_public.cpp: Added.
+        (SharedLib_Load):
+        (SharedLib_GetFunction):
+        (SharedLib_Unload):
+        * openvr/src/vrcommon/sharedlibtools_public.h: Added.
+        * openvr/src/vrcommon/strtools_public.cpp: Added.
+        (StringHasPrefix):
+        (StringHasPrefixCaseSensitive):
+        (StringHasSuffix):
+        (StringHasSuffixCaseSensitive):
+        (UTF16to8):
+        (UTF8to16):
+        (strcpy_safe):
+        (StringToUpper):
+        (StringToLower):
+        (ReturnStdString):
+        (BufferToStdString):
+        (Uint64ToString):
+        (StringToUint64):
+        (cIntToHexDigit):
+        (iHexCharToInt):
+        (V_URLEncodeInternal):
+        (V_URLDecodeInternal):
+        (V_URLEncode):
+        (V_URLDecode):
+        (V_StripExtension):
+        * openvr/src/vrcommon/strtools_public.h: Added.
+        (stricmp):
+        (strnicmp):
+        (wcsncpy_s):
+        (strncpy_s):
+        (strtoull):
+        * openvr/src/vrcommon/vrpathregistry_public.cpp: Added.
+        (GetAppSettingsPath):
+        (CVRPathRegistry_Public::CVRPathRegistry_Public):
+        (CVRPathRegistry_Public::GetOpenVRConfigPath):
+        (CVRPathRegistry_Public::GetVRPathRegistryFilename):
+        (ParseStringListFromJson):
+        (StringListToJson):
+        (CVRPathRegistry_Public::ToJsonString):
+        (CVRPathRegistry_Public::BLoadFromFile):
+        (CVRPathRegistry_Public::BSaveToFile const):
+        (CVRPathRegistry_Public::GetRuntimePath const):
+        (CVRPathRegistry_Public::GetConfigPath const):
+        (CVRPathRegistry_Public::GetLogPath const):
+        (CVRPathRegistry_Public::GetPaths):
+        * openvr/src/vrcommon/vrpathregistry_public.h: Added.
+
 2017-12-14  David Kilzer  <ddkilzer@apple.com>
 
         Enable -Wstrict-prototypes for WebKit
diff --git a/Source/ThirdParty/openvr/CMakeLists.txt b/Source/ThirdParty/openvr/CMakeLists.txt
new file mode 100644 (file)
index 0000000..d13a7f9
--- /dev/null
@@ -0,0 +1,58 @@
+# Set the minimum required version of CMake for this project.
+cmake_minimum_required(VERSION 2.8)
+
+# Setup some options.
+option(BUILD_SHARED "Builds the library as shared library" OFF)
+option(USE_LIBCXX "Uses libc++ instead of libstdc++" ON)
+option(USE_CUSTOM_LIBCXX "Uses a custom libc++" OFF)
+
+add_definitions( -DVR_API_PUBLIC )
+
+# Check if 32 or 64 bit system.
+set(SIZEOF_VOIDP ${CMAKE_SIZEOF_VOID_P})
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+  set(PROCESSOR_ARCH "64")
+else()
+  set(PROCESSOR_ARCH "32")
+endif()
+
+# Get platform.
+if(WIN32)
+       set(PLATFORM_NAME "win")
+elseif(UNIX AND NOT APPLE)
+  if(CMAKE_SYSTEM_NAME MATCHES ".*Linux")
+    set(PLATFORM_NAME "linux")
+    add_definitions(-DLINUX -DPOSIX)
+    if(PROCESSOR_ARCH MATCHES "64")
+        add_definitions(-DLINUX64)
+    endif()
+  endif()
+elseif(APPLE)
+  if(CMAKE_SYSTEM_NAME MATCHES ".*Darwin.*" OR CMAKE_SYSTEM_NAME MATCHES ".*MacOS.*")
+    set(PLATFORM_NAME "osx")
+    add_definitions(-DOSX -DPOSIX)
+  endif()
+endif()
+
+# Enable some properties.
+if(CMAKE_COMPILER_IS_GNUCC OR CMAKE_C_COMPILER_ID MATCHES "Clang")
+       # Enable c++11 and hide symbols which shouldn't be visible
+       set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fPIC -fvisibility=hidden")
+
+       # Set custom libc++ usage here
+       if(CMAKE_C_COMPILER_ID MATCHES "Clang" AND USE_LIBCXX)
+              if(USE_CUSTOM_LIBCXX)
+                     if(BUILD_SHARED)
+                            set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -stdlib=libc++")
+                     endif()
+                     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdinc++")
+                     include_directories( ${LIBCXX_INCLUDE} ${LIBCXX_ABI_INCLUDE})
+                     message(STATUS "Using custom libc++")
+              else()
+                     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+                     message(STATUS "Using libc++")
+              endif()
+       endif()
+endif()
+
+add_subdirectory(src)
diff --git a/Source/ThirdParty/openvr/LICENSE b/Source/ThirdParty/openvr/LICENSE
new file mode 100644 (file)
index 0000000..ee83337
--- /dev/null
@@ -0,0 +1,27 @@
+Copyright (c) 2015, Valve Corporation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/Source/ThirdParty/openvr/README.md b/Source/ThirdParty/openvr/README.md
new file mode 100644 (file)
index 0000000..5976d62
--- /dev/null
@@ -0,0 +1,13 @@
+OpenVR SDK
+---
+
+OpenVR is an API and runtime that allows access to VR hardware from multiple 
+vendors without requiring that applications have specific knowledge of the 
+hardware they are targeting. This repository is an SDK that contains the API 
+and samples. The runtime is under SteamVR in Tools on Steam. 
+
+### Documentation
+
+Documentation for the API is available on the [Github Wiki](https://github.com/ValveSoftware/openvr/wiki/API-Documentation)
+
+More information on OpenVR and SteamVR can be found on http://steamvr.com
diff --git a/Source/ThirdParty/openvr/README.webkit b/Source/ThirdParty/openvr/README.webkit
new file mode 100644 (file)
index 0000000..4ff9782
--- /dev/null
@@ -0,0 +1,21 @@
+This is the OpenVR library from
+https://github.com/ValveSoftware/openvr
+
+Upstream code can be viewed at
+ https://github.com/ValveSoftware/openvr/tree/master/
+
+and cloned by
+ git clone https://github.com/ValveSoftware/openvr.git
+
+Current version: [commit ebdea152f8aac77e9a6db29682b81d762159df7e]
+
+which corresponds to 1.0.10 release.
+
+WebKit changes:
+* patches/cmake-build.patch: script used to allow openvr CMake build to be
+integrated into WebKit build
+* Removed bin/ directory. Not needed as it includes precompiled libraries
+* Removed lib/ directory. Not needed as it includes precompiled libraries
+* Removed controller_callouts/ directory. Unneeded docs
+* Removed samples/ directory.
+* Replaced tabs by whitespaces to make check-webkit-style happy.
\ No newline at end of file
diff --git a/Source/ThirdParty/openvr/Toolchain-clang.cmake b/Source/ThirdParty/openvr/Toolchain-clang.cmake
new file mode 100644 (file)
index 0000000..fb6b0ac
--- /dev/null
@@ -0,0 +1,9 @@
+set(CMAKE_SYSTEM_NAME Linux)
+
+set(CMAKE_C_COMPILER clang)
+set(CMAKE_CXX_COMPILER clang++)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
diff --git a/Source/ThirdParty/openvr/headers/openvr.h b/Source/ThirdParty/openvr/headers/openvr.h
new file mode 100644 (file)
index 0000000..076e49a
--- /dev/null
@@ -0,0 +1,3777 @@
+#pragma once
+
+// openvr.h
+//========= Copyright Valve Corporation ============//
+// Dynamically generated file. Do not modify this file directly.
+
+#ifndef _OPENVR_API
+#define _OPENVR_API
+
+#include <stdint.h>
+
+
+
+// vrtypes.h
+#ifndef _INCLUDE_VRTYPES_H
+#define _INCLUDE_VRTYPES_H
+
+// Forward declarations to avoid requiring vulkan.h
+struct VkDevice_T;
+struct VkPhysicalDevice_T;
+struct VkInstance_T;
+struct VkQueue_T;
+
+// Forward declarations to avoid requiring d3d12.h
+struct ID3D12Resource;
+struct ID3D12CommandQueue;
+
+namespace vr
+{
+#pragma pack( push, 8 )
+
+typedef void* glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+
+// right-handed system
+// +y is up
+// +x is to the right
+// -z is going away from you
+// Distance unit is  meters
+struct HmdMatrix34_t
+{
+       float m[3][4];
+};
+
+struct HmdMatrix44_t
+{
+       float m[4][4];
+};
+
+struct HmdVector3_t
+{
+       float v[3];
+};
+
+struct HmdVector4_t
+{
+       float v[4];
+};
+
+struct HmdVector3d_t
+{
+       double v[3];
+};
+
+struct HmdVector2_t
+{
+       float v[2];
+};
+
+struct HmdQuaternion_t
+{
+       double w, x, y, z;
+};
+
+struct HmdColor_t
+{
+       float r, g, b, a;
+};
+
+struct HmdQuad_t
+{
+       HmdVector3_t vCorners[ 4 ];
+};
+
+struct HmdRect2_t
+{
+       HmdVector2_t vTopLeft;
+       HmdVector2_t vBottomRight;
+};
+
+/** Used to return the post-distortion UVs for each color channel. 
+* UVs range from 0 to 1 with 0,0 in the upper left corner of the 
+* source render target. The 0,0 to 1,1 range covers a single eye. */
+struct DistortionCoordinates_t
+{
+       float rfRed[2];
+       float rfGreen[2];
+       float rfBlue[2];
+};
+
+enum EVREye
+{
+       Eye_Left = 0,
+       Eye_Right = 1
+};
+
+enum ETextureType
+{
+       TextureType_DirectX = 0, // Handle is an ID3D11Texture
+       TextureType_OpenGL = 1,  // Handle is an OpenGL texture name or an OpenGL render buffer name, depending on submit flags
+       TextureType_Vulkan = 2, // Handle is a pointer to a VRVulkanTextureData_t structure
+       TextureType_IOSurface = 3, // Handle is a macOS cross-process-sharable IOSurfaceRef
+       TextureType_DirectX12 = 4, // Handle is a pointer to a D3D12TextureData_t structure
+};
+
+enum EColorSpace
+{
+       ColorSpace_Auto = 0,       // Assumes 'gamma' for 8-bit per component formats, otherwise 'linear'.  This mirrors the DXGI formats which have _SRGB variants.
+       ColorSpace_Gamma = 1,       // Texture data can be displayed directly on the display without any conversion (a.k.a. display native format).
+       ColorSpace_Linear = 2,       // Same as gamma but has been converted to a linear representation using DXGI's sRGB conversion algorithm.
+};
+
+struct Texture_t
+{
+       void* handle; // See ETextureType definition above
+       ETextureType eType;
+       EColorSpace eColorSpace;
+};
+
+// Handle to a shared texture (HANDLE on Windows obtained using OpenSharedResource).
+typedef uint64_t SharedTextureHandle_t;
+#define INVALID_SHARED_TEXTURE_HANDLE       ((vr::SharedTextureHandle_t)0)
+
+enum ETrackingResult
+{
+       TrackingResult_Uninitialized                     = 1,
+
+       TrackingResult_Calibrating_InProgress       = 100,
+       TrackingResult_Calibrating_OutOfRange       = 101,
+
+       TrackingResult_Running_OK                            = 200,
+       TrackingResult_Running_OutOfRange              = 201,
+};
+
+typedef uint32_t DriverId_t;
+static const uint32_t k_nDriverNone = 0xFFFFFFFF;
+
+static const uint32_t k_unMaxDriverDebugResponseSize = 32768;
+
+/** Used to pass device IDs to API calls */
+typedef uint32_t TrackedDeviceIndex_t;
+static const uint32_t k_unTrackedDeviceIndex_Hmd = 0;
+static const uint32_t k_unMaxTrackedDeviceCount = 16;
+static const uint32_t k_unTrackedDeviceIndexOther = 0xFFFFFFFE;
+static const uint32_t k_unTrackedDeviceIndexInvalid = 0xFFFFFFFF;
+
+/** Describes what kind of object is being tracked at a given ID */
+enum ETrackedDeviceClass
+{
+       TrackedDeviceClass_Invalid = 0,                            // the ID was not valid.
+       TrackedDeviceClass_HMD = 1,                                   // Head-Mounted Displays
+       TrackedDeviceClass_Controller = 2,                     // Tracked controllers
+       TrackedDeviceClass_GenericTracker = 3,              // Generic trackers, similar to controllers
+       TrackedDeviceClass_TrackingReference = 4,       // Camera and base stations that serve as tracking reference points
+       TrackedDeviceClass_DisplayRedirect = 5,              // Accessories that aren't necessarily tracked themselves, but may redirect video output from other tracked devices
+};
+
+
+/** Describes what specific role associated with a tracked device */
+enum ETrackedControllerRole
+{
+       TrackedControllerRole_Invalid = 0,                                   // Invalid value for controller type
+       TrackedControllerRole_LeftHand = 1,                                   // Tracked device associated with the left hand
+       TrackedControllerRole_RightHand = 2,                            // Tracked device associated with the right hand
+};
+
+
+/** describes a single pose for a tracked object */
+struct TrackedDevicePose_t
+{
+       HmdMatrix34_t mDeviceToAbsoluteTracking;
+       HmdVector3_t vVelocity;                            // velocity in tracker space in m/s
+       HmdVector3_t vAngularVelocity;              // angular velocity in radians/s (?)
+       ETrackingResult eTrackingResult;
+       bool bPoseIsValid;
+
+       // This indicates that there is a device connected for this spot in the pose array.
+       // It could go from true to false if the user unplugs the device.
+       bool bDeviceIsConnected;
+};
+
+/** Identifies which style of tracking origin the application wants to use
+* for the poses it is requesting */
+enum ETrackingUniverseOrigin
+{
+       TrackingUniverseSeated = 0,              // Poses are provided relative to the seated zero pose
+       TrackingUniverseStanding = 1,       // Poses are provided relative to the safe bounds configured by the user
+       TrackingUniverseRawAndUncalibrated = 2,       // Poses are provided in the coordinate system defined by the driver.  It has Y up and is unified for devices of the same driver. You usually don't want this one.
+};
+
+// Refers to a single container of properties
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+
+static const PropertyContainerHandle_t k_ulInvalidPropertyContainer = 0;
+static const PropertyTypeTag_t k_unInvalidPropertyTag = 0;
+
+// Use these tags to set/get common types as struct properties
+static const PropertyTypeTag_t k_unFloatPropertyTag = 1;
+static const PropertyTypeTag_t k_unInt32PropertyTag = 2;
+static const PropertyTypeTag_t k_unUint64PropertyTag = 3;
+static const PropertyTypeTag_t k_unBoolPropertyTag = 4;
+static const PropertyTypeTag_t k_unStringPropertyTag = 5;
+
+static const PropertyTypeTag_t k_unHmdMatrix34PropertyTag = 20;
+static const PropertyTypeTag_t k_unHmdMatrix44PropertyTag = 21;
+static const PropertyTypeTag_t k_unHmdVector3PropertyTag = 22;
+static const PropertyTypeTag_t k_unHmdVector4PropertyTag = 23;
+
+static const PropertyTypeTag_t k_unHiddenAreaPropertyTag = 30;
+
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_Start = 1000;
+static const PropertyTypeTag_t k_unOpenVRInternalReserved_End = 10000;
+
+
+/** Each entry in this enum represents a property that can be retrieved about a
+* tracked device. Many fields are only valid for one ETrackedDeviceClass. */
+enum ETrackedDeviceProperty
+{
+       Prop_Invalid                                                        = 0,
+
+       // general properties that apply to all device classes
+       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, // 0 is empty, 1 is full
+       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,
+
+       // Properties that are unique to TrackedDeviceClass_HMD
+       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,
+
+       // Properties that are unique to TrackedDeviceClass_Controller
+       Prop_AttachedDeviceId_String                            = 3000,
+       Prop_SupportedButtons_Uint64                            = 3001,
+       Prop_Axis0Type_Int32                                          = 3002, // Return value is of type EVRControllerAxisType
+       Prop_Axis1Type_Int32                                          = 3003, // Return value is of type EVRControllerAxisType
+       Prop_Axis2Type_Int32                                          = 3004, // Return value is of type EVRControllerAxisType
+       Prop_Axis3Type_Int32                                          = 3005, // Return value is of type EVRControllerAxisType
+       Prop_Axis4Type_Int32                                          = 3006, // Return value is of type EVRControllerAxisType
+       Prop_ControllerRoleHint_Int32                            = 3007, // Return value is of type ETrackedControllerRole
+
+       // Properties that are unique to TrackedDeviceClass_TrackingReference
+       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,
+
+       // Properties that are used for user interface like icons names
+       Prop_IconPathName_String                                          = 5000, // DEPRECATED. Value not referenced. Now expected to be part of icon path properties.
+       Prop_NamedIconPathDeviceOff_String                            = 5001, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+       Prop_NamedIconPathDeviceSearching_String              = 5002, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+       Prop_NamedIconPathDeviceSearchingAlert_String       = 5003, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+       Prop_NamedIconPathDeviceReady_String                     = 5004, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+       Prop_NamedIconPathDeviceReadyAlert_String              = 5005, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+       Prop_NamedIconPathDeviceNotReady_String                     = 5006, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+       Prop_NamedIconPathDeviceStandby_String                     = 5007, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+       Prop_NamedIconPathDeviceAlertLow_String                     = 5008, // {driver}/icons/icon_filename - PNG for static icon, or GIF for animation, 50x32 for headsets and 32x32 for others
+
+       // Properties that are used by helpers, but are opaque to applications
+       Prop_DisplayHiddenArea_Binary_Start                            = 5100,
+       Prop_DisplayHiddenArea_Binary_End                            = 5150,
+
+       // Properties that are unique to drivers
+       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,
+
+       // Vendors are free to expose private debug data in this reserved region
+       Prop_VendorSpecific_Reserved_Start                     = 10000,
+       Prop_VendorSpecific_Reserved_End                     = 10999,
+};
+
+/** No string property will ever be longer than this length */
+static const uint32_t k_unMaxPropertyStringSize = 32 * 1024;
+
+/** Used to return errors that occur when reading properties. */
+enum ETrackedPropertyError
+{
+       TrackedProp_Success                                          = 0,
+       TrackedProp_WrongDataType                            = 1,
+       TrackedProp_WrongDeviceClass                     = 2,
+       TrackedProp_BufferTooSmall                            = 3,
+       TrackedProp_UnknownProperty                            = 4, // Driver has not set the property (and may not ever).
+       TrackedProp_InvalidDevice                            = 5,
+       TrackedProp_CouldNotContactServer              = 6,
+       TrackedProp_ValueNotProvidedByDevice       = 7,
+       TrackedProp_StringExceedsMaximumLength       = 8,
+       TrackedProp_NotYetAvailable                            = 9, // The property value isn't known yet, but is expected soon. Call again later.
+       TrackedProp_PermissionDenied                     = 10,
+       TrackedProp_InvalidOperation                     = 11,
+};
+
+/** Allows the application to control what part of the provided texture will be used in the
+* frame buffer. */
+struct VRTextureBounds_t
+{
+       float uMin, vMin;
+       float uMax, vMax;
+};
+
+/** Allows specifying pose used to render provided scene texture (if different from value returned by WaitGetPoses). */
+struct VRTextureWithPose_t : public Texture_t
+{
+       HmdMatrix34_t mDeviceToAbsoluteTracking; // Actual pose used to render scene textures.
+};
+
+/** Allows the application to control how scene textures are used by the compositor when calling Submit. */
+enum EVRSubmitFlags
+{
+       // Simple render path. App submits rendered left and right eye images with no lens distortion correction applied.
+       Submit_Default = 0x00,
+
+       // App submits final left and right eye images with lens distortion already applied (lens distortion makes the images appear
+       // barrel distorted with chromatic aberration correction applied). The app would have used the data returned by
+       // vr::IVRSystem::ComputeDistortion() to apply the correct distortion to the rendered images before calling Submit().
+       Submit_LensDistortionAlreadyApplied = 0x01,
+
+       // If the texture pointer passed in is actually a renderbuffer (e.g. for MSAA in OpenGL) then set this flag.
+       Submit_GlRenderBuffer = 0x02,
+
+       // Do not use
+       Submit_Reserved = 0x04,
+
+       // Set to indicate that pTexture is a pointer to a VRTextureWithPose_t.
+       Submit_TextureWithPose = 0x08,
+};
+
+/** Data required for passing Vulkan textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct VRVulkanTextureData_t
+{
+       uint64_t m_nImage; // VkImage
+       VkDevice_T *m_pDevice;
+       VkPhysicalDevice_T *m_pPhysicalDevice;
+       VkInstance_T *m_pInstance;
+       VkQueue_T *m_pQueue;
+       uint32_t m_nQueueFamilyIndex;
+       uint32_t m_nWidth, m_nHeight, m_nFormat, m_nSampleCount;
+};
+
+/** Data required for passing D3D12 textures to IVRCompositor::Submit.
+* Be sure to call OpenVR_Shutdown before destroying these resources. */
+struct D3D12TextureData_t
+{
+       ID3D12Resource *m_pResource;
+       ID3D12CommandQueue *m_pCommandQueue;
+       uint32_t m_nNodeMask;
+};
+
+/** Status of the overall system or tracked objects */
+enum EVRState
+{
+       VRState_Undefined = -1,
+       VRState_Off = 0,
+       VRState_Searching = 1,
+       VRState_Searching_Alert = 2,
+       VRState_Ready = 3,
+       VRState_Ready_Alert = 4,
+       VRState_NotReady = 5,
+       VRState_Standby = 6,
+       VRState_Ready_Alert_Low = 7,
+};
+
+/** The types of events that could be posted (and what the parameters mean for each event type) */
+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, // data is controller
+       VREvent_ButtonUnpress                            = 201, // data is controller
+       VREvent_ButtonTouch                                   = 202, // data is controller
+       VREvent_ButtonUntouch                            = 203, // data is controller
+
+       VREvent_MouseMove                                   = 300, // data is mouse
+       VREvent_MouseButtonDown                            = 301, // data is mouse
+       VREvent_MouseButtonUp                            = 302, // data is mouse
+       VREvent_FocusEnter                                   = 303, // data is overlay
+       VREvent_FocusLeave                                   = 304, // data is overlay
+       VREvent_Scroll                                          = 305, // data is mouse
+       VREvent_TouchPadMove                            = 306, // data is mouse
+       VREvent_OverlayFocusChanged                     = 307, // data is overlay, global event
+
+       VREvent_InputFocusCaptured                     = 400, // data is process DEPRECATED
+       VREvent_InputFocusReleased                     = 401, // data is process DEPRECATED
+       VREvent_SceneFocusLost                            = 402, // data is process
+       VREvent_SceneFocusGained                     = 403, // data is process
+       VREvent_SceneApplicationChanged              = 404, // data is process - The App actually drawing the scene changed (usually to or from the compositor)
+       VREvent_SceneFocusChanged                     = 405, // data is process - New app got access to draw the scene
+       VREvent_InputFocusChanged                     = 406, // data is process
+       VREvent_SceneApplicationSecondaryRenderingStarted = 407, // data is process
+
+       VREvent_HideRenderModels                     = 410, // Sent to the scene application to request hiding render models temporarily
+       VREvent_ShowRenderModels                     = 411, // Sent to the scene application to request restoring render model visibility
+
+       VREvent_OverlayShown                            = 500,
+       VREvent_OverlayHidden                            = 501,
+       VREvent_DashboardActivated                     = 502,
+       VREvent_DashboardDeactivated              = 503,
+       VREvent_DashboardThumbSelected              = 504, // Sent to the overlay manager - data is overlay
+       VREvent_DashboardRequested                     = 505, // Sent to the overlay manager - data is overlay
+       VREvent_ResetDashboard                            = 506, // Send to the overlay manager
+       VREvent_RenderToast                                   = 507, // Send to the dashboard to render a toast - data is the notification ID
+       VREvent_ImageLoaded                                   = 508, // Sent to overlays when a SetOverlayRaw or SetOverlayFromFile call finishes loading
+       VREvent_ShowKeyboard                            = 509, // Sent to keyboard renderer in the dashboard to invoke it
+       VREvent_HideKeyboard                            = 510, // Sent to keyboard renderer in the dashboard to hide it
+       VREvent_OverlayGamepadFocusGained       = 511, // Sent to an overlay when IVROverlay::SetFocusOverlay is called on it
+       VREvent_OverlayGamepadFocusLost              = 512, // Send to an overlay when it previously had focus and IVROverlay::SetFocusOverlay is called on something else
+       VREvent_OverlaySharedTextureChanged = 513,
+       VREvent_DashboardGuideButtonDown       = 514,
+       VREvent_DashboardGuideButtonUp              = 515,
+       VREvent_ScreenshotTriggered                     = 516, // Screenshot button combo was pressed, Dashboard should request a screenshot
+       VREvent_ImageFailed                                   = 517, // Sent to overlays when a SetOverlayRaw or SetOverlayfromFail fails to load
+       VREvent_DashboardOverlayCreated              = 518,
+
+       // Screenshot API
+       VREvent_RequestScreenshot                            = 520, // Sent by vrclient application to compositor to take a screenshot
+       VREvent_ScreenshotTaken                                   = 521, // Sent by compositor to the application that the screenshot has been taken
+       VREvent_ScreenshotFailed                            = 522, // Sent by compositor to the application that the screenshot failed to be taken
+       VREvent_SubmitScreenshotToDashboard              = 523, // Sent by compositor to the dashboard that a completed screenshot was submitted
+       VREvent_ScreenshotProgressToDashboard       = 524, // Sent by compositor to the dashboard that a completed screenshot was submitted
+
+       VREvent_PrimaryDashboardDeviceChanged       = 525,
+
+       VREvent_Notification_Shown                            = 600,
+       VREvent_Notification_Hidden                            = 601,
+       VREvent_Notification_BeginInteraction       = 602,
+       VREvent_Notification_Destroyed                     = 603,
+
+       VREvent_Quit                                                 = 700, // data is process
+       VREvent_ProcessQuit                                          = 701, // data is process
+       VREvent_QuitAborted_UserPrompt                     = 702, // data is process
+       VREvent_QuitAcknowledged                            = 703, // data is process
+       VREvent_DriverRequestedQuit                            = 704, // The driver has requested that SteamVR shut down
+
+       VREvent_ChaperoneDataHasChanged                     = 800,
+       VREvent_ChaperoneUniverseHasChanged              = 801,
+       VREvent_ChaperoneTempDataHasChanged              = 802,
+       VREvent_ChaperoneSettingsHaveChanged       = 803,
+       VREvent_SeatedZeroPoseReset                            = 804,
+
+       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_StatusUpdate                                   = 900,
+
+       VREvent_MCImageUpdated                                   = 1000,
+
+       VREvent_FirmwareUpdateStarted                     = 1100,
+       VREvent_FirmwareUpdateFinished                     = 1101,
+
+       VREvent_KeyboardClosed                                   = 1200,
+       VREvent_KeyboardCharInput                            = 1201,
+       VREvent_KeyboardDone                                   = 1202, // Sent when DONE button clicked on keyboard
+
+       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_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,
+       
+       // Vendors are free to expose private events in this reserved region
+       VREvent_VendorSpecific_Reserved_Start       = 10000,
+       VREvent_VendorSpecific_Reserved_End              = 19999,
+};
+
+
+/** Level of Hmd activity */
+// UserInteraction_Timeout means the device is in the process of timing out.
+// InUse = ( k_EDeviceActivityLevel_UserInteraction || k_EDeviceActivityLevel_UserInteraction_Timeout )
+// VREvent_TrackedDeviceUserInteractionStarted fires when the devices transitions from Standby -> UserInteraction or Idle -> UserInteraction.
+// VREvent_TrackedDeviceUserInteractionEnded fires when the devices transitions from UserInteraction_Timeout -> Idle
+enum EDeviceActivityLevel
+{       
+       k_EDeviceActivityLevel_Unknown = -1,                                                               
+       k_EDeviceActivityLevel_Idle = 0,                                          // No activity for the last 10 seconds
+       k_EDeviceActivityLevel_UserInteraction = 1,                            // Activity (movement or prox sensor) is happening now       
+       k_EDeviceActivityLevel_UserInteraction_Timeout = 2,              // No activity for the last 0.5 seconds
+       k_EDeviceActivityLevel_Standby = 3,                                          // Idle for at least 5 seconds (configurable in Settings -> Power Management)
+};
+
+
+/** VR controller button and axis IDs */
+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,
+
+       // aliases for well known controllers
+       k_EButton_SteamVR_Touchpad       = k_EButton_Axis0,
+       k_EButton_SteamVR_Trigger       = k_EButton_Axis1,
+
+       k_EButton_Dashboard_Back       = k_EButton_Grip,
+
+       k_EButton_Max                            = 64
+};
+
+inline uint64_t ButtonMaskFromId( EVRButtonId id ) { return 1ull << id; }
+
+/** used for controller button events */
+struct VREvent_Controller_t
+{
+       uint32_t button; // EVRButtonId enum
+};
+
+
+/** used for simulated mouse events in overlay space */
+enum EVRMouseButton
+{
+       VRMouseButton_Left                                   = 0x0001,
+       VRMouseButton_Right                                   = 0x0002,
+       VRMouseButton_Middle                            = 0x0004,
+};
+
+
+/** used for simulated mouse events in overlay space */
+struct VREvent_Mouse_t
+{
+       float x, y; // co-ords are in GL space, bottom left of the texture is 0,0
+       uint32_t button; // EVRMouseButton enum
+};
+
+/** used for simulated mouse wheel scroll in overlay space */
+struct VREvent_Scroll_t
+{
+       float xdelta, ydelta; // movement in fraction of the pad traversed since last delta, 1.0 for a full swipe
+       uint32_t repeatCount;
+};
+
+/** when in mouse input mode you can receive data from the touchpad, these events are only sent if the users finger
+   is on the touchpad (or just released from it) 
+**/
+struct VREvent_TouchPadMove_t
+{
+       // true if the users finger is detected on the touch pad
+       bool bFingerDown;
+
+       // How long the finger has been down in seconds
+       float flSecondsFingerDown;
+
+       // These values indicate the starting finger position (so you can do some basic swipe stuff)
+       float fValueXFirst;
+       float fValueYFirst;
+
+       // This is the raw sampled coordinate without deadzoning
+       float fValueXRaw;
+       float fValueYRaw;
+};
+
+/** notification related events. Details will still change at this point */
+struct VREvent_Notification_t
+{
+       uint64_t ulUserValue;
+       uint32_t notificationId;
+};
+
+/** Used for events about processes */
+struct VREvent_Process_t
+{
+       uint32_t pid;
+       uint32_t oldPid;
+       bool bForced;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Overlay_t
+{
+       uint64_t overlayHandle;
+};
+
+
+/** Used for a few events about overlays */
+struct VREvent_Status_t
+{
+       uint32_t statusState; // EVRState enum
+};
+
+/** Used for keyboard events **/
+struct VREvent_Keyboard_t
+{
+       char cNewInput[8];       // Up to 11 bytes of new input
+       uint64_t uUserValue;       // Possible flags about the new input
+};
+
+struct VREvent_Ipd_t
+{
+       float ipdMeters;
+};
+
+struct VREvent_Chaperone_t
+{
+       uint64_t m_nPreviousUniverse;
+       uint64_t m_nCurrentUniverse;
+};
+
+/** Not actually used for any events */
+struct VREvent_Reserved_t
+{
+       uint64_t reserved0;
+       uint64_t reserved1;
+};
+
+struct VREvent_PerformanceTest_t
+{
+       uint32_t m_nFidelityLevel;
+};
+
+struct VREvent_SeatedZeroPoseReset_t
+{
+       bool bResetBySystemMenu;
+};
+
+struct VREvent_Screenshot_t
+{
+       uint32_t handle;
+       uint32_t type;
+};
+
+struct VREvent_ScreenshotProgress_t
+{
+       float progress;
+};
+
+struct VREvent_ApplicationLaunch_t
+{
+       uint32_t pid;
+       uint32_t unArgsHandle;
+};
+
+struct VREvent_EditingCameraSurface_t
+{
+       uint64_t overlayHandle;
+       uint32_t nVisualMode;
+};
+
+struct VREvent_MessageOverlay_t
+{
+       uint32_t unVRMessageOverlayResponse; // vr::VRMessageOverlayResponse enum
+};
+
+struct VREvent_Property_t
+{
+       PropertyContainerHandle_t container;
+       ETrackedDeviceProperty prop;
+};
+
+/** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py */
+typedef union
+{
+       VREvent_Reserved_t reserved;
+       VREvent_Controller_t controller;
+       VREvent_Mouse_t mouse;
+       VREvent_Scroll_t scroll;
+       VREvent_Process_t process;
+       VREvent_Notification_t notification;
+       VREvent_Overlay_t overlay;
+       VREvent_Status_t status;
+       VREvent_Keyboard_t keyboard;
+       VREvent_Ipd_t ipd;
+       VREvent_Chaperone_t chaperone;
+       VREvent_PerformanceTest_t performanceTest;
+       VREvent_TouchPadMove_t touchPadMove;
+       VREvent_SeatedZeroPoseReset_t seatedZeroPoseReset;
+       VREvent_Screenshot_t screenshot;
+       VREvent_ScreenshotProgress_t screenshotProgress;
+       VREvent_ApplicationLaunch_t applicationLaunch;
+       VREvent_EditingCameraSurface_t cameraSurface;
+       VREvent_MessageOverlay_t messageOverlay;
+       VREvent_Property_t property;
+} VREvent_Data_t;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** An event posted by the server to all running applications */
+struct VREvent_t
+{
+       uint32_t eventType; // EVREventType enum
+       TrackedDeviceIndex_t trackedDeviceIndex;
+       float eventAgeSeconds;
+       // event data must be the end of the struct as its size is variable
+       VREvent_Data_t data;
+};
+
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+/** The mesh to draw into the stencil (or depth) buffer to perform 
+* early stencil (or depth) kills of pixels that will never appear on the HMD.
+* This mesh draws on all the pixels that will be hidden after distortion. 
+*
+* If the HMD does not provide a visible area mesh pVertexData will be
+* NULL and unTriangleCount will be 0. */
+struct HiddenAreaMesh_t
+{
+       const HmdVector2_t *pVertexData;
+       uint32_t unTriangleCount;
+};
+
+
+enum EHiddenAreaMeshType
+{
+       k_eHiddenAreaMesh_Standard = 0,
+       k_eHiddenAreaMesh_Inverse = 1,
+       k_eHiddenAreaMesh_LineLoop = 2,
+
+       k_eHiddenAreaMesh_Max = 3,
+};
+
+
+/** Identifies what kind of axis is on the controller at index n. Read this type 
+* with pVRSystem->Get( nControllerDeviceIndex, Prop_Axis0Type_Int32 + n );
+*/
+enum EVRControllerAxisType
+{
+       k_eControllerAxis_None = 0,
+       k_eControllerAxis_TrackPad = 1,
+       k_eControllerAxis_Joystick = 2,
+       k_eControllerAxis_Trigger = 3, // Analog trigger data is in the X axis
+};
+
+
+/** contains information about one axis on the controller */
+struct VRControllerAxis_t
+{
+       float x; // Ranges from -1.0 to 1.0 for joysticks and track pads. Ranges from 0.0 to 1.0 for triggers were 0 is fully released.
+       float y; // Ranges from -1.0 to 1.0 for joysticks and track pads. Is always 0.0 for triggers.
+};
+
+
+/** the number of axes in the controller state */
+static const uint32_t k_unControllerStateAxisCount = 5;
+
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+/** Holds all the state of a controller at one moment in time. */
+struct VRControllerState001_t
+{
+       // If packet num matches that on your prior call, then the controller state hasn't been changed since 
+       // your last call and there is no need to process it
+       uint32_t unPacketNum;
+
+       // bit flags for each of the buttons. Use ButtonMaskFromId to turn an ID into a mask
+       uint64_t ulButtonPressed;
+       uint64_t ulButtonTouched;
+
+       // Axis data for the controller's analog inputs
+       VRControllerAxis_t rAxis[ k_unControllerStateAxisCount ];
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+typedef VRControllerState001_t VRControllerState_t;
+
+
+/** determines how to provide output to the application of various event processing functions. */
+enum EVRControllerEventOutputType
+{
+       ControllerEventOutput_OSEvents = 0,
+       ControllerEventOutput_VREvents = 1,
+};
+
+
+
+/** Collision Bounds Style */
+enum ECollisionBoundsStyle
+{
+       COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+       COLLISION_BOUNDS_STYLE_INTERMEDIATE,
+       COLLISION_BOUNDS_STYLE_SQUARES,
+       COLLISION_BOUNDS_STYLE_ADVANCED,
+       COLLISION_BOUNDS_STYLE_NONE,
+
+       COLLISION_BOUNDS_STYLE_COUNT
+};
+
+/** Allows the application to customize how the overlay appears in the compositor */
+struct Compositor_OverlaySettings
+{
+       uint32_t size; // sizeof(Compositor_OverlaySettings)
+       bool curved, antialias;
+       float scale, distance, alpha;
+       float uOffset, vOffset, uScale, vScale;
+       float gridDivs, gridWidth, gridScale;
+       HmdMatrix44_t transform;
+};
+
+/** used to refer to a single VR overlay */
+typedef uint64_t VROverlayHandle_t;
+
+static const VROverlayHandle_t k_ulOverlayHandleInvalid = 0;
+
+/** Errors that can occur around VR overlays */
+enum EVROverlayError
+{
+       VROverlayError_None                                          = 0,
+
+       VROverlayError_UnknownOverlay                     = 10,
+       VROverlayError_InvalidHandle                     = 11,
+       VROverlayError_PermissionDenied                     = 12,
+       VROverlayError_OverlayLimitExceeded              = 13, // No more overlays could be created because the maximum number already exist
+       VROverlayError_WrongVisibilityType              = 14,
+       VROverlayError_KeyTooLong                            = 15,
+       VROverlayError_NameTooLong                            = 16,
+       VROverlayError_KeyInUse                                   = 17,
+       VROverlayError_WrongTransformType              = 18,
+       VROverlayError_InvalidTrackedDevice              = 19,
+       VROverlayError_InvalidParameter                     = 20,
+       VROverlayError_ThumbnailCantBeDestroyed       = 21,
+       VROverlayError_ArrayTooSmall                     = 22,
+       VROverlayError_RequestFailed                     = 23,
+       VROverlayError_InvalidTexture                     = 24,
+       VROverlayError_UnableToLoadFile                     = 25,
+       VROverlayError_KeyboardAlreadyInUse              = 26,
+       VROverlayError_NoNeighbor                            = 27,
+       VROverlayError_TooManyMaskPrimitives       = 29,
+       VROverlayError_BadMaskPrimitive                     = 30,
+};
+
+/** enum values to pass in to VR_Init to identify whether the application will 
+* draw a 3D scene. */
+enum EVRApplicationType
+{
+       VRApplication_Other = 0,              // Some other kind of application that isn't covered by the other entries 
+       VRApplication_Scene       = 1,              // Application will submit 3D frames 
+       VRApplication_Overlay = 2,              // Application only interacts with overlays
+       VRApplication_Background = 3,       // Application should not start SteamVR if it's not already running, and should not
+                                                               // keep it running if everything else quits.
+       VRApplication_Utility = 4,              // Init should not try to load any drivers. The application needs access to utility
+                                                               // interfaces (like IVRSettings and IVRApplications) but not hardware.
+       VRApplication_VRMonitor = 5,       // Reserved for vrmonitor
+       VRApplication_SteamWatchdog = 6,// Reserved for Steam
+       VRApplication_Bootstrapper = 7, // Start up SteamVR
+
+       VRApplication_Max
+};
+
+
+/** error codes for firmware */
+enum EVRFirmwareError
+{
+       VRFirmwareError_None = 0,
+       VRFirmwareError_Success = 1,
+       VRFirmwareError_Fail = 2,
+};
+
+
+/** error codes for notifications */
+enum EVRNotificationError
+{
+       VRNotificationError_OK = 0,
+       VRNotificationError_InvalidNotificationId = 100,
+       VRNotificationError_NotificationQueueFull = 101,
+       VRNotificationError_InvalidOverlayHandle = 102,
+       VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+};
+
+
+/** error codes returned by Vr_Init */
+
+// Please add adequate error description to https://developer.valvesoftware.com/w/index.php?title=Category:SteamVRHelp
+enum EVRInitError
+{
+       VRInitError_None       = 0,
+       VRInitError_Unknown = 1,
+
+       VRInitError_Init_InstallationNotFound                     = 100,
+       VRInitError_Init_InstallationCorrupt                     = 101,
+       VRInitError_Init_VRClientDLLNotFound                     = 102,
+       VRInitError_Init_FileNotFound                                   = 103,
+       VRInitError_Init_FactoryNotFound                            = 104,
+       VRInitError_Init_InterfaceNotFound                            = 105,
+       VRInitError_Init_InvalidInterface                            = 106,
+       VRInitError_Init_UserConfigDirectoryInvalid              = 107,
+       VRInitError_Init_HmdNotFound                                   = 108,
+       VRInitError_Init_NotInitialized                                   = 109,
+       VRInitError_Init_PathRegistryNotFound                     = 110,
+       VRInitError_Init_NoConfigPath                                   = 111,
+       VRInitError_Init_NoLogPath                                          = 112,
+       VRInitError_Init_PathRegistryNotWritable              = 113,
+       VRInitError_Init_AppInfoInitFailed                            = 114,
+       VRInitError_Init_Retry                                                 = 115, // Used internally to cause retries to vrserver
+       VRInitError_Init_InitCanceledByUser                            = 116, // The calling application should silently exit. The user canceled app startup
+       VRInitError_Init_AnotherAppLaunching                     = 117, 
+       VRInitError_Init_SettingsInitFailed                            = 118, 
+       VRInitError_Init_ShuttingDown                                   = 119,
+       VRInitError_Init_TooManyObjects                                   = 120,
+       VRInitError_Init_NoServerForBackgroundApp              = 121,
+       VRInitError_Init_NotSupportedWithCompositor              = 122,
+       VRInitError_Init_NotAvailableToUtilityApps              = 123,
+       VRInitError_Init_Internal                                           = 124,
+       VRInitError_Init_HmdDriverIdIsNone                             = 125,
+       VRInitError_Init_HmdNotFoundPresenceFailed               = 126,
+       VRInitError_Init_VRMonitorNotFound                            = 127,
+       VRInitError_Init_VRMonitorStartupFailed                     = 128,
+       VRInitError_Init_LowPowerWatchdogNotSupported       = 129, 
+       VRInitError_Init_InvalidApplicationType                     = 130,
+       VRInitError_Init_NotAvailableToWatchdogApps              = 131,
+       VRInitError_Init_WatchdogDisabledInSettings              = 132,
+       VRInitError_Init_VRDashboardNotFound                     = 133,
+       VRInitError_Init_VRDashboardStartupFailed              = 134,
+       VRInitError_Init_VRHomeNotFound                                   = 135,
+       VRInitError_Init_VRHomeStartupFailed                     = 136,
+       VRInitError_Init_RebootingBusy                                   = 137,
+       VRInitError_Init_FirmwareUpdateBusy                            = 138,
+       VRInitError_Init_FirmwareRecoveryBusy                     = 139,
+
+
+       VRInitError_Driver_Failed                                          = 200,
+       VRInitError_Driver_Unknown                                          = 201,
+       VRInitError_Driver_HmdUnknown                                   = 202,
+       VRInitError_Driver_NotLoaded                                   = 203,
+       VRInitError_Driver_RuntimeOutOfDate                            = 204,
+       VRInitError_Driver_HmdInUse                                          = 205,
+       VRInitError_Driver_NotCalibrated                            = 206,
+       VRInitError_Driver_CalibrationInvalid                     = 207,
+       VRInitError_Driver_HmdDisplayNotFound                     = 208,
+       VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+       // VRInitError_Driver_HmdDisplayNotFoundAfterFix = 210, // not needed: here for historic reasons
+       VRInitError_Driver_HmdDriverIdOutOfBounds              = 211,
+       VRInitError_Driver_HmdDisplayMirrored                     = 212,
+
+       VRInitError_IPC_ServerInitFailed                            = 300,
+       VRInitError_IPC_ConnectFailed                                   = 301,
+       VRInitError_IPC_SharedStateInitFailed                     = 302,
+       VRInitError_IPC_CompositorInitFailed                     = 303,
+       VRInitError_IPC_MutexInitFailed                                   = 304,
+       VRInitError_IPC_Failed                                                 = 305,
+       VRInitError_IPC_CompositorConnectFailed                     = 306,
+       VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+       VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+
+       VRInitError_Compositor_Failed                                   = 400,
+       VRInitError_Compositor_D3D11HardwareRequired       = 401,
+       VRInitError_Compositor_FirmwareRequiresUpdate       = 402,
+       VRInitError_Compositor_OverlayInitFailed              = 403,
+       VRInitError_Compositor_ScreenshotsInitFailed       = 404,
+       VRInitError_Compositor_UnableToCreateDevice              = 405,
+
+       VRInitError_VendorSpecific_UnableToConnectToOculusRuntime              = 1000,
+
+       VRInitError_VendorSpecific_HmdFound_CantOpenDevice                             = 1101,
+       VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart       = 1102,
+       VRInitError_VendorSpecific_HmdFound_NoStoredConfig                             = 1103,
+       VRInitError_VendorSpecific_HmdFound_ConfigTooBig                             = 1104,
+       VRInitError_VendorSpecific_HmdFound_ConfigTooSmall                             = 1105,
+       VRInitError_VendorSpecific_HmdFound_UnableToInitZLib                      = 1106,
+       VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion        = 1107,
+       VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart       = 1108,
+       VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart       = 1109,
+       VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext              = 1110,
+       VRInitError_VendorSpecific_HmdFound_UserDataAddressRange              = 1111,
+       VRInitError_VendorSpecific_HmdFound_UserDataError                            = 1112,
+       VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck              = 1113,
+
+       VRInitError_Steam_SteamInstallationNotFound = 2000,
+};
+
+enum EVRScreenshotType
+{
+       VRScreenshotType_None = 0,
+       VRScreenshotType_Mono = 1, // left eye only
+       VRScreenshotType_Stereo = 2,
+       VRScreenshotType_Cubemap = 3,
+       VRScreenshotType_MonoPanorama = 4,
+       VRScreenshotType_StereoPanorama = 5
+};
+
+enum EVRScreenshotPropertyFilenames
+{
+       VRScreenshotPropertyFilenames_Preview = 0,
+       VRScreenshotPropertyFilenames_VR = 1,
+};
+
+enum EVRTrackedCameraError
+{
+       VRTrackedCameraError_None                       = 0,
+       VRTrackedCameraError_OperationFailed            = 100,
+       VRTrackedCameraError_InvalidHandle              = 101,       
+       VRTrackedCameraError_InvalidFrameHeaderVersion  = 102,
+       VRTrackedCameraError_OutOfHandles               = 103,
+       VRTrackedCameraError_IPCFailure                 = 104,
+       VRTrackedCameraError_NotSupportedForThisDevice  = 105,
+       VRTrackedCameraError_SharedMemoryFailure        = 106,
+       VRTrackedCameraError_FrameBufferingFailure      = 107,
+       VRTrackedCameraError_StreamSetupFailure         = 108,
+       VRTrackedCameraError_InvalidGLTextureId         = 109,
+       VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+       VRTrackedCameraError_FailedToGetGLTextureId     = 111,
+       VRTrackedCameraError_SharedTextureFailure       = 112,
+       VRTrackedCameraError_NoFrameAvailable           = 113,
+       VRTrackedCameraError_InvalidArgument            = 114,
+       VRTrackedCameraError_InvalidFrameBufferSize     = 115,
+};
+
+enum EVRTrackedCameraFrameType
+{
+       VRTrackedCameraFrameType_Distorted = 0,                     // This is the camera video frame size in pixels, still distorted.
+       VRTrackedCameraFrameType_Undistorted,                     // In pixels, an undistorted inscribed rectangle region without invalid regions. This size is subject to changes shortly.
+       VRTrackedCameraFrameType_MaximumUndistorted,       // In pixels, maximum undistorted with invalid regions. Non zero alpha component identifies valid regions.
+       MAX_CAMERA_FRAME_TYPES
+};
+
+typedef uint64_t TrackedCameraHandle_t;
+#define INVALID_TRACKED_CAMERA_HANDLE       ((vr::TrackedCameraHandle_t)0)
+
+struct CameraVideoStreamFrameHeader_t
+{
+       EVRTrackedCameraFrameType eFrameType;
+
+       uint32_t nWidth;
+       uint32_t nHeight;
+       uint32_t nBytesPerPixel;
+
+       uint32_t nFrameSequence;
+
+       TrackedDevicePose_t standingTrackedDevicePose;
+};
+
+// Screenshot types
+typedef uint32_t ScreenshotHandle_t;
+
+static const uint32_t k_unScreenshotHandleInvalid = 0;
+
+#pragma pack( pop )
+
+// figure out how to import from the VR API dll
+#if defined(_WIN32)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __declspec( dllexport )
+#else
+#define VR_INTERFACE extern "C" __declspec( dllimport )
+#endif
+
+#elif defined(__GNUC__) || defined(COMPILER_GCC) || defined(__APPLE__)
+
+#ifdef VR_API_EXPORT
+#define VR_INTERFACE extern "C" __attribute__((visibility("default")))
+#else
+#define VR_INTERFACE extern "C" 
+#endif
+
+#else
+#error "Unsupported Platform."
+#endif
+
+
+#if defined( _WIN32 )
+#define VR_CALLTYPE __cdecl
+#else
+#define VR_CALLTYPE 
+#endif
+
+} // namespace vr
+
+#endif // _INCLUDE_VRTYPES_H
+
+
+// vrannotation.h
+#ifdef API_GEN
+# define VR_CLANG_ATTR(ATTR) __attribute__((annotate( ATTR )))
+#else
+# define VR_CLANG_ATTR(ATTR)
+#endif
+
+#define VR_METHOD_DESC(DESC) VR_CLANG_ATTR( "desc:" #DESC ";" )
+#define VR_IGNOREATTR() VR_CLANG_ATTR( "ignore" )
+#define VR_OUT_STRUCT() VR_CLANG_ATTR( "out_struct: ;" )
+#define VR_OUT_STRING() VR_CLANG_ATTR( "out_string: ;" )
+#define VR_OUT_ARRAY_CALL(COUNTER,FUNCTION,PARAMS) VR_CLANG_ATTR( "out_array_call:" #COUNTER "," #FUNCTION "," #PARAMS ";" )
+#define VR_OUT_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "out_array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT(COUNTER) VR_CLANG_ATTR( "array_count:" #COUNTER ";" )
+#define VR_ARRAY_COUNT_D(COUNTER, DESC) VR_CLANG_ATTR( "array_count:" #COUNTER ";desc:" #DESC )
+#define VR_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "buffer_count:" #COUNTER ";" )
+#define VR_OUT_BUFFER_COUNT(COUNTER) VR_CLANG_ATTR( "out_buffer_count:" #COUNTER ";" )
+#define VR_OUT_STRING_COUNT(COUNTER) VR_CLANG_ATTR( "out_string_count:" #COUNTER ";" )
+
+// ivrsystem.h
+namespace vr
+{
+
+class IVRSystem
+{
+public:
+
+
+       // ------------------------------------
+       // Display Methods
+       // ------------------------------------
+
+       /** Suggested size for the intermediate render target that the distortion pulls from. */
+       virtual void GetRecommendedRenderTargetSize( uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+       /** The projection matrix for the specified eye */
+       virtual HmdMatrix44_t GetProjectionMatrix( EVREye eEye, float fNearZ, float fFarZ ) = 0;
+
+       /** The components necessary to build your own projection matrix in case your
+       * application is doing something fancy like infinite Z */
+       virtual void GetProjectionRaw( EVREye eEye, float *pfLeft, float *pfRight, float *pfTop, float *pfBottom ) = 0;
+
+       /** Gets the result of the distortion function for the specified eye and input UVs. UVs go from 0,0 in 
+       * the upper left of that eye's viewport and 1,1 in the lower right of that eye's viewport.
+       * Returns true for success. Otherwise, returns false, and distortion coordinates are not suitable. */
+       virtual bool ComputeDistortion( EVREye eEye, float fU, float fV, DistortionCoordinates_t *pDistortionCoordinates ) = 0;
+
+       /** Returns the transform from eye space to the head space. Eye space is the per-eye flavor of head
+       * space that provides stereo disparity. Instead of Model * View * Projection the sequence is Model * View * Eye^-1 * Projection. 
+       * Normally View and Eye^-1 will be multiplied together and treated as View in your application. 
+       */
+       virtual HmdMatrix34_t GetEyeToHeadTransform( EVREye eEye ) = 0;
+
+       /** Returns the number of elapsed seconds since the last recorded vsync event. This 
+       *       will come from a vsync timer event in the timer if possible or from the application-reported
+       *   time if that is not available. If no vsync times are available the function will 
+       *   return zero for vsync time and frame counter and return false from the method. */
+       virtual bool GetTimeSinceLastVsync( float *pfSecondsSinceLastVsync, uint64_t *pulFrameCounter ) = 0;
+
+       /** [D3D9 Only]
+       * Returns the adapter index that the user should pass into CreateDevice to set up D3D9 in such
+       * a way that it can go full screen exclusive on the HMD. Returns -1 if there was an error.
+       */
+       virtual int32_t GetD3D9AdapterIndex() = 0;
+
+       /** [D3D10/11 Only]
+       * Returns the adapter index that the user should pass into EnumAdapters to create the device 
+       * and swap chain in DX10 and DX11. If an error occurs the index will be set to -1.
+       */
+       virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex ) = 0;
+       
+       /**
+        * Returns platform- and texture-type specific adapter identification so that applications and the
+        * compositor are creating textures and swap chains on the same GPU. If an error occurs the device
+        * will be set to 0.
+        * pInstance is an optional parameter that is required only when textureType is TextureType_Vulkan.
+        * [D3D10/11/12 Only (D3D9 Not Supported)]
+        *  Returns the adapter LUID that identifies the GPU attached to the HMD. The user should
+        *  enumerate all adapters using IDXGIFactory::EnumAdapters and IDXGIAdapter::GetDesc to find
+        *  the adapter with the matching LUID, or use IDXGIFactory4::EnumAdapterByLuid.
+        *  The discovered IDXGIAdapter should be used to create the device and swap chain.
+        * [Vulkan Only]
+        *  Returns the VkPhysicalDevice that should be used by the application.
+        *  pInstance must be the instance the application will use to query for the VkPhysicalDevice.  The application
+        *  must create the VkInstance with extensions returned by IVRCompositor::GetVulkanInstanceExtensionsRequired enabled.
+        * [macOS Only]
+        *  Returns an id<MTLDevice> that should be used by the application.
+        */
+       virtual void GetOutputDevice( uint64_t *pnDevice, ETextureType textureType, VkInstance_T *pInstance = nullptr ) = 0;
+
+       // ------------------------------------
+       // Display Mode methods
+       // ------------------------------------
+
+       /** Use to determine if the headset display is part of the desktop (i.e. extended) or hidden (i.e. direct mode). */
+       virtual bool IsDisplayOnDesktop() = 0;
+
+       /** Set the display visibility (true = extended, false = direct mode).  Return value of true indicates that the change was successful. */
+       virtual bool SetDisplayVisibility( bool bIsVisibleOnDesktop ) = 0;
+
+       // ------------------------------------
+       // Tracking Methods
+       // ------------------------------------
+
+       /** The pose that the tracker thinks that the HMD will be in at the specified number of seconds into the 
+       * future. Pass 0 to get the state at the instant the method is called. Most of the time the application should
+       * calculate the time until the photons will be emitted from the display and pass that time into the method.
+       *
+       * This is roughly analogous to the inverse of the view matrix in most applications, though 
+       * many games will need to do some additional rotation or translation on top of the rotation
+       * and translation provided by the head pose.
+       *
+       * For devices where bPoseIsValid is true the application can use the pose to position the device
+       * in question. The provided array can be any size up to k_unMaxTrackedDeviceCount. 
+       *
+       * Seated experiences should call this method with TrackingUniverseSeated and receive poses relative
+       * to the seated zero pose. Standing experiences should call this method with TrackingUniverseStanding 
+       * and receive poses relative to the Chaperone Play Area. TrackingUniverseRawAndUncalibrated should 
+       * probably not be used unless the application is the Chaperone calibration tool itself, but will provide
+       * poses relative to the hardware-specific coordinate system in the driver.
+       */
+       virtual void GetDeviceToAbsoluteTrackingPose( ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, VR_ARRAY_COUNT(unTrackedDevicePoseArrayCount) TrackedDevicePose_t *pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount ) = 0;
+
+       /** Sets the zero pose for the seated tracker coordinate system to the current position and yaw of the HMD. After 
+       * ResetSeatedZeroPose all GetDeviceToAbsoluteTrackingPose calls that pass TrackingUniverseSeated as the origin 
+       * will be relative to this new zero pose. The new zero coordinate system will not change the fact that the Y axis 
+       * is up in the real world, so the next pose returned from GetDeviceToAbsoluteTrackingPose after a call to 
+       * ResetSeatedZeroPose may not be exactly an identity matrix.
+       *
+       * NOTE: This function overrides the user's previously saved seated zero pose and should only be called as the result of a user action. 
+       * Users are also able to set their seated zero pose via the OpenVR Dashboard.
+       **/
+       virtual void ResetSeatedZeroPose() = 0;
+
+       /** Returns the transform from the seated zero pose to the standing absolute tracking system. This allows 
+       * applications to represent the seated origin to used or transform object positions from one coordinate
+       * system to the other. 
+       *
+       * The seated origin may or may not be inside the Play Area or Collision Bounds returned by IVRChaperone. Its position 
+       * depends on what the user has set from the Dashboard settings and previous calls to ResetSeatedZeroPose. */
+       virtual HmdMatrix34_t GetSeatedZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+       /** Returns the transform from the tracking origin to the standing absolute tracking system. This allows
+       * applications to convert from raw tracking space to the calibrated standing coordinate system. */
+       virtual HmdMatrix34_t GetRawZeroPoseToStandingAbsoluteTrackingPose() = 0;
+
+       /** Get a sorted array of device indices of a given class of tracked devices (e.g. controllers).  Devices are sorted right to left
+       * relative to the specified tracked device (default: hmd -- pass in -1 for absolute tracking space).  Returns the number of devices
+       * in the list, or the size of the array needed if not large enough. */
+       virtual uint32_t GetSortedTrackedDeviceIndicesOfClass( ETrackedDeviceClass eTrackedDeviceClass, VR_ARRAY_COUNT(unTrackedDeviceIndexArrayCount) vr::TrackedDeviceIndex_t *punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, vr::TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex = k_unTrackedDeviceIndex_Hmd ) = 0;
+
+       /** Returns the level of activity on the device. */
+       virtual EDeviceActivityLevel GetTrackedDeviceActivityLevel( vr::TrackedDeviceIndex_t unDeviceId ) = 0;
+
+       /** Convenience utility to apply the specified transform to the specified pose.
+       *   This properly transforms all pose components, including velocity and angular velocity
+       */
+       virtual void ApplyTransform( TrackedDevicePose_t *pOutputPose, const TrackedDevicePose_t *pTrackedDevicePose, const HmdMatrix34_t *pTransform ) = 0;
+
+       /** Returns the device index associated with a specific role, for example the left hand or the right hand. */
+       virtual vr::TrackedDeviceIndex_t GetTrackedDeviceIndexForControllerRole( vr::ETrackedControllerRole unDeviceType ) = 0;
+
+       /** Returns the controller type associated with a device index. */
+       virtual vr::ETrackedControllerRole GetControllerRoleForTrackedDeviceIndex( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+       // ------------------------------------
+       // Property methods
+       // ------------------------------------
+
+       /** Returns the device class of a tracked device. If there has not been a device connected in this slot
+       * since the application started this function will return TrackedDevice_Invalid. For previous detected
+       * devices the function will return the previously observed device class. 
+       *
+       * To determine which devices exist on the system, just loop from 0 to k_unMaxTrackedDeviceCount and check
+       * the device class. Every device with something other than TrackedDevice_Invalid is associated with an 
+       * actual tracked device. */
+       virtual ETrackedDeviceClass GetTrackedDeviceClass( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+       /** Returns true if there is a device connected in this slot. */
+       virtual bool IsTrackedDeviceConnected( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+       /** Returns a bool property. If the device index is not valid or the property is not a bool type this function will return false. */
+       virtual bool GetBoolTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+       /** Returns a float property. If the device index is not valid or the property is not a float type this function will return 0. */
+       virtual float GetFloatTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+       /** Returns an int property. If the device index is not valid or the property is not a int type this function will return 0. */
+       virtual int32_t GetInt32TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+       /** Returns a uint64 property. If the device index is not valid or the property is not a uint64 type this function will return 0. */
+       virtual uint64_t GetUint64TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+       /** Returns a matrix property. If the device index is not valid or the property is not a matrix type, this function will return identity. */
+       virtual HmdMatrix34_t GetMatrix34TrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError *pError = 0L ) = 0;
+
+       /** Returns a string property. If the device index is not valid or the property is not a string type this function will 
+       * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+       * null. Strings will always fit in buffers of k_unMaxPropertyStringSize characters. */
+       virtual uint32_t GetStringTrackedDeviceProperty( vr::TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, ETrackedPropertyError *pError = 0L ) = 0;
+
+       /** returns a string that corresponds with the specified property error. The string will be the name 
+       * of the error enum value for all valid error codes */
+       virtual const char *GetPropErrorNameFromEnum( ETrackedPropertyError error ) = 0;
+
+       // ------------------------------------
+       // Event methods
+       // ------------------------------------
+
+       /** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+       * this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+       virtual bool PollNextEvent( VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+       /** Returns true and fills the event with the next event on the queue if there is one. If there are no events
+       * this method returns false. Fills in the pose of the associated tracked device in the provided pose struct. 
+       * This pose will always be older than the call to this function and should not be used to render the device. 
+       uncbVREvent should be the size in bytes of the VREvent_t struct */
+       virtual bool PollNextEventWithPose( ETrackingUniverseOrigin eOrigin, VREvent_t *pEvent, uint32_t uncbVREvent, vr::TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+       /** returns the name of an EVREvent enum value */
+       virtual const char *GetEventTypeNameFromEnum( EVREventType eType ) = 0;
+
+       // ------------------------------------
+       // Rendering helper methods
+       // ------------------------------------
+
+       /** Returns the hidden area mesh for the current HMD. The pixels covered by this mesh will never be seen by the user after the lens distortion is
+       * applied based on visibility to the panels. If this HMD does not have a hidden area mesh, the vertex data and count will be NULL and 0 respectively.
+       * This mesh is meant to be rendered into the stencil buffer (or into the depth buffer setting nearz) before rendering each eye's view. 
+       * This will improve performance by letting the GPU early-reject pixels the user will never see before running the pixel shader.
+       * NOTE: Render this mesh with backface culling disabled since the winding order of the vertices can be different per-HMD or per-eye.
+       * Setting the bInverse argument to true will produce the visible area mesh that is commonly used in place of full-screen quads. The visible area mesh covers all of the pixels the hidden area mesh does not cover.
+       * Setting the bLineLoop argument will return a line loop of vertices in HiddenAreaMesh_t->pVertexData with HiddenAreaMesh_t->unTriangleCount set to the number of vertices.
+       */
+       virtual HiddenAreaMesh_t GetHiddenAreaMesh( EVREye eEye, EHiddenAreaMeshType type = k_eHiddenAreaMesh_Standard ) = 0;
+
+       // ------------------------------------
+       // Controller methods
+       // ------------------------------------
+
+       /** Fills the supplied struct with the current state of the controller. Returns false if the controller index
+       * is invalid. */
+       virtual bool GetControllerState( vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize ) = 0;
+
+       /** fills the supplied struct with the current state of the controller and the provided pose with the pose of 
+       * the controller when the controller state was updated most recently. Use this form if you need a precise controller
+       * pose as input to your application when the user presses or releases a button. */
+       virtual bool GetControllerStateWithPose( ETrackingUniverseOrigin eOrigin, vr::TrackedDeviceIndex_t unControllerDeviceIndex, vr::VRControllerState_t *pControllerState, uint32_t unControllerStateSize, TrackedDevicePose_t *pTrackedDevicePose ) = 0;
+
+       /** Trigger a single haptic pulse on a controller. After this call the application may not trigger another haptic pulse on this controller
+       * and axis combination for 5ms. */
+       virtual void TriggerHapticPulse( vr::TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec ) = 0;
+
+       /** returns the name of an EVRButtonId enum value */
+       virtual const char *GetButtonIdNameFromEnum( EVRButtonId eButtonId ) = 0;
+
+       /** returns the name of an EVRControllerAxisType enum value */
+       virtual const char *GetControllerAxisTypeNameFromEnum( EVRControllerAxisType eAxisType ) = 0;
+
+       /** Tells OpenVR that this process wants exclusive access to controller button states and button events. Other apps will be notified that 
+       * they have lost input focus with a VREvent_InputFocusCaptured event. Returns false if input focus could not be captured for
+       * some reason. */
+       virtual bool CaptureInputFocus() = 0;
+
+       /** Tells OpenVR that this process no longer wants exclusive access to button states and button events. Other apps will be notified 
+       * that input focus has been released with a VREvent_InputFocusReleased event. */
+       virtual void ReleaseInputFocus() = 0;
+
+       /** Returns true if input focus is captured by another process. */
+       virtual bool IsInputFocusCapturedByAnotherProcess() = 0;
+
+       // ------------------------------------
+       // Debug Methods
+       // ------------------------------------
+
+       /** Sends a request to the driver for the specified device and returns the response. The maximum response size is 32k,
+       * but this method can be called with a smaller buffer. If the response exceeds the size of the buffer, it is truncated. 
+       * The size of the response including its terminating null is returned. */
+       virtual uint32_t DriverDebugRequest( vr::TrackedDeviceIndex_t unDeviceIndex, const char *pchRequest, char *pchResponseBuffer, uint32_t unResponseBufferSize ) = 0;
+
+       // ------------------------------------
+       // Firmware methods
+       // ------------------------------------
+       
+       /** Performs the actual firmware update if applicable. 
+        * The following events will be sent, if VRFirmwareError_None was returned: VREvent_FirmwareUpdateStarted, VREvent_FirmwareUpdateFinished 
+        * Use the properties Prop_Firmware_UpdateAvailable_Bool, Prop_Firmware_ManualUpdate_Bool, and Prop_Firmware_ManualUpdateURL_String
+        * to figure our whether a firmware update is available, and to figure out whether its a manual update 
+        * Prop_Firmware_ManualUpdateURL_String should point to an URL describing the manual update process */
+       virtual vr::EVRFirmwareError PerformFirmwareUpdate( vr::TrackedDeviceIndex_t unDeviceIndex ) = 0;
+
+       // ------------------------------------
+       // Application life cycle methods
+       // ------------------------------------
+
+       /** Call this to acknowledge to the system that VREvent_Quit has been received and that the process is exiting.
+       * This extends the timeout until the process is killed. */
+       virtual void AcknowledgeQuit_Exiting() = 0;
+
+       /** Call this to tell the system that the user is being prompted to save data. This
+       * halts the timeout and dismisses the dashboard (if it was up). Applications should be sure to actually 
+       * prompt the user to save and then exit afterward, otherwise the user will be left in a confusing state. */
+       virtual void AcknowledgeQuit_UserPrompt() = 0;
+
+};
+
+static const char * const IVRSystem_Version = "IVRSystem_017";
+
+}
+
+
+// ivrapplications.h
+namespace vr
+{
+
+       /** Used for all errors reported by the IVRApplications interface */
+       enum EVRApplicationError
+       {
+              VRApplicationError_None = 0,
+
+              VRApplicationError_AppKeyAlreadyExists = 100,       // Only one application can use any given key
+              VRApplicationError_NoManifest = 101,                     // the running application does not have a manifest
+              VRApplicationError_NoApplication = 102,                     // No application is running
+              VRApplicationError_InvalidIndex = 103,
+              VRApplicationError_UnknownApplication = 104,       // the application could not be found
+              VRApplicationError_IPCFailed = 105,                            // An IPC failure caused the request to fail
+              VRApplicationError_ApplicationAlreadyRunning = 106, 
+              VRApplicationError_InvalidManifest = 107,
+              VRApplicationError_InvalidApplication = 108,
+              VRApplicationError_LaunchFailed = 109,                     // the process didn't start
+              VRApplicationError_ApplicationAlreadyStarting = 110, // the system was already starting the same application
+              VRApplicationError_LaunchInProgress = 111,              // The system was already starting a different application
+              VRApplicationError_OldApplicationQuitting = 112, 
+              VRApplicationError_TransitionAborted = 113,
+              VRApplicationError_IsTemplate = 114, // error when you try to call LaunchApplication() on a template type app (use LaunchTemplateApplication)
+              VRApplicationError_SteamVRIsExiting = 115,
+
+              VRApplicationError_BufferTooSmall = 200,              // The provided buffer was too small to fit the requested data
+              VRApplicationError_PropertyNotSet = 201,              // The requested property was not set
+              VRApplicationError_UnknownProperty = 202,
+              VRApplicationError_InvalidParameter = 203,
+       };
+
+       /** The maximum length of an application key */
+       static const uint32_t k_unMaxApplicationKeyLength = 128;
+
+       /** these are the properties available on applications. */
+       enum EVRApplicationProperty
+       {
+              VRApplicationProperty_Name_String                            = 0,
+
+              VRApplicationProperty_LaunchType_String                     = 11,
+              VRApplicationProperty_WorkingDirectory_String       = 12,
+              VRApplicationProperty_BinaryPath_String                     = 13,
+              VRApplicationProperty_Arguments_String                     = 14,
+              VRApplicationProperty_URL_String                            = 15,
+
+              VRApplicationProperty_Description_String              = 50,
+              VRApplicationProperty_NewsURL_String                     = 51,
+              VRApplicationProperty_ImagePath_String                     = 52,
+              VRApplicationProperty_Source_String                            = 53,
+
+              VRApplicationProperty_IsDashboardOverlay_Bool       = 60,
+              VRApplicationProperty_IsTemplate_Bool                     = 61,
+              VRApplicationProperty_IsInstanced_Bool                     = 62,
+              VRApplicationProperty_IsInternal_Bool                     = 63,
+              VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+
+              VRApplicationProperty_LastLaunchTime_Uint64              = 70,
+       };
+
+       /** These are states the scene application startup process will go through. */
+       enum EVRApplicationTransitionState
+       {
+              VRApplicationTransition_None = 0,
+
+              VRApplicationTransition_OldAppQuitSent = 10,
+              VRApplicationTransition_WaitingForExternalLaunch = 11,
+              
+              VRApplicationTransition_NewAppLaunched = 20,
+       };
+
+       struct AppOverrideKeys_t
+       {
+              const char *pchKey;
+              const char *pchValue;
+       };
+
+       /** Currently recognized mime types */
+       static const char * const k_pch_MimeType_HomeApp              = "vr/home";
+       static const char * const k_pch_MimeType_GameTheater       = "vr/game_theater";
+
+       class IVRApplications
+       {
+       public:
+
+              // ---------------  Application management  --------------- //
+
+              /** Adds an application manifest to the list to load when building the list of installed applications. 
+              * Temporary manifests are not automatically loaded */
+              virtual EVRApplicationError AddApplicationManifest( const char *pchApplicationManifestFullPath, bool bTemporary = false ) = 0;
+
+              /** Removes an application manifest from the list to load when building the list of installed applications. */
+              virtual EVRApplicationError RemoveApplicationManifest( const char *pchApplicationManifestFullPath ) = 0;
+
+              /** Returns true if an application is installed */
+              virtual bool IsApplicationInstalled( const char *pchAppKey ) = 0;
+
+              /** Returns the number of applications available in the list */
+              virtual uint32_t GetApplicationCount() = 0;
+
+              /** Returns the key of the specified application. The index is at least 0 and is less than the return 
+              * value of GetApplicationCount(). The buffer should be at least k_unMaxApplicationKeyLength in order to 
+              * fit the key. */
+              virtual EVRApplicationError GetApplicationKeyByIndex( uint32_t unApplicationIndex, VR_OUT_STRING() char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+              /** Returns the key of the application for the specified Process Id. The buffer should be at least 
+              * k_unMaxApplicationKeyLength in order to fit the key. */
+              virtual EVRApplicationError GetApplicationKeyByProcessId( uint32_t unProcessId, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+              /** Launches the application. The existing scene application will exit and then the new application will start.
+              * This call is not valid for dashboard overlay applications. */
+              virtual EVRApplicationError LaunchApplication( const char *pchAppKey ) = 0;
+
+              /** Launches an instance of an application of type template, with its app key being pchNewAppKey (which must be unique) and optionally override sections
+              * from the manifest file via AppOverrideKeys_t
+              */
+              virtual EVRApplicationError LaunchTemplateApplication( const char *pchTemplateAppKey, const char *pchNewAppKey, VR_ARRAY_COUNT( unKeys ) const AppOverrideKeys_t *pKeys, uint32_t unKeys ) = 0;
+
+              /** launches the application currently associated with this mime type and passes it the option args, typically the filename or object name of the item being launched */
+              virtual vr::EVRApplicationError LaunchApplicationFromMimeType( const char *pchMimeType, const char *pchArgs ) = 0;
+
+              /** Launches the dashboard overlay application if it is not already running. This call is only valid for 
+              * dashboard overlay applications. */
+              virtual EVRApplicationError LaunchDashboardOverlay( const char *pchAppKey ) = 0;
+
+              /** Cancel a pending launch for an application */
+              virtual bool CancelApplicationLaunch( const char *pchAppKey ) = 0;
+
+              /** Identifies a running application. OpenVR can't always tell which process started in response
+              * to a URL. This function allows a URL handler (or the process itself) to identify the app key 
+              * for the now running application. Passing a process ID of 0 identifies the calling process. 
+              * The application must be one that's known to the system via a call to AddApplicationManifest. */
+              virtual EVRApplicationError IdentifyApplication( uint32_t unProcessId, const char *pchAppKey ) = 0;
+
+              /** Returns the process ID for an application. Return 0 if the application was not found or is not running. */
+              virtual uint32_t GetApplicationProcessId( const char *pchAppKey ) = 0;
+
+              /** Returns a string for an applications error */
+              virtual const char *GetApplicationsErrorNameFromEnum( EVRApplicationError error ) = 0;
+
+              // ---------------  Application properties  --------------- //
+
+              /** Returns a value for an application property. The required buffer size to fit this value will be returned. */
+              virtual uint32_t GetApplicationPropertyString( const char *pchAppKey, EVRApplicationProperty eProperty, VR_OUT_STRING() char *pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError *peError = nullptr ) = 0;
+
+              /** Returns a bool value for an application property. Returns false in all error cases. */
+              virtual bool GetApplicationPropertyBool( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+              /** Returns a uint64 value for an application property. Returns 0 in all error cases. */
+              virtual uint64_t GetApplicationPropertyUint64( const char *pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError *peError = nullptr ) = 0;
+
+              /** Sets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+              virtual EVRApplicationError SetApplicationAutoLaunch( const char *pchAppKey, bool bAutoLaunch ) = 0;
+
+              /** Gets the application auto-launch flag. This is only valid for applications which return true for VRApplicationProperty_IsDashboardOverlay_Bool. */
+              virtual bool GetApplicationAutoLaunch( const char *pchAppKey ) = 0;
+
+              /** Adds this mime-type to the list of supported mime types for this application*/
+              virtual EVRApplicationError SetDefaultApplicationForMimeType( const char *pchAppKey, const char *pchMimeType ) = 0;
+
+              /** return the app key that will open this mime type */
+              virtual bool GetDefaultApplicationForMimeType( const char *pchMimeType, char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+              /** Get the list of supported mime types for this application, comma-delimited */
+              virtual bool GetApplicationSupportedMimeTypes( const char *pchAppKey, char *pchMimeTypesBuffer, uint32_t unMimeTypesBuffer ) = 0;
+
+              /** Get the list of app-keys that support this mime type, comma-delimited, the return value is number of bytes you need to return the full string */
+              virtual uint32_t GetApplicationsThatSupportMimeType( const char *pchMimeType, char *pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer ) = 0;
+
+              /** Get the args list from an app launch that had the process already running, you call this when you get a VREvent_ApplicationMimeTypeLoad */
+              virtual uint32_t GetApplicationLaunchArguments( uint32_t unHandle, char *pchArgs, uint32_t unArgs ) = 0;
+
+              // ---------------  Transition methods --------------- //
+
+              /** Returns the app key for the application that is starting up */
+              virtual EVRApplicationError GetStartingApplication( char *pchAppKeyBuffer, uint32_t unAppKeyBufferLen ) = 0;
+
+              /** Returns the application transition state */
+              virtual EVRApplicationTransitionState GetTransitionState() = 0;
+
+              /** Returns errors that would prevent the specified application from launching immediately. Calling this function will
+              * cause the current scene application to quit, so only call it when you are actually about to launch something else.
+              * What the caller should do about these failures depends on the failure:
+              *   VRApplicationError_OldApplicationQuitting - An existing application has been told to quit. Wait for a VREvent_ProcessQuit
+              *                                               and try again.
+              *   VRApplicationError_ApplicationAlreadyStarting - This application is already starting. This is a permanent failure.
+              *   VRApplicationError_LaunchInProgress             - A different application is already starting. This is a permanent failure.
+              *   VRApplicationError_None                   - Go ahead and launch. Everything is clear.
+              */
+              virtual EVRApplicationError PerformApplicationPrelaunchCheck( const char *pchAppKey ) = 0;
+
+              /** Returns a string for an application transition state */
+              virtual const char *GetApplicationsTransitionStateNameFromEnum( EVRApplicationTransitionState state ) = 0;
+
+              /** Returns true if the outgoing scene app has requested a save prompt before exiting */
+              virtual bool IsQuitUserPromptRequested() = 0;
+
+              /** Starts a subprocess within the calling application. This
+              * suppresses all application transition UI and automatically identifies the new executable 
+              * as part of the same application. On success the calling process should exit immediately. 
+              * If working directory is NULL or "" the directory portion of the binary path will be 
+              * the working directory. */
+              virtual EVRApplicationError LaunchInternalProcess( const char *pchBinaryPath, const char *pchArguments, const char *pchWorkingDirectory ) = 0;
+
+              /** Returns the current scene process ID according to the application system. A scene process will get scene
+              * focus once it starts rendering, but it will appear here once it calls VR_Init with the Scene application
+              * type. */
+              virtual uint32_t GetCurrentSceneProcessId() = 0;
+       };
+
+       static const char * const IVRApplications_Version = "IVRApplications_006";
+
+} // namespace vr
+
+// ivrsettings.h
+namespace vr
+{
+       enum EVRSettingsError
+       {
+              VRSettingsError_None = 0,
+              VRSettingsError_IPCFailed = 1,
+              VRSettingsError_WriteFailed = 2,
+              VRSettingsError_ReadFailed = 3,
+              VRSettingsError_JsonParseFailed = 4,
+              VRSettingsError_UnsetSettingHasNoDefault = 5, // This will be returned if the setting does not appear in the appropriate default file and has not been set
+       };
+
+       // The maximum length of a settings key
+       static const uint32_t k_unMaxSettingsKeyLength = 128;
+
+       class IVRSettings
+       {
+       public:
+              virtual const char *GetSettingsErrorNameFromEnum( EVRSettingsError eError ) = 0;
+
+              // Returns true if file sync occurred (force or settings dirty)
+              virtual bool Sync( bool bForce = false, EVRSettingsError *peError = nullptr ) = 0;
+
+              virtual void SetBool( const char *pchSection, const char *pchSettingsKey, bool bValue, EVRSettingsError *peError = nullptr ) = 0;
+              virtual void SetInt32( const char *pchSection, const char *pchSettingsKey, int32_t nValue, EVRSettingsError *peError = nullptr ) = 0;
+              virtual void SetFloat( const char *pchSection, const char *pchSettingsKey, float flValue, EVRSettingsError *peError = nullptr ) = 0;
+              virtual void SetString( const char *pchSection, const char *pchSettingsKey, const char *pchValue, EVRSettingsError *peError = nullptr ) = 0;
+
+              // Users of the system need to provide a proper default in default.vrsettings in the resources/settings/ directory
+              // of either the runtime or the driver_xxx directory. Otherwise the default will be false, 0, 0.0 or ""
+              virtual bool GetBool( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+              virtual int32_t GetInt32( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+              virtual float GetFloat( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+              virtual void GetString( const char *pchSection, const char *pchSettingsKey, VR_OUT_STRING() char *pchValue, uint32_t unValueLen, EVRSettingsError *peError = nullptr ) = 0;
+
+              virtual void RemoveSection( const char *pchSection, EVRSettingsError *peError = nullptr ) = 0;
+              virtual void RemoveKeyInSection( const char *pchSection, const char *pchSettingsKey, EVRSettingsError *peError = nullptr ) = 0;
+       };
+
+       //-----------------------------------------------------------------------------
+       static const char * const IVRSettings_Version = "IVRSettings_002";
+
+       //-----------------------------------------------------------------------------
+       // steamvr keys
+       static const char * const k_pch_SteamVR_Section = "steamvr";
+       static const char * const k_pch_SteamVR_RequireHmd_String = "requireHmd";
+       static const char * const k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+       static const char * const k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+       static const char * const k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+       static const char * const k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+       static const char * const k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+       static const char * const k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+       static const char * const k_pch_SteamVR_SendSystemButtonToAllApps_Bool= "sendSystemButtonToAllApps";
+       static const char * const k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+       static const char * const k_pch_SteamVR_IPD_Float = "ipd";
+       static const char * const k_pch_SteamVR_Background_String = "background";
+       static const char * const k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+       static const char * const k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+       static const char * const k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+       static const char * const k_pch_SteamVR_GridColor_String = "gridColor";
+       static const char * const k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+       static const char * const k_pch_SteamVR_ShowStage_Bool = "showStage";
+       static const char * const k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+       static const char * const k_pch_SteamVR_DirectMode_Bool = "directMode";
+       static const char * const k_pch_SteamVR_DirectModeEdidVid_Int32 = "directModeEdidVid";
+       static const char * const k_pch_SteamVR_DirectModeEdidPid_Int32 = "directModeEdidPid";
+       static const char * const k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+       static const char * const k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+       static const char * const k_pch_SteamVR_BaseStationPowerManagement_Bool = "basestationPowerManagement";
+       static const char * const k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+       static const char * const k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+       static const char * const k_pch_SteamVR_AllowAsyncReprojection_Bool = "allowAsyncReprojection";
+       static const char * const k_pch_SteamVR_AllowReprojection_Bool = "allowInterleavedReprojection";
+       static const char * const k_pch_SteamVR_ForceReprojection_Bool = "forceReprojection";
+       static const char * const k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+       static const char * const k_pch_SteamVR_DefaultMirrorView_Int32 = "defaultMirrorView";
+       static const char * const k_pch_SteamVR_ShowMirrorView_Bool = "showMirrorView";
+       static const char * const k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+       static const char * const k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+       static const char * const k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+       static const char * const k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+       static const char * const k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+       static const char * const k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+       static const char * const k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+       static const char * const k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+       static const char * const k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+       static const char * const k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+       static const char * const k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+
+       //-----------------------------------------------------------------------------
+       // lighthouse keys
+       static const char * const k_pch_Lighthouse_Section = "driver_lighthouse";
+       static const char * const k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+       static const char * const k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+       static const char * const k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+       static const char * const k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+       static const char * const k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+
+       //-----------------------------------------------------------------------------
+       // null keys
+       static const char * const k_pch_Null_Section = "driver_null";
+       static const char * const k_pch_Null_SerialNumber_String = "serialNumber";
+       static const char * const k_pch_Null_ModelNumber_String = "modelNumber";
+       static const char * const k_pch_Null_WindowX_Int32 = "windowX";
+       static const char * const k_pch_Null_WindowY_Int32 = "windowY";
+       static const char * const k_pch_Null_WindowWidth_Int32 = "windowWidth";
+       static const char * const k_pch_Null_WindowHeight_Int32 = "windowHeight";
+       static const char * const k_pch_Null_RenderWidth_Int32 = "renderWidth";
+       static const char * const k_pch_Null_RenderHeight_Int32 = "renderHeight";
+       static const char * const k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+       static const char * const k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+
+       //-----------------------------------------------------------------------------
+       // user interface keys
+       static const char * const k_pch_UserInterface_Section = "userinterface";
+       static const char * const k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+       static const char * const k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+       static const char * const k_pch_UserInterface_Screenshots_Bool = "screenshots";
+       static const char * const k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+
+       //-----------------------------------------------------------------------------
+       // notification keys
+       static const char * const k_pch_Notifications_Section = "notifications";
+       static const char * const k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+
+       //-----------------------------------------------------------------------------
+       // keyboard keys
+       static const char * const k_pch_Keyboard_Section = "keyboard";
+       static const char * const k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+       static const char * const k_pch_Keyboard_ScaleX = "ScaleX";
+       static const char * const k_pch_Keyboard_ScaleY = "ScaleY";
+       static const char * const k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+       static const char * const k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+       static const char * const k_pch_Keyboard_OffsetY = "OffsetY";
+       static const char * const k_pch_Keyboard_Smoothing = "Smoothing";
+
+       //-----------------------------------------------------------------------------
+       // perf keys
+       static const char * const k_pch_Perf_Section = "perfcheck";
+       static const char * const k_pch_Perf_HeuristicActive_Bool = "heuristicActive";
+       static const char * const k_pch_Perf_NotifyInHMD_Bool = "warnInHMD";
+       static const char * const k_pch_Perf_NotifyOnlyOnce_Bool = "warnOnlyOnce";
+       static const char * const k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+       static const char * const k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+       static const char * const k_pch_Perf_TestData_Float = "perfTestData";
+       static const char * const k_pch_Perf_LinuxGPUProfiling_Bool = "linuxGPUProfiling";
+
+       //-----------------------------------------------------------------------------
+       // collision bounds keys
+       static const char * const k_pch_CollisionBounds_Section = "collisionBounds";
+       static const char * const k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+       static const char * const k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+       static const char * const k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+       static const char * const k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+       static const char * const k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+       static const char * const k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+       static const char * const k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+       static const char * const k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+       static const char * const k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+
+       //-----------------------------------------------------------------------------
+       // camera keys
+       static const char * const k_pch_Camera_Section = "camera";
+       static const char * const k_pch_Camera_EnableCamera_Bool = "enableCamera";
+       static const char * const k_pch_Camera_EnableCameraInDashboard_Bool = "enableCameraInDashboard";
+       static const char * const k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+       static const char * const k_pch_Camera_EnableCameraForRoomView_Bool = "enableCameraForRoomView";
+       static const char * const k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+       static const char * const k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+       static const char * const k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+       static const char * const k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+       static const char * const k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+
+       //-----------------------------------------------------------------------------
+       // audio keys
+       static const char * const k_pch_audio_Section = "audio";
+       static const char * const k_pch_audio_OnPlaybackDevice_String = "onPlaybackDevice";
+       static const char * const k_pch_audio_OnRecordDevice_String = "onRecordDevice";
+       static const char * const k_pch_audio_OnPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+       static const char * const k_pch_audio_OffPlaybackDevice_String = "offPlaybackDevice";
+       static const char * const k_pch_audio_OffRecordDevice_String = "offRecordDevice";
+       static const char * const k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+
+       //-----------------------------------------------------------------------------
+       // power management keys
+       static const char * const k_pch_Power_Section = "power";
+       static const char * const k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+       static const char * const k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+       static const char * const k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+       static const char * const k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+       static const char * const k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+       static const char * const k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+
+       //-----------------------------------------------------------------------------
+       // dashboard keys
+       static const char * const k_pch_Dashboard_Section = "dashboard";
+       static const char * const k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+       static const char * const k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+
+       //-----------------------------------------------------------------------------
+       // model skin keys
+       static const char * const k_pch_modelskin_Section = "modelskins";
+
+       //-----------------------------------------------------------------------------
+       // driver keys - These could be checked in any driver_<name> section
+       static const char * const k_pch_Driver_Enable_Bool = "enable";
+
+} // namespace vr
+
+// ivrchaperone.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+enum ChaperoneCalibrationState
+{
+       // OK!
+       ChaperoneCalibrationState_OK = 1,                                                               // Chaperone is fully calibrated and working correctly
+
+       // Warnings
+       ChaperoneCalibrationState_Warning = 100,
+       ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,       // A base station thinks that it might have moved
+       ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,                     // There are less base stations than when calibrated
+       ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,              // Seated bounds haven't been calibrated for the current tracking center
+
+       // Errors
+       ChaperoneCalibrationState_Error = 200,                                                        // The UniverseID is invalid
+       ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,              // Tracking center hasn't be calibrated for at least one of the base stations
+       ChaperoneCalibrationState_Error_BaseStationConflict = 202,                     // Tracking center is calibrated, but base stations disagree on the tracking space
+       ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,                            // Play Area hasn't been calibrated for the current tracking center
+       ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,              // Collision Bounds haven't been calibrated for the current tracking center
+};
+
+
+/** HIGH LEVEL TRACKING SPACE ASSUMPTIONS:
+* 0,0,0 is the preferred standing area center.
+* 0Y is the floor height.
+* -Z is the preferred forward facing direction. */
+class IVRChaperone
+{
+public:
+
+       /** Get the current state of Chaperone calibration. This state can change at any time during a session due to physical base station changes. **/
+       virtual ChaperoneCalibrationState GetCalibrationState() = 0;
+
+       /** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z. 
+       * Tracking space center (0,0,0) is the center of the Play Area. **/
+       virtual bool GetPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+       /** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds).
+       * Corners are in counter-clockwise order.
+       * Standing center (0,0,0) is the center of the Play Area.
+       * It's a rectangle.
+       * 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+       * Height of every corner is 0Y (on the floor). **/
+       virtual bool GetPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+       /** Reload Chaperone data from the .vrchap file on disk. */
+       virtual void ReloadInfo( void ) = 0;
+
+       /** Optionally give the chaperone system a hit about the color and brightness in the scene **/
+       virtual void SetSceneColor( HmdColor_t color ) = 0;
+
+       /** Get the current chaperone bounds draw color and brightness **/
+       virtual void GetBoundsColor( HmdColor_t *pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, HmdColor_t *pOutputCameraColor ) = 0;
+
+       /** Determine whether the bounds are showing right now **/
+       virtual bool AreBoundsVisible() = 0;
+
+       /** Force the bounds to show, mostly for utilities **/
+       virtual void ForceBoundsVisible( bool bForce ) = 0;
+};
+
+static const char * const IVRChaperone_Version = "IVRChaperone_003";
+
+#pragma pack( pop )
+
+}
+
+// ivrchaperonesetup.h
+namespace vr
+{
+
+enum EChaperoneConfigFile
+{
+       EChaperoneConfigFile_Live = 1,              // The live chaperone config, used by most applications and games
+       EChaperoneConfigFile_Temp = 2,              // The temporary chaperone config, used to live-preview collision bounds in room setup
+};
+
+enum EChaperoneImportFlags
+{
+       EChaperoneImport_BoundsOnly = 0x0001,
+};
+
+/** Manages the working copy of the chaperone info. By default this will be the same as the 
+* live copy. Any changes made with this interface will stay in the working copy until 
+* CommitWorkingCopy() is called, at which point the working copy and the live copy will be 
+* the same again. */
+class IVRChaperoneSetup
+{
+public:
+
+       /** Saves the current working copy to disk */
+       virtual bool CommitWorkingCopy( EChaperoneConfigFile configFile ) = 0;
+
+       /** Reverts the working copy to match the live chaperone calibration.
+       * To modify existing data this MUST be do WHILE getting a non-error ChaperoneCalibrationStatus.
+       * Only after this should you do gets and sets on the existing data. */
+       virtual void RevertWorkingCopy() = 0;
+
+       /** Returns the width and depth of the Play Area (formerly named Soft Bounds) in X and Z from the working copy.
+       * Tracking space center (0,0,0) is the center of the Play Area. */
+       virtual bool GetWorkingPlayAreaSize( float *pSizeX, float *pSizeZ ) = 0;
+
+       /** Returns the 4 corner positions of the Play Area (formerly named Soft Bounds) from the working copy.
+       * Corners are in clockwise order.
+       * Tracking space center (0,0,0) is the center of the Play Area.
+       * It's a rectangle.
+       * 2 sides are parallel to the X axis and 2 sides are parallel to the Z axis.
+       * Height of every corner is 0Y (on the floor). **/
+       virtual bool GetWorkingPlayAreaRect( HmdQuad_t *rect ) = 0;
+
+       /** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+       * into the buffer up to the max specified from the working copy. */
+       virtual bool GetWorkingCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+       /** Returns the number of Quads if the buffer points to null. Otherwise it returns Quads 
+       * into the buffer up to the max specified. */
+       virtual bool GetLiveCollisionBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+       /** Returns the preferred seated position from the working copy. */
+       virtual bool GetWorkingSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+       /** Returns the standing origin from the working copy. */
+       virtual bool GetWorkingStandingZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatStandingZeroPoseToRawTrackingPose ) = 0;
+
+       /** Sets the Play Area in the working copy. */
+       virtual void SetWorkingPlayAreaSize( float sizeX, float sizeZ ) = 0;
+
+       /** Sets the Collision Bounds in the working copy. */
+       virtual void SetWorkingCollisionBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) = 0;
+
+       /** Sets the preferred seated position in the working copy. */
+       virtual void SetWorkingSeatedZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+       /** Sets the preferred standing position in the working copy. */
+       virtual void SetWorkingStandingZeroPoseToRawTrackingPose( const HmdMatrix34_t *pMatStandingZeroPoseToRawTrackingPose ) = 0;
+
+       /** Tear everything down and reload it from the file on disk */
+       virtual void ReloadFromDisk( EChaperoneConfigFile configFile ) = 0;
+
+       /** Returns the preferred seated position. */
+       virtual bool GetLiveSeatedZeroPoseToRawTrackingPose( HmdMatrix34_t *pmatSeatedZeroPoseToRawTrackingPose ) = 0;
+
+       virtual void SetWorkingCollisionBoundsTagsInfo( VR_ARRAY_COUNT(unTagCount) uint8_t *pTagsBuffer, uint32_t unTagCount ) = 0;
+       virtual bool GetLiveCollisionBoundsTagsInfo( VR_OUT_ARRAY_COUNT(punTagCount) uint8_t *pTagsBuffer, uint32_t *punTagCount ) = 0;
+
+       virtual bool SetWorkingPhysicalBoundsInfo( VR_ARRAY_COUNT(unQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t unQuadsCount ) = 0;
+       virtual bool GetLivePhysicalBoundsInfo( VR_OUT_ARRAY_COUNT(punQuadsCount) HmdQuad_t *pQuadsBuffer, uint32_t* punQuadsCount ) = 0;
+
+       virtual bool ExportLiveToBuffer( VR_OUT_STRING() char *pBuffer, uint32_t *pnBufferLength ) = 0;
+       virtual bool ImportFromBufferToWorking( const char *pBuffer, uint32_t nImportFlags ) = 0;
+};
+
+static const char * const IVRChaperoneSetup_Version = "IVRChaperoneSetup_005";
+
+
+}
+
+// ivrcompositor.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRCompositorError
+{
+       VRCompositorError_None                                          = 0,
+       VRCompositorError_RequestFailed                            = 1,
+       VRCompositorError_IncompatibleVersion              = 100,
+       VRCompositorError_DoNotHaveFocus                     = 101,
+       VRCompositorError_InvalidTexture                     = 102,
+       VRCompositorError_IsNotSceneApplication              = 103,
+       VRCompositorError_TextureIsOnWrongDevice       = 104,
+       VRCompositorError_TextureUsesUnsupportedFormat = 105,
+       VRCompositorError_SharedTexturesNotSupported = 106,
+       VRCompositorError_IndexOutOfRange                     = 107,
+       VRCompositorError_AlreadySubmitted                     = 108,
+       VRCompositorError_InvalidBounds                            = 109,
+};
+
+const uint32_t VRCompositor_ReprojectionReason_Cpu = 0x01;
+const uint32_t VRCompositor_ReprojectionReason_Gpu = 0x02;
+const uint32_t VRCompositor_ReprojectionAsync      = 0x04;       // This flag indicates the async reprojection mode is active,
+                                                                                                         // but does not indicate if reprojection actually happened or not.
+                                                                                                         // Use the ReprojectionReason flags above to check if reprojection
+                                                                                                         // was actually applied (i.e. scene texture was reused).
+                                                                                                         // NumFramePresents > 1 also indicates the scene texture was reused,
+                                                                                                         // and also the number of times that it was presented in total.
+
+/** Provides a single frame's timing information to the app */
+struct Compositor_FrameTiming
+{
+       uint32_t m_nSize; // Set to sizeof( Compositor_FrameTiming )
+       uint32_t m_nFrameIndex;
+       uint32_t m_nNumFramePresents; // number of times this frame was presented
+       uint32_t m_nNumMisPresented; // number of times this frame was presented on a vsync other than it was originally predicted to
+       uint32_t m_nNumDroppedFrames; // number of additional times previous frame was scanned out
+       uint32_t m_nReprojectionFlags;
+
+       /** Absolute time reference for comparing frames.  This aligns with the vsync that running start is relative to. */
+       double m_flSystemTimeInSeconds;
+
+       /** These times may include work from other processes due to OS scheduling.
+       * The fewer packets of work these are broken up into, the less likely this will happen.
+       * GPU work can be broken up by calling Flush.  This can sometimes be useful to get the GPU started
+       * processing that work earlier in the frame. */
+       float m_flPreSubmitGpuMs; // time spent rendering the scene (gpu work submitted between WaitGetPoses and second Submit)
+       float m_flPostSubmitGpuMs; // additional time spent rendering by application (e.g. companion window)
+       float m_flTotalRenderGpuMs; // time between work submitted immediately after present (ideally vsync) until the end of compositor submitted work
+       float m_flCompositorRenderGpuMs; // time spend performing distortion correction, rendering chaperone, overlays, etc.
+       float m_flCompositorRenderCpuMs; // time spent on cpu submitting the above work for this frame
+       float m_flCompositorIdleCpuMs; // time spent waiting for running start (application could have used this much more time)
+
+       /** Miscellaneous measured intervals. */
+       float m_flClientFrameIntervalMs; // time between calls to WaitGetPoses
+       float m_flPresentCallCpuMs; // time blocked on call to present (usually 0.0, but can go long)
+       float m_flWaitForPresentCpuMs; // time spent spin-waiting for frame index to change (not near-zero indicates wait object failure)
+       float m_flSubmitFrameMs; // time spent in IVRCompositor::Submit (not near-zero indicates driver issue)
+
+       /** The following are all relative to this frame's SystemTimeInSeconds */
+       float m_flWaitGetPosesCalledMs;
+       float m_flNewPosesReadyMs;
+       float m_flNewFrameReadyMs; // second call to IVRCompositor::Submit
+       float m_flCompositorUpdateStartMs;
+       float m_flCompositorUpdateEndMs;
+       float m_flCompositorRenderStartMs;
+
+       vr::TrackedDevicePose_t m_HmdPose; // pose used by app to render this frame
+};
+
+/** Cumulative stats for current application.  These are not cleared until a new app connects,
+* but they do stop accumulating once the associated app disconnects. */
+struct Compositor_CumulativeStats
+{
+       uint32_t m_nPid; // Process id associated with these stats (may no longer be running).
+       uint32_t m_nNumFramePresents; // total number of times we called present (includes reprojected frames)
+       uint32_t m_nNumDroppedFrames; // total number of times an old frame was re-scanned out (without reprojection)
+       uint32_t m_nNumReprojectedFrames; // total number of times a frame was scanned out a second time (with reprojection)
+
+       /** Values recorded at startup before application has fully faded in the first time. */
+       uint32_t m_nNumFramePresentsOnStartup;
+       uint32_t m_nNumDroppedFramesOnStartup;
+       uint32_t m_nNumReprojectedFramesOnStartup;
+
+       /** Applications may explicitly fade to the compositor.  This is usually to handle level transitions, and loading often causes
+       * system wide hitches.  The following stats are collected during this period.  Does not include values recorded during startup. */
+       uint32_t m_nNumLoading;
+       uint32_t m_nNumFramePresentsLoading;
+       uint32_t m_nNumDroppedFramesLoading;
+       uint32_t m_nNumReprojectedFramesLoading;
+
+       /** If we don't get a new frame from the app in less than 2.5 frames, then we assume the app has hung and start
+       * fading back to the compositor.  The following stats are a result of this, and are a subset of those recorded above.
+       * Does not include values recorded during start up or loading. */
+       uint32_t m_nNumTimedOut;
+       uint32_t m_nNumFramePresentsTimedOut;
+       uint32_t m_nNumDroppedFramesTimedOut;
+       uint32_t m_nNumReprojectedFramesTimedOut;
+};
+
+#pragma pack( pop )
+
+/** Allows the application to interact with the compositor */
+class IVRCompositor
+{
+public:
+       /** Sets tracking space returned by WaitGetPoses */
+       virtual void SetTrackingSpace( ETrackingUniverseOrigin eOrigin ) = 0;
+
+       /** Gets current tracking space returned by WaitGetPoses */
+       virtual ETrackingUniverseOrigin GetTrackingSpace() = 0;
+
+       /** Scene applications should call this function to get poses to render with (and optionally poses predicted an additional frame out to use for gameplay).
+       * This function will block until "running start" milliseconds before the start of the frame, and should be called at the last moment before needing to
+       * start rendering.
+       *
+       * Return codes:
+       *       - IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+       *       - DoNotHaveFocus (some other app has taken focus - this will throttle the call to 10hz to reduce the impact on that app)
+       */
+       virtual EVRCompositorError WaitGetPoses( VR_ARRAY_COUNT(unRenderPoseArrayCount) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+              VR_ARRAY_COUNT(unGamePoseArrayCount) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+       /** Get the last set of poses returned by WaitGetPoses. */
+       virtual EVRCompositorError GetLastPoses( VR_ARRAY_COUNT( unRenderPoseArrayCount ) TrackedDevicePose_t* pRenderPoseArray, uint32_t unRenderPoseArrayCount,
+              VR_ARRAY_COUNT( unGamePoseArrayCount ) TrackedDevicePose_t* pGamePoseArray, uint32_t unGamePoseArrayCount ) = 0;
+
+       /** Interface for accessing last set of poses returned by WaitGetPoses one at a time.
+       * Returns VRCompositorError_IndexOutOfRange if unDeviceIndex not less than k_unMaxTrackedDeviceCount otherwise VRCompositorError_None.
+       * It is okay to pass NULL for either pose if you only want one of the values. */
+       virtual EVRCompositorError GetLastPoseForTrackedDeviceIndex( TrackedDeviceIndex_t unDeviceIndex, TrackedDevicePose_t *pOutputPose, TrackedDevicePose_t *pOutputGamePose ) = 0;
+
+       /** Updated scene texture to display. If pBounds is NULL the entire texture will be used.  If called from an OpenGL app, consider adding a glFlush after
+       * Submitting both frames to signal the driver to start processing, otherwise it may wait until the command buffer fills up, causing the app to miss frames.
+       *
+       * OpenGL dirty state:
+       *       glBindTexture
+       *
+       * Return codes:
+       *       - IsNotSceneApplication (make sure to call VR_Init with VRApplicaiton_Scene)
+       *       - DoNotHaveFocus (some other app has taken focus)
+       *       - TextureIsOnWrongDevice (application did not use proper AdapterIndex - see IVRSystem.GetDXGIOutputInfo)
+       *       - SharedTexturesNotSupported (application needs to call CreateDXGIFactory1 or later before creating DX device)
+       *       - TextureUsesUnsupportedFormat (scene textures must be compatible with DXGI sharing rules - e.g. uncompressed, no mips, etc.)
+       *       - InvalidTexture (usually means bad arguments passed in)
+       *       - AlreadySubmitted (app has submitted two left textures or two right textures in a single frame - i.e. before calling WaitGetPoses again)
+       */
+       virtual EVRCompositorError Submit( EVREye eEye, const Texture_t *pTexture, const VRTextureBounds_t* pBounds = 0, EVRSubmitFlags nSubmitFlags = Submit_Default ) = 0;
+
+       /** Clears the frame that was sent with the last call to Submit. This will cause the 
+       * compositor to show the grid until Submit is called again. */
+       virtual void ClearLastSubmittedFrame() = 0;
+
+       /** Call immediately after presenting your app's window (i.e. companion window) to unblock the compositor.
+       * This is an optional call, which only needs to be used if you can't instead call WaitGetPoses immediately after Present.
+       * For example, if your engine's render and game loop are not on separate threads, or blocking the render thread until 3ms before the next vsync would
+       * introduce a deadlock of some sort.  This function tells the compositor that you have finished all rendering after having Submitted buffers for both
+       * eyes, and it is free to start its rendering work.  This should only be called from the same thread you are rendering on. */
+       virtual void PostPresentHandoff() = 0;
+
+       /** Returns true if timing data is filled it.  Sets oldest timing info if nFramesAgo is larger than the stored history.
+       * Be sure to set timing.size = sizeof(Compositor_FrameTiming) on struct passed in before calling this function. */
+       virtual bool GetFrameTiming( Compositor_FrameTiming *pTiming, uint32_t unFramesAgo = 0 ) = 0;
+
+       /** Interface for copying a range of timing data.  Frames are returned in ascending order (oldest to newest) with the last being the most recent frame.
+       * Only the first entry's m_nSize needs to be set, as the rest will be inferred from that.  Returns total number of entries filled out. */
+       virtual uint32_t GetFrameTimings( Compositor_FrameTiming *pTiming, uint32_t nFrames ) = 0;
+
+       /** Returns the time in seconds left in the current (as identified by FrameTiming's frameIndex) frame.
+       * Due to "running start", this value may roll over to the next frame before ever reaching 0.0. */
+       virtual float GetFrameTimeRemaining() = 0;
+
+       /** Fills out stats accumulated for the last connected application.  Pass in sizeof( Compositor_CumulativeStats ) as second parameter. */
+       virtual void GetCumulativeStats( Compositor_CumulativeStats *pStats, uint32_t nStatsSizeInBytes ) = 0;
+
+       /** Fades the view on the HMD to the specified color. The fade will take fSeconds, and the color values are between
+       * 0.0 and 1.0. This color is faded on top of the scene based on the alpha parameter. Removing the fade color instantly 
+       * would be FadeToColor( 0.0, 0.0, 0.0, 0.0, 0.0 ).  Values are in un-premultiplied alpha space. */
+       virtual void FadeToColor( float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground = false ) = 0;
+
+       /** Get current fade color value. */
+       virtual HmdColor_t GetCurrentFadeColor( bool bBackground = false ) = 0;
+
+       /** Fading the Grid in or out in fSeconds */
+       virtual void FadeGrid( float fSeconds, bool bFadeIn ) = 0;
+
+       /** Get current alpha value of grid. */
+       virtual float GetCurrentGridAlpha() = 0;
+
+       /** Override the skybox used in the compositor (e.g. for during level loads when the app can't feed scene images fast enough)
+       * Order is Front, Back, Left, Right, Top, Bottom.  If only a single texture is passed, it is assumed in lat-long format.
+       * If two are passed, it is assumed a lat-long stereo pair. */
+       virtual EVRCompositorError SetSkyboxOverride( VR_ARRAY_COUNT( unTextureCount ) const Texture_t *pTextures, uint32_t unTextureCount ) = 0;
+
+       /** Resets compositor skybox back to defaults. */
+       virtual void ClearSkyboxOverride() = 0;
+
+       /** Brings the compositor window to the front. This is useful for covering any other window that may be on the HMD
+       * and is obscuring the compositor window. */
+       virtual void CompositorBringToFront() = 0;
+
+       /** Pushes the compositor window to the back. This is useful for allowing other applications to draw directly to the HMD. */
+       virtual void CompositorGoToBack() = 0;
+
+       /** Tells the compositor process to clean up and exit. You do not need to call this function at shutdown. Under normal 
+       * circumstances the compositor will manage its own life cycle based on what applications are running. */
+       virtual void CompositorQuit() = 0;
+       
+       /** Return whether the compositor is fullscreen */
+       virtual bool IsFullscreen() = 0;
+
+       /** Returns the process ID of the process that is currently rendering the scene */
+       virtual uint32_t GetCurrentSceneFocusProcess() = 0;
+
+       /** Returns the process ID of the process that rendered the last frame (or 0 if the compositor itself rendered the frame.)
+       * Returns 0 when fading out from an app and the app's process Id when fading into an app. */
+       virtual uint32_t GetLastFrameRenderer() = 0;
+
+       /** Returns true if the current process has the scene focus */
+       virtual bool CanRenderScene() = 0;
+
+       /** Creates a window on the primary monitor to display what is being shown in the headset. */
+       virtual void ShowMirrorWindow() = 0;
+
+       /** Closes the mirror window. */
+       virtual void HideMirrorWindow() = 0;
+
+       /** Returns true if the mirror window is shown. */
+       virtual bool IsMirrorWindowVisible() = 0;
+
+       /** Writes all images that the compositor knows about (including overlays) to a 'screenshots' folder in the SteamVR runtime root. */
+       virtual void CompositorDumpImages() = 0;
+
+       /** Let an app know it should be rendering with low resources. */
+       virtual bool ShouldAppRenderWithLowResources() = 0;
+
+       /** Override interleaved reprojection logic to force on. */
+       virtual void ForceInterleavedReprojectionOn( bool bOverride ) = 0;
+
+       /** Force reconnecting to the compositor process. */
+       virtual void ForceReconnectProcess() = 0;
+
+       /** Temporarily suspends rendering (useful for finer control over scene transitions). */
+       virtual void SuspendRendering( bool bSuspend ) = 0;
+
+       /** Opens a shared D3D11 texture with the undistorted composited image for each eye.  Use ReleaseMirrorTextureD3D11 when finished
+       * instead of calling Release on the resource itself. */
+       virtual vr::EVRCompositorError GetMirrorTextureD3D11( vr::EVREye eEye, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView ) = 0;
+       virtual void ReleaseMirrorTextureD3D11( void *pD3D11ShaderResourceView ) = 0;
+
+       /** Access to mirror textures from OpenGL. */
+       virtual vr::EVRCompositorError GetMirrorTextureGL( vr::EVREye eEye, vr::glUInt_t *pglTextureId, vr::glSharedTextureHandle_t *pglSharedTextureHandle ) = 0;
+       virtual bool ReleaseSharedGLTexture( vr::glUInt_t glTextureId, vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+       virtual void LockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+       virtual void UnlockGLSharedTextureForAccess( vr::glSharedTextureHandle_t glSharedTextureHandle ) = 0;
+
+       /** [Vulkan Only]
+       * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+       * null.  The string will be a space separated list of-required instance extensions to enable in VkCreateInstance */
+       virtual uint32_t GetVulkanInstanceExtensionsRequired( VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+       /** [Vulkan only]
+       * return 0. Otherwise it returns the length of the number of bytes necessary to hold this string including the trailing
+       * null.  The string will be a space separated list of required device extensions to enable in VkCreateDevice */
+       virtual uint32_t GetVulkanDeviceExtensionsRequired( VkPhysicalDevice_T *pPhysicalDevice, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+
+       /** [ Vulkan/D3D12 Only ]
+       * There are two purposes for SetExplicitTimingMode:
+       *       1. To get a more accurate GPU timestamp for when the frame begins in Vulkan/D3D12 applications.
+       *       2. (Optional) To avoid having WaitGetPoses access the Vulkan queue so that the queue can be accessed from
+       *       another thread while WaitGetPoses is executing.
+       *
+       * More accurate GPU timestamp for the start of the frame is achieved by the application calling
+       * SubmitExplicitTimingData immediately before its first submission to the Vulkan/D3D12 queue.
+       * This is more accurate because normally this GPU timestamp is recorded during WaitGetPoses.  In D3D11, 
+       * WaitGetPoses queues a GPU timestamp write, but it does not actually get submitted to the GPU until the 
+       * application flushes.  By using SubmitExplicitTimingData, the timestamp is recorded at the same place for 
+       * Vulkan/D3D12 as it is for D3D11, resulting in a more accurate GPU time measurement for the frame.
+       *
+       * Avoiding WaitGetPoses accessing the Vulkan queue can be achieved using SetExplicitTimingMode as well.  If this is desired,
+       * the application *MUST* call PostPresentHandoff itself prior to WaitGetPoses.  If SetExplicitTimingMode is true and the
+       * application calls PostPresentHandoff, then WaitGetPoses is guaranteed not to access the queue.  Note that PostPresentHandoff
+       * and SubmitExplicitTimingData will access the queue, so only WaitGetPoses becomes safe for accessing the queue from another
+       * thread. */
+       virtual void SetExplicitTimingMode( bool bExplicitTimingMode ) = 0;
+
+       /** [ Vulkan/D3D12 Only ]
+       * Submit explicit timing data.  When SetExplicitTimingMode is true, this must be called immediately before
+       * the application's first vkQueueSubmit (Vulkan) or ID3D12CommandQueue::ExecuteCommandLists (D3D12) of each frame.
+       * This function will insert a GPU timestamp write just before the application starts its rendering.  This function
+       * will perform a vkQueueSubmit on Vulkan so must not be done simultaneously with VkQueue operations on another thread.
+       * Returns VRCompositorError_RequestFailed if SetExplicitTimingMode is not enabled. */
+       virtual EVRCompositorError SubmitExplicitTimingData() = 0;
+};
+
+static const char * const IVRCompositor_Version = "IVRCompositor_021";
+
+} // namespace vr
+
+
+
+// ivrnotifications.h
+namespace vr
+{
+
+#pragma pack( push, 8 )
+
+// Used for passing graphic data
+struct NotificationBitmap_t
+{
+       NotificationBitmap_t()
+              : m_pImageData( nullptr )
+              , m_nWidth( 0 )
+              , m_nHeight( 0 )
+              , m_nBytesPerPixel( 0 )
+       {
+       };
+
+       void *m_pImageData;
+       int32_t m_nWidth;
+       int32_t m_nHeight;
+       int32_t m_nBytesPerPixel;
+};
+
+
+/** Be aware that the notification type is used as 'priority' to pick the next notification */
+enum EVRNotificationType
+{
+       /** Transient notifications are automatically hidden after a period of time set by the user. 
+       * They are used for things like information and chat messages that do not require user interaction. */
+       EVRNotificationType_Transient = 0,
+
+       /** Persistent notifications are shown to the user until they are hidden by calling RemoveNotification().
+       * They are used for things like phone calls and alarms that require user interaction. */
+       EVRNotificationType_Persistent = 1,
+
+       /** System notifications are shown no matter what. It is expected, that the ulUserValue is used as ID.
+        * If there is already a system notification in the queue with that ID it is not accepted into the queue
+        * to prevent spamming with system notification */
+       EVRNotificationType_Transient_SystemWithUserValue = 2,
+};
+
+enum EVRNotificationStyle
+{
+       /** Creates a notification with minimal external styling. */
+       EVRNotificationStyle_None = 0,
+
+       /** Used for notifications about overlay-level status. In Steam this is used for events like downloads completing. */
+       EVRNotificationStyle_Application = 100,
+
+       /** Used for notifications about contacts that are unknown or not available. In Steam this is used for friend invitations and offline friends. */
+       EVRNotificationStyle_Contact_Disabled = 200,
+
+       /** Used for notifications about contacts that are available but inactive. In Steam this is used for friends that are online but not playing a game. */
+       EVRNotificationStyle_Contact_Enabled = 201,
+
+       /** Used for notifications about contacts that are available and active. In Steam this is used for friends that are online and currently running a game. */
+       EVRNotificationStyle_Contact_Active = 202,
+};
+
+static const uint32_t k_unNotificationTextMaxSize = 256;
+
+typedef uint32_t VRNotificationId;
+
+
+
+#pragma pack( pop )
+
+/** Allows notification sources to interact with the VR system
+       This current interface is not yet implemented. Do not use yet. */
+class IVRNotifications
+{
+public:
+       /** Create a notification and enqueue it to be shown to the user.
+       * An overlay handle is required to create a notification, as otherwise it would be impossible for a user to act on it.
+       * To create a two-line notification, use a line break ('\n') to split the text into two lines.
+       * The pImage argument may be NULL, in which case the specified overlay's icon will be used instead. */
+       virtual EVRNotificationError CreateNotification( VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, const char *pchText, EVRNotificationStyle style, const NotificationBitmap_t *pImage, /* out */ VRNotificationId *pNotificationId ) = 0;
+
+       /** Destroy a notification, hiding it first if it currently shown to the user. */
+       virtual EVRNotificationError RemoveNotification( VRNotificationId notificationId ) = 0;
+
+};
+
+static const char * const IVRNotifications_Version = "IVRNotifications_002";
+
+} // namespace vr
+
+
+
+// ivroverlay.h
+namespace vr
+{
+
+       /** The maximum length of an overlay key in bytes, counting the terminating null character. */
+       static const uint32_t k_unVROverlayMaxKeyLength = 128;
+
+       /** The maximum length of an overlay name in bytes, counting the terminating null character. */
+       static const uint32_t k_unVROverlayMaxNameLength = 128;
+
+       /** The maximum number of overlays that can exist in the system at one time. */
+       static const uint32_t k_unMaxOverlayCount = 64;
+
+       /** The maximum number of overlay intersection mask primitives per overlay */
+       static const uint32_t k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+
+       /** Types of input supported by VR Overlays */
+       enum VROverlayInputMethod
+       {
+              VROverlayInputMethod_None              = 0, // No input events will be generated automatically for this overlay
+              VROverlayInputMethod_Mouse              = 1, // Tracked controllers will get mouse events automatically
+       };
+
+       /** Allows the caller to figure out which overlay transform getter to call. */
+       enum VROverlayTransformType
+       {
+              VROverlayTransform_Absolute                                   = 0,
+              VROverlayTransform_TrackedDeviceRelative       = 1,
+              VROverlayTransform_SystemOverlay                     = 2,
+              VROverlayTransform_TrackedComponent               = 3,
+       };
+
+       /** Overlay control settings */
+       enum VROverlayFlags
+       {
+              VROverlayFlags_None                     = 0,
+
+              // The following only take effect when rendered using the high quality render path (see SetHighQualityOverlay).
+              VROverlayFlags_Curved              = 1,
+              VROverlayFlags_RGSS4X              = 2,
+
+              // Set this flag on a dashboard overlay to prevent a tab from showing up for that overlay
+              VROverlayFlags_NoDashboardTab = 3,
+
+              // Set this flag on a dashboard that is able to deal with gamepad focus events
+              VROverlayFlags_AcceptsGamepadEvents = 4,
+
+              // Indicates that the overlay should dim/brighten to show gamepad focus
+              VROverlayFlags_ShowGamepadFocus = 5,
+
+              // When in VROverlayInputMethod_Mouse you can optionally enable sending VRScroll_t 
+              VROverlayFlags_SendVRScrollEvents = 6,
+              VROverlayFlags_SendVRTouchpadEvents = 7,
+
+              // If set this will render a vertical scroll wheel on the primary controller, 
+              //  only needed if not using VROverlayFlags_SendVRScrollEvents but you still want to represent a scroll wheel
+              VROverlayFlags_ShowTouchPadScrollWheel = 8,
+
+              // If this is set ownership and render access to the overlay are transferred 
+              // to the new scene process on a call to IVRApplications::LaunchInternalProcess
+              VROverlayFlags_TransferOwnershipToInternalProcess = 9,
+
+              // If set, renders 50% of the texture in each eye, side by side
+              VROverlayFlags_SideBySide_Parallel = 10, // Texture is left/right
+              VROverlayFlags_SideBySide_Crossed = 11, // Texture is crossed and right/left
+
+              VROverlayFlags_Panorama = 12, // Texture is a panorama
+              VROverlayFlags_StereoPanorama = 13, // Texture is a stereo panorama
+
+              // If this is set on an overlay owned by the scene application that overlay
+              // will be sorted with the "Other" overlays on top of all other scene overlays
+              VROverlayFlags_SortWithNonSceneOverlays = 14,
+
+              // If set, the overlay will be shown in the dashboard, otherwise it will be hidden.
+              VROverlayFlags_VisibleInDashboard = 15,
+       };
+
+       enum VRMessageOverlayResponse
+       {
+              VRMessageOverlayResponse_ButtonPress_0 = 0,
+              VRMessageOverlayResponse_ButtonPress_1 = 1,
+              VRMessageOverlayResponse_ButtonPress_2 = 2,
+              VRMessageOverlayResponse_ButtonPress_3 = 3,
+              VRMessageOverlayResponse_CouldntFindSystemOverlay = 4,
+              VRMessageOverlayResponse_CouldntFindOrCreateClientOverlay= 5,
+              VRMessageOverlayResponse_ApplicationQuit = 6
+       };
+
+       struct VROverlayIntersectionParams_t
+       {
+              HmdVector3_t vSource;
+              HmdVector3_t vDirection;
+              ETrackingUniverseOrigin eOrigin;
+       };
+
+       struct VROverlayIntersectionResults_t
+       {
+              HmdVector3_t vPoint;
+              HmdVector3_t vNormal;
+              HmdVector2_t vUVs;
+              float fDistance;
+       };
+
+       // Input modes for the Big Picture gamepad text entry
+       enum EGamepadTextInputMode
+       {
+              k_EGamepadTextInputModeNormal = 0,
+              k_EGamepadTextInputModePassword = 1,
+              k_EGamepadTextInputModeSubmit = 2,
+       };
+
+       // Controls number of allowed lines for the Big Picture gamepad text entry
+       enum EGamepadTextInputLineMode
+       {
+              k_EGamepadTextInputLineModeSingleLine = 0,
+              k_EGamepadTextInputLineModeMultipleLines = 1
+       };
+
+       /** Directions for changing focus between overlays with the gamepad */
+       enum EOverlayDirection
+       {
+              OverlayDirection_Up = 0,
+              OverlayDirection_Down = 1,
+              OverlayDirection_Left = 2,
+              OverlayDirection_Right = 3,
+              
+              OverlayDirection_Count = 4,
+       };
+
+       enum EVROverlayIntersectionMaskPrimitiveType
+       {
+              OverlayIntersectionPrimitiveType_Rectangle,
+              OverlayIntersectionPrimitiveType_Circle,
+       };
+
+       struct IntersectionMaskRectangle_t
+       {
+              float m_flTopLeftX;
+              float m_flTopLeftY;
+              float m_flWidth;
+              float m_flHeight;
+       };
+
+       struct IntersectionMaskCircle_t
+       {
+              float m_flCenterX;
+              float m_flCenterY;
+              float m_flRadius;
+       };
+
+       /** NOTE!!! If you change this you MUST manually update openvr_interop.cs.py and openvr_api_flat.h.py */
+       typedef union
+       {
+              IntersectionMaskRectangle_t m_Rectangle;
+              IntersectionMaskCircle_t m_Circle;
+       } VROverlayIntersectionMaskPrimitive_Data_t;
+
+       struct VROverlayIntersectionMaskPrimitive_t
+       {
+              EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+              VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+       };
+
+       class IVROverlay
+       {
+       public:
+
+              // ---------------------------------------------
+              // Overlay management methods
+              // ---------------------------------------------
+
+              /** Finds an existing overlay with the specified key. */
+              virtual EVROverlayError FindOverlay( const char *pchOverlayKey, VROverlayHandle_t * pOverlayHandle ) = 0;
+
+              /** Creates a new named overlay. All overlays start hidden and with default settings. */
+              virtual EVROverlayError CreateOverlay( const char *pchOverlayKey, const char *pchOverlayName, VROverlayHandle_t * pOverlayHandle ) = 0;
+
+              /** Destroys the specified overlay. When an application calls VR_Shutdown all overlays created by that app are
+              * automatically destroyed. */
+              virtual EVROverlayError DestroyOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Specify which overlay to use the high quality render path.  This overlay will be composited in during the distortion pass which
+              * results in it drawing on top of everything else, but also at a higher quality as it samples the source texture directly rather than
+              * rasterizing into each eye's render texture first.  Because if this, only one of these is supported at any given time.  It is most useful
+              * for overlays that are expected to take up most of the user's view (e.g. streaming video).
+              * This mode does not support mouse input to your overlay. */
+              virtual EVROverlayError SetHighQualityOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Returns the overlay handle of the current overlay being rendered using the single high quality overlay render path.
+              * Otherwise it will return k_ulOverlayHandleInvalid. */
+              virtual vr::VROverlayHandle_t GetHighQualityOverlay() = 0;
+
+              /** Fills the provided buffer with the string key of the overlay. Returns the size of buffer required to store the key, including
+              * the terminating null character. k_unVROverlayMaxKeyLength will be enough bytes to fit the string. */
+              virtual uint32_t GetOverlayKey( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
+
+              /** Fills the provided buffer with the friendly name of the overlay. Returns the size of buffer required to store the key, including
+              * the terminating null character. k_unVROverlayMaxNameLength will be enough bytes to fit the string. */
+              virtual uint32_t GetOverlayName( VROverlayHandle_t ulOverlayHandle, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize, EVROverlayError *pError = 0L ) = 0;
+
+              /** set the name to use for this overlay */
+              virtual EVROverlayError SetOverlayName( VROverlayHandle_t ulOverlayHandle, const char *pchName ) = 0;
+
+              /** Gets the raw image data from an overlay. Overlay image data is always returned as RGBA data, 4 bytes per pixel. If the buffer is not large enough, width and height 
+              * will be set and VROverlayError_ArrayTooSmall is returned. */
+              virtual EVROverlayError GetOverlayImageData( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unBufferSize, uint32_t *punWidth, uint32_t *punHeight ) = 0;
+
+              /** returns a string that corresponds with the specified overlay error. The string will be the name 
+              * of the error enum value for all valid error codes */
+              virtual const char *GetOverlayErrorNameFromEnum( EVROverlayError error ) = 0;
+
+              // ---------------------------------------------
+              // Overlay rendering methods
+              // ---------------------------------------------
+
+              /** Sets the pid that is allowed to render to this overlay (the creator pid is always allow to render),
+              *       by default this is the pid of the process that made the overlay */
+              virtual EVROverlayError SetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle, uint32_t unPID ) = 0;
+
+              /** Gets the pid that is allowed to render to this overlay */
+              virtual uint32_t GetOverlayRenderingPid( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Specify flag setting for a given overlay */
+              virtual EVROverlayError SetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled ) = 0;
+
+              /** Sets flag setting for a given overlay */
+              virtual EVROverlayError GetOverlayFlag( VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool *pbEnabled ) = 0;
+
+              /** Sets the color tint of the overlay quad. Use 0.0 to 1.0 per channel. */
+              virtual EVROverlayError SetOverlayColor( VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue ) = 0;
+
+              /** Gets the color tint of the overlay quad. */
+              virtual EVROverlayError GetOverlayColor( VROverlayHandle_t ulOverlayHandle, float *pfRed, float *pfGreen, float *pfBlue ) = 0;
+
+              /** Sets the alpha of the overlay quad. Use 1.0 for 100 percent opacity to 0.0 for 0 percent opacity. */
+              virtual EVROverlayError SetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float fAlpha ) = 0;
+
+              /** Gets the alpha of the overlay quad. By default overlays are rendering at 100 percent alpha (1.0). */
+              virtual EVROverlayError GetOverlayAlpha( VROverlayHandle_t ulOverlayHandle, float *pfAlpha ) = 0;
+
+              /** Sets the aspect ratio of the texels in the overlay. 1.0 means the texels are square. 2.0 means the texels
+              * are twice as wide as they are tall. Defaults to 1.0. */
+              virtual EVROverlayError SetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float fTexelAspect ) = 0;
+
+              /** Gets the aspect ratio of the texels in the overlay. Defaults to 1.0 */
+              virtual EVROverlayError GetOverlayTexelAspect( VROverlayHandle_t ulOverlayHandle, float *pfTexelAspect ) = 0;
+
+              /** Sets the rendering sort order for the overlay. Overlays are rendered this order:
+              *      Overlays owned by the scene application
+              *      Overlays owned by some other application
+              *
+              *       Within a category overlays are rendered lowest sort order to highest sort order. Overlays with the same 
+              *       sort order are rendered back to front base on distance from the HMD.
+              *
+              *       Sort order defaults to 0. */
+              virtual EVROverlayError SetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder ) = 0;
+
+              /** Gets the sort order of the overlay. See SetOverlaySortOrder for how this works. */
+              virtual EVROverlayError GetOverlaySortOrder( VROverlayHandle_t ulOverlayHandle, uint32_t *punSortOrder ) = 0;
+
+              /** Sets the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+              virtual EVROverlayError SetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float fWidthInMeters ) = 0;
+
+              /** Returns the width of the overlay quad in meters. By default overlays are rendered on a quad that is 1 meter across */
+              virtual EVROverlayError GetOverlayWidthInMeters( VROverlayHandle_t ulOverlayHandle, float *pfWidthInMeters ) = 0;
+
+              /** For high-quality curved overlays only, sets the distance range in meters from the overlay used to automatically curve
+              * the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+              virtual EVROverlayError SetOverlayAutoCurveDistanceRangeInMeters( VROverlayHandle_t ulOverlayHandle, float fMinDistanceInMeters, float fMaxDistanceInMeters ) = 0;
+
+              /** For high-quality curved overlays only, gets the distance range in meters from the overlay used to automatically curve
+              * the surface around the viewer.  Min is distance is when the surface will be most curved.  Max is when least curved. */
+              virtual EVROverlayError GetOverlayAutoCurveDistanceRangeInMeters( VROverlayHandle_t ulOverlayHandle, float *pfMinDistanceInMeters, float *pfMaxDistanceInMeters ) = 0;
+
+              /** Sets the colorspace the overlay texture's data is in.  Defaults to 'auto'.
+              * If the texture needs to be resolved, you should call SetOverlayTexture with the appropriate colorspace instead. */
+              virtual EVROverlayError SetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace ) = 0;
+
+              /** Gets the overlay's current colorspace setting. */
+              virtual EVROverlayError GetOverlayTextureColorSpace( VROverlayHandle_t ulOverlayHandle, EColorSpace *peTextureColorSpace ) = 0;
+
+              /** Sets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+              virtual EVROverlayError SetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, const VRTextureBounds_t *pOverlayTextureBounds ) = 0;
+
+              /** Gets the part of the texture to use for the overlay. UV Min is the upper left corner and UV Max is the lower right corner. */
+              virtual EVROverlayError GetOverlayTextureBounds( VROverlayHandle_t ulOverlayHandle, VRTextureBounds_t *pOverlayTextureBounds ) = 0;
+
+              /** Gets render model to draw behind this overlay */
+              virtual uint32_t GetOverlayRenderModel( vr::VROverlayHandle_t ulOverlayHandle, char *pchValue, uint32_t unBufferSize, HmdColor_t *pColor, vr::EVROverlayError *pError ) = 0;
+
+              /** Sets render model to draw behind this overlay and the vertex color to use, pass null for pColor to match the overlays vertex color. 
+                     The model is scaled by the same amount as the overlay, with a default of 1m. */
+              virtual vr::EVROverlayError SetOverlayRenderModel( vr::VROverlayHandle_t ulOverlayHandle, const char *pchRenderModel, const HmdColor_t *pColor ) = 0;
+
+              /** Returns the transform type of this overlay. */
+              virtual EVROverlayError GetOverlayTransformType( VROverlayHandle_t ulOverlayHandle, VROverlayTransformType *peTransformType ) = 0;
+
+              /** Sets the transform to absolute tracking origin. */
+              virtual EVROverlayError SetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
+
+              /** Gets the transform if it is absolute. Returns an error if the transform is some other type. */
+              virtual EVROverlayError GetOverlayTransformAbsolute( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin *peTrackingOrigin, HmdMatrix34_t *pmatTrackingOriginToOverlayTransform ) = 0;
+
+              /** Sets the transform to relative to the transform of the specified tracked device. */
+              virtual EVROverlayError SetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, const HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
+
+              /** Gets the transform if it is relative to a tracked device. Returns an error if the transform is some other type. */
+              virtual EVROverlayError GetOverlayTransformTrackedDeviceRelative( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punTrackedDevice, HmdMatrix34_t *pmatTrackedDeviceToOverlayTransform ) = 0;
+
+              /** Sets the transform to draw the overlay on a rendermodel component mesh instead of a quad. This will only draw when the system is
+              * drawing the device. Overlays with this transform type cannot receive mouse events. */
+              virtual EVROverlayError SetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, const char *pchComponentName ) = 0;
+
+              /** Gets the transform information when the overlay is rendering on a component. */
+              virtual EVROverlayError GetOverlayTransformTrackedDeviceComponent( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t *punDeviceIndex, char *pchComponentName, uint32_t unComponentNameSize ) = 0;
+
+              /** Gets the transform if it is relative to another overlay. Returns an error if the transform is some other type. */
+              virtual vr::EVROverlayError GetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t *ulOverlayHandleParent, HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
+              
+              /** Sets the transform to relative to the transform of the specified overlay. This overlays visibility will also track the parents visibility */
+              virtual vr::EVROverlayError SetOverlayTransformOverlayRelative( VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, const HmdMatrix34_t *pmatParentOverlayToOverlayTransform ) = 0;
+
+              /** Shows the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+              virtual EVROverlayError ShowOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Hides the VR overlay.  For dashboard overlays, only the Dashboard Manager is allowed to call this. */
+              virtual EVROverlayError HideOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Returns true if the overlay is visible. */
+              virtual bool IsOverlayVisible( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Get the transform in 3d space associated with a specific 2d point in the overlay's coordinate space (where 0,0 is the lower left). -Z points out of the overlay */
+              virtual EVROverlayError GetTransformForOverlayCoordinates( VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, HmdVector2_t coordinatesInOverlay, HmdMatrix34_t *pmatTransform ) = 0;
+
+              // ---------------------------------------------
+              // Overlay input methods
+              // ---------------------------------------------
+
+              /** Returns true and fills the event with the next event on the overlay's event queue, if there is one. 
+              * If there are no events this method returns false. uncbVREvent should be the size in bytes of the VREvent_t struct */
+              virtual bool PollNextOverlayEvent( VROverlayHandle_t ulOverlayHandle, VREvent_t *pEvent, uint32_t uncbVREvent ) = 0;
+
+              /** Returns the current input settings for the specified overlay. */
+              virtual EVROverlayError GetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod *peInputMethod ) = 0;
+
+              /** Sets the input settings for the specified overlay. */
+              virtual EVROverlayError SetOverlayInputMethod( VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod ) = 0;
+
+              /** Gets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+              * typically the size of the underlying UI in pixels. */
+              virtual EVROverlayError GetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, HmdVector2_t *pvecMouseScale ) = 0;
+
+              /** Sets the mouse scaling factor that is used for mouse events. The actual texture may be a different size, but this is
+              * typically the size of the underlying UI in pixels (not in world space). */
+              virtual EVROverlayError SetOverlayMouseScale( VROverlayHandle_t ulOverlayHandle, const HmdVector2_t *pvecMouseScale ) = 0;
+
+              /** Computes the overlay-space pixel coordinates of where the ray intersects the overlay with the
+              * specified settings. Returns false if there is no intersection. */
+              virtual bool ComputeOverlayIntersection( VROverlayHandle_t ulOverlayHandle, const VROverlayIntersectionParams_t *pParams, VROverlayIntersectionResults_t *pResults ) = 0;
+
+              /** Processes mouse input from the specified controller as though it were a mouse pointed at a compositor overlay with the
+              * specified settings. The controller is treated like a laser pointer on the -z axis. The point where the laser pointer would
+              * intersect with the overlay is the mouse position, the trigger is left mouse, and the track pad is right mouse. 
+              *
+              * Return true if the controller is pointed at the overlay and an event was generated. */
+              virtual bool HandleControllerOverlayInteractionAsMouse( VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unControllerDeviceIndex ) = 0;
+
+              /** Returns true if the specified overlay is the hover target. An overlay is the hover target when it is the last overlay "moused over" 
+              * by the virtual mouse pointer */
+              virtual bool IsHoverTargetOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Returns the current Gamepad focus overlay */
+              virtual vr::VROverlayHandle_t GetGamepadFocusOverlay() = 0;
+
+              /** Sets the current Gamepad focus overlay */
+              virtual EVROverlayError SetGamepadFocusOverlay( VROverlayHandle_t ulNewFocusOverlay ) = 0;
+
+              /** Sets an overlay's neighbor. This will also set the neighbor of the "to" overlay
+              * to point back to the "from" overlay. If an overlay's neighbor is set to invalid both
+              * ends will be cleared */
+              virtual EVROverlayError SetOverlayNeighbor( EOverlayDirection eDirection, VROverlayHandle_t ulFrom, VROverlayHandle_t ulTo ) = 0;
+
+              /** Changes the Gamepad focus from one overlay to one of its neighbors. Returns VROverlayError_NoNeighbor if there is no
+              * neighbor in that direction */
+              virtual EVROverlayError MoveGamepadFocusToNeighbor( EOverlayDirection eDirection, VROverlayHandle_t ulFrom ) = 0;
+
+              // ---------------------------------------------
+              // Overlay texture methods
+              // ---------------------------------------------
+
+              /** Texture to draw for the overlay. This function can only be called by the overlay's creator or renderer process (see SetOverlayRenderingPid) .
+              *
+              * OpenGL dirty state:
+              *       glBindTexture
+              */
+              virtual EVROverlayError SetOverlayTexture( VROverlayHandle_t ulOverlayHandle, const Texture_t *pTexture ) = 0;
+
+              /** Use this to tell the overlay system to release the texture set for this overlay. */
+              virtual EVROverlayError ClearOverlayTexture( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Separate interface for providing the data as a stream of bytes, but there is an upper bound on data 
+              * that can be sent. This function can only be called by the overlay's renderer process. */
+              virtual EVROverlayError SetOverlayRaw( VROverlayHandle_t ulOverlayHandle, void *pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unDepth ) = 0;
+
+              /** Separate interface for providing the image through a filename: can be png or jpg, and should not be bigger than 1920x1080.
+              * This function can only be called by the overlay's renderer process */
+              virtual EVROverlayError SetOverlayFromFile( VROverlayHandle_t ulOverlayHandle, const char *pchFilePath ) = 0;
+
+              /** Get the native texture handle/device for an overlay you have created.
+              * On windows this handle will be a ID3D11ShaderResourceView with a ID3D11Texture2D bound.
+              *
+              * The texture will always be sized to match the backing texture you supplied in SetOverlayTexture above.
+              *
+              * You MUST call ReleaseNativeOverlayHandle() with pNativeTextureHandle once you are done with this texture.
+              *
+              * pNativeTextureHandle is an OUTPUT, it will be a pointer to a ID3D11ShaderResourceView *.
+              * pNativeTextureRef is an INPUT and should be a ID3D11Resource *. The device used by pNativeTextureRef will be used to bind pNativeTextureHandle.
+              */
+              virtual EVROverlayError GetOverlayTexture( VROverlayHandle_t ulOverlayHandle, void **pNativeTextureHandle, void *pNativeTextureRef, uint32_t *pWidth, uint32_t *pHeight, uint32_t *pNativeFormat, ETextureType *pAPIType, EColorSpace *pColorSpace, VRTextureBounds_t *pTextureBounds ) = 0;
+
+              /** Release the pNativeTextureHandle provided from the GetOverlayTexture call, this allows the system to free the underlying GPU resources for this object,
+              * so only do it once you stop rendering this texture.
+              */
+              virtual EVROverlayError ReleaseNativeOverlayHandle( VROverlayHandle_t ulOverlayHandle, void *pNativeTextureHandle ) = 0;
+
+              /** Get the size of the overlay texture */
+              virtual EVROverlayError GetOverlayTextureSize( VROverlayHandle_t ulOverlayHandle, uint32_t *pWidth, uint32_t *pHeight ) = 0;
+
+              // ----------------------------------------------
+              // Dashboard Overlay Methods
+              // ----------------------------------------------
+
+              /** Creates a dashboard overlay and returns its handle */
+              virtual EVROverlayError CreateDashboardOverlay( const char *pchOverlayKey, const char *pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t *pThumbnailHandle ) = 0;
+
+              /** Returns true if the dashboard is visible */
+              virtual bool IsDashboardVisible() = 0;
+
+              /** returns true if the dashboard is visible and the specified overlay is the active system Overlay */
+              virtual bool IsActiveDashboardOverlay( VROverlayHandle_t ulOverlayHandle ) = 0;
+
+              /** Sets the dashboard overlay to only appear when the specified process ID has scene focus */
+              virtual EVROverlayError SetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId ) = 0;
+
+              /** Gets the process ID that this dashboard overlay requires to have scene focus */
+              virtual EVROverlayError GetDashboardOverlaySceneProcess( VROverlayHandle_t ulOverlayHandle, uint32_t *punProcessId ) = 0;
+
+              /** Shows the dashboard. */
+              virtual void ShowDashboard( const char *pchOverlayToShow ) = 0;
+
+              /** Returns the tracked device that has the laser pointer in the dashboard */
+              virtual vr::TrackedDeviceIndex_t GetPrimaryDashboardDevice() = 0;
+
+              // ---------------------------------------------
+              // Keyboard methods
+              // ---------------------------------------------
+              
+              /** Show the virtual keyboard to accept input **/
+              virtual EVROverlayError ShowKeyboard( EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue ) = 0;
+
+              virtual EVROverlayError ShowKeyboardForOverlay( VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, const char *pchDescription, uint32_t unCharMax, const char *pchExistingText, bool bUseMinimalMode, uint64_t uUserValue ) = 0;
+
+              /** Get the text that was entered into the text input **/
+              virtual uint32_t GetKeyboardText( VR_OUT_STRING() char *pchText, uint32_t cchText ) = 0;
+
+              /** Hide the virtual keyboard **/
+              virtual void HideKeyboard() = 0;
+
+              /** Set the position of the keyboard in world space **/
+              virtual void SetKeyboardTransformAbsolute( ETrackingUniverseOrigin eTrackingOrigin, const HmdMatrix34_t *pmatTrackingOriginToKeyboardTransform ) = 0;
+
+              /** Set the position of the keyboard in overlay space by telling it to avoid a rectangle in the overlay. Rectangle coords have (0,0) in the bottom left **/
+              virtual void SetKeyboardPositionForOverlay( VROverlayHandle_t ulOverlayHandle, HmdRect2_t avoidRect ) = 0;
+
+              // ---------------------------------------------
+              // Overlay input methods
+              // ---------------------------------------------
+
+              /** Sets a list of primitives to be used for controller ray intersection
+              * typically the size of the underlying UI in pixels (not in world space). */
+              virtual EVROverlayError SetOverlayIntersectionMask( VROverlayHandle_t ulOverlayHandle, VROverlayIntersectionMaskPrimitive_t *pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize = sizeof( VROverlayIntersectionMaskPrimitive_t ) ) = 0;
+
+              virtual EVROverlayError GetOverlayFlags( VROverlayHandle_t ulOverlayHandle, uint32_t *pFlags ) = 0;
+
+              // ---------------------------------------------
+              // Message box methods
+              // ---------------------------------------------
+
+              /** Show the message overlay. This will block and return you a result. **/
+              virtual VRMessageOverlayResponse ShowMessageOverlay( const char* pchText, const char* pchCaption, const char* pchButton0Text, const char* pchButton1Text = nullptr, const char* pchButton2Text = nullptr, const char* pchButton3Text = nullptr ) = 0;
+
+              /** If the calling process owns the overlay and it's open, this will close it. **/
+              virtual void CloseMessageOverlay() = 0;
+       };
+
+       static const char * const IVROverlay_Version = "IVROverlay_016";
+
+} // namespace vr
+
+// ivrrendermodels.h
+namespace vr
+{
+
+static const char * const k_pch_Controller_Component_GDC2015 = "gdc2015";   // Canonical coordinate system of the gdc 2015 wired controller, provided for backwards compatibility
+static const char * const k_pch_Controller_Component_Base = "base";         // For controllers with an unambiguous 'base'.
+static const char * const k_pch_Controller_Component_Tip = "tip";           // For controllers with an unambiguous 'tip' (used for 'laser-pointing')
+static const char * const k_pch_Controller_Component_HandGrip = "handgrip"; // Neutral, ambidextrous hand-pose when holding controller. On plane between neutrally posed index finger and thumb
+static const char * const k_pch_Controller_Component_Status = "status";              // 1:1 aspect ratio status area, with canonical [0,1] uv mapping
+
+#pragma pack( push, 8 )
+
+/** Errors that can occur with the VR compositor */
+enum EVRRenderModelError
+{
+       VRRenderModelError_None = 0,
+       VRRenderModelError_Loading = 100,
+       VRRenderModelError_NotSupported = 200,
+       VRRenderModelError_InvalidArg = 300,
+       VRRenderModelError_InvalidModel = 301,
+       VRRenderModelError_NoShapes = 302,
+       VRRenderModelError_MultipleShapes = 303,
+       VRRenderModelError_TooManyVertices = 304,
+       VRRenderModelError_MultipleTextures = 305,
+       VRRenderModelError_BufferTooSmall = 306,
+       VRRenderModelError_NotEnoughNormals = 307,
+       VRRenderModelError_NotEnoughTexCoords = 308,
+
+       VRRenderModelError_InvalidTexture = 400,
+};
+
+typedef uint32_t VRComponentProperties;
+
+enum EVRComponentProperty
+{
+       VRComponentProperty_IsStatic = (1 << 0),
+       VRComponentProperty_IsVisible = (1 << 1),
+       VRComponentProperty_IsTouched = (1 << 2),
+       VRComponentProperty_IsPressed = (1 << 3),
+       VRComponentProperty_IsScrolled = (1 << 4),
+};
+
+/** Describes state information about a render-model component, including transforms and other dynamic properties */
+struct RenderModel_ComponentState_t
+{
+       HmdMatrix34_t mTrackingToComponentRenderModel;  // Transform required when drawing the component render model
+       HmdMatrix34_t mTrackingToComponentLocal;        // Transform available for attaching to a local component coordinate system (-Z out from surface )
+       VRComponentProperties uProperties;
+};
+
+/** A single vertex in a render model */
+struct RenderModel_Vertex_t
+{
+       HmdVector3_t vPosition;              // position in meters in device space
+       HmdVector3_t vNormal;
+       float rfTextureCoord[2];
+};
+
+/** A texture map for use on a render model */
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_TextureMap_t
+{
+       uint16_t unWidth, unHeight; // width and height of the texture map in pixels
+       const uint8_t *rubTextureMapData;       // Map texture data. All textures are RGBA with 8 bits per channel per pixel. Data size is width * height * 4ub
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+/**  Session unique texture identifier. Rendermodels which share the same texture will have the same id.
+IDs <0 denote the texture is not present */
+
+typedef int32_t TextureID_t;
+
+const TextureID_t INVALID_TEXTURE_ID = -1;
+
+#if defined(__linux__) || defined(__APPLE__) 
+// This structure was originally defined mis-packed on Linux, preserved for 
+// compatibility. 
+#pragma pack( push, 4 )
+#endif
+
+struct RenderModel_t
+{
+       const RenderModel_Vertex_t *rVertexData;       // Vertex data for the mesh
+       uint32_t unVertexCount;                                          // Number of vertices in the vertex data
+       const uint16_t *rIndexData;                                   // Indices into the vertex data for each triangle
+       uint32_t unTriangleCount;                                   // Number of triangles in the mesh. Index count is 3 * TriangleCount
+       TextureID_t diffuseTextureId;                            // Session unique texture identifier. Rendermodels which share the same texture will have the same id. <0 == texture not present
+};
+#if defined(__linux__) || defined(__APPLE__) 
+#pragma pack( pop )
+#endif
+
+
+struct RenderModel_ControllerMode_State_t
+{
+       bool bScrollWheelVisible; // is this controller currently set to be in a scroll wheel mode
+};
+
+#pragma pack( pop )
+
+class IVRRenderModels
+{
+public:
+
+       /** Loads and returns a render model for use in the application. pchRenderModelName should be a render model name
+       * from the Prop_RenderModelName_String property or an absolute path name to a render model on disk. 
+       *
+       * The resulting render model is valid until VR_Shutdown() is called or until FreeRenderModel() is called. When the 
+       * application is finished with the render model it should call FreeRenderModel() to free the memory associated
+       * with the model.
+       *
+       * The method returns VRRenderModelError_Loading while the render model is still being loaded.
+       * The method returns VRRenderModelError_None once loaded successfully, otherwise will return an error. */
+       virtual EVRRenderModelError LoadRenderModel_Async( const char *pchRenderModelName, RenderModel_t **ppRenderModel ) = 0;
+
+       /** Frees a previously returned render model
+       *   It is safe to call this on a null ptr. */
+       virtual void FreeRenderModel( RenderModel_t *pRenderModel ) = 0;
+
+       /** Loads and returns a texture for use in the application. */
+       virtual EVRRenderModelError LoadTexture_Async( TextureID_t textureId, RenderModel_TextureMap_t **ppTexture ) = 0;
+
+       /** Frees a previously returned texture
+       *   It is safe to call this on a null ptr. */
+       virtual void FreeTexture( RenderModel_TextureMap_t *pTexture ) = 0;
+
+       /** Creates a D3D11 texture and loads data into it. */
+       virtual EVRRenderModelError LoadTextureD3D11_Async( TextureID_t textureId, void *pD3D11Device, void **ppD3D11Texture2D ) = 0;
+
+       /** Helper function to copy the bits into an existing texture. */
+       virtual EVRRenderModelError LoadIntoTextureD3D11_Async( TextureID_t textureId, void *pDstTexture ) = 0;
+
+       /** Use this to free textures created with LoadTextureD3D11_Async instead of calling Release on them. */
+       virtual void FreeTextureD3D11( void *pD3D11Texture2D ) = 0;
+
+       /** Use this to get the names of available render models.  Index does not correlate to a tracked device index, but
+       * is only used for iterating over all available render models.  If the index is out of range, this function will return 0.
+       * Otherwise, it will return the size of the buffer required for the name. */
+       virtual uint32_t GetRenderModelName( uint32_t unRenderModelIndex, VR_OUT_STRING() char *pchRenderModelName, uint32_t unRenderModelNameLen ) = 0;
+
+       /** Returns the number of available render models. */
+       virtual uint32_t GetRenderModelCount() = 0;
+
+
+       /** Returns the number of components of the specified render model.
+       *  Components are useful when client application wish to draw, label, or otherwise interact with components of tracked objects.
+       *  Examples controller components:
+       *   renderable things such as triggers, buttons
+       *   non-renderable things which include coordinate systems such as 'tip', 'base', a neutral controller agnostic hand-pose
+       *   If all controller components are enumerated and rendered, it will be equivalent to drawing the traditional render model
+       *   Returns 0 if components not supported, >0 otherwise */
+       virtual uint32_t GetComponentCount( const char *pchRenderModelName ) = 0;
+
+       /** Use this to get the names of available components.  Index does not correlate to a tracked device index, but
+       * is only used for iterating over all available components.  If the index is out of range, this function will return 0.
+       * Otherwise, it will return the size of the buffer required for the name. */
+       virtual uint32_t GetComponentName( const char *pchRenderModelName, uint32_t unComponentIndex, VR_OUT_STRING( ) char *pchComponentName, uint32_t unComponentNameLen ) = 0;
+
+       /** Get the button mask for all buttons associated with this component
+       *   If no buttons (or axes) are associated with this component, return 0
+       *   Note: multiple components may be associated with the same button. Ex: two grip buttons on a single controller.
+       *   Note: A single component may be associated with multiple buttons. Ex: A trackpad which also provides "D-pad" functionality */
+       virtual uint64_t GetComponentButtonMask( const char *pchRenderModelName, const char *pchComponentName ) = 0;
+
+       /** Use this to get the render model name for the specified rendermode/component combination, to be passed to LoadRenderModel.
+       * If the component name is out of range, this function will return 0.
+       * Otherwise, it will return the size of the buffer required for the name. */
+       virtual uint32_t GetComponentRenderModelName( const char *pchRenderModelName, const char *pchComponentName, VR_OUT_STRING( ) char *pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen ) = 0;
+
+       /** Use this to query information about the component, as a function of the controller state.
+       *
+       * For dynamic controller components (ex: trigger) values will reflect component motions
+       * For static components this will return a consistent value independent of the VRControllerState_t
+       *
+       * If the pchRenderModelName or pchComponentName is invalid, this will return false (and transforms will be set to identity).
+       * Otherwise, return true
+       * Note: For dynamic objects, visibility may be dynamic. (I.e., true/false will be returned based on controller state and controller mode state ) */
+       virtual bool GetComponentState( const char *pchRenderModelName, const char *pchComponentName, const vr::VRControllerState_t *pControllerState, const RenderModel_ControllerMode_State_t *pState, RenderModel_ComponentState_t *pComponentState ) = 0;
+
+       /** Returns true if the render model has a component with the specified name */
+       virtual bool RenderModelHasComponent( const char *pchRenderModelName, const char *pchComponentName ) = 0;
+
+       /** Returns the URL of the thumbnail image for this rendermodel */
+       virtual uint32_t GetRenderModelThumbnailURL( const char *pchRenderModelName, VR_OUT_STRING() char *pchThumbnailURL, uint32_t unThumbnailURLLen, vr::EVRRenderModelError *peError ) = 0;
+
+       /** Provides a render model path that will load the unskinned model if the model name provided has been replace by the user. If the model
+       * hasn't been replaced the path value will still be a valid path to load the model. Pass this to LoadRenderModel_Async, etc. to load the
+       * model. */
+       virtual uint32_t GetRenderModelOriginalPath( const char *pchRenderModelName, VR_OUT_STRING() char *pchOriginalPath, uint32_t unOriginalPathLen, vr::EVRRenderModelError *peError ) = 0;
+
+       /** Returns a string for a render model error */
+       virtual const char *GetRenderModelErrorNameFromEnum( vr::EVRRenderModelError error ) = 0;
+};
+
+static const char * const IVRRenderModels_Version = "IVRRenderModels_005";
+
+}
+
+
+// ivrextendeddisplay.h
+namespace vr
+{
+
+       /** NOTE: Use of this interface is not recommended in production applications. It will not work for displays which use
+       * direct-to-display mode. Creating our own window is also incompatible with the VR compositor and is not available when the compositor is running. */
+       class IVRExtendedDisplay
+       {
+       public:
+
+              /** Size and position that the window needs to be on the VR display. */
+              virtual void GetWindowBounds( int32_t *pnX, int32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+              /** Gets the viewport in the frame buffer to draw the output of the distortion into */
+              virtual void GetEyeOutputViewport( EVREye eEye, uint32_t *pnX, uint32_t *pnY, uint32_t *pnWidth, uint32_t *pnHeight ) = 0;
+
+              /** [D3D10/11 Only]
+              * Returns the adapter index and output index that the user should pass into EnumAdapters and EnumOutputs
+              * to create the device and swap chain in DX10 and DX11. If an error occurs both indices will be set to -1.
+              */
+              virtual void GetDXGIOutputInfo( int32_t *pnAdapterIndex, int32_t *pnAdapterOutputIndex ) = 0;
+
+       };
+
+       static const char * const IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+
+}
+
+
+// ivrtrackedcamera.h
+namespace vr
+{
+
+class IVRTrackedCamera
+{
+public:
+       /** Returns a string for an error */
+       virtual const char *GetCameraErrorNameFromEnum( vr::EVRTrackedCameraError eCameraError ) = 0;
+
+       /** For convenience, same as tracked property request Prop_HasCamera_Bool */
+       virtual vr::EVRTrackedCameraError HasCamera( vr::TrackedDeviceIndex_t nDeviceIndex, bool *pHasCamera ) = 0;
+
+       /** Gets size of the image frame. */
+       virtual vr::EVRTrackedCameraError GetCameraFrameSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, uint32_t *pnWidth, uint32_t *pnHeight, uint32_t *pnFrameBufferSize ) = 0;
+
+       virtual vr::EVRTrackedCameraError GetCameraIntrinsics( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::HmdVector2_t *pFocalLength, vr::HmdVector2_t *pCenter ) = 0;
+
+       virtual vr::EVRTrackedCameraError GetCameraProjection( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, vr::HmdMatrix44_t *pProjection ) = 0;
+
+       /** Acquiring streaming service permits video streaming for the caller. Releasing hints the system that video services do not need to be maintained for this client.
+       * If the camera has not already been activated, a one time spin up may incur some auto exposure as well as initial streaming frame delays.
+       * The camera should be considered a global resource accessible for shared consumption but not exclusive to any caller.
+       * The camera may go inactive due to lack of active consumers or headset idleness. */
+       virtual vr::EVRTrackedCameraError AcquireVideoStreamingService( vr::TrackedDeviceIndex_t nDeviceIndex, vr::TrackedCameraHandle_t *pHandle ) = 0;
+       virtual vr::EVRTrackedCameraError ReleaseVideoStreamingService( vr::TrackedCameraHandle_t hTrackedCamera ) = 0;
+
+       /** Copies the image frame into a caller's provided buffer. The image data is currently provided as RGBA data, 4 bytes per pixel.
+       * A caller can provide null for the framebuffer or frameheader if not desired. Requesting the frame header first, followed by the frame buffer allows
+       * the caller to determine if the frame as advanced per the frame header sequence. 
+       * If there is no frame available yet, due to initial camera spinup or re-activation, the error will be VRTrackedCameraError_NoFrameAvailable.
+       * Ideally a caller should be polling at ~16ms intervals */
+       virtual vr::EVRTrackedCameraError GetVideoStreamFrameBuffer( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pFrameBuffer, uint32_t nFrameBufferSize, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+
+       /** Gets size of the image frame. */
+       virtual vr::EVRTrackedCameraError GetVideoStreamTextureSize( vr::TrackedDeviceIndex_t nDeviceIndex, vr::EVRTrackedCameraFrameType eFrameType, vr::VRTextureBounds_t *pTextureBounds, uint32_t *pnWidth, uint32_t *pnHeight ) = 0; 
+
+       /** Access a shared D3D11 texture for the specified tracked camera stream.
+       * The camera frame type VRTrackedCameraFrameType_Undistorted is not supported directly as a shared texture. It is an interior subregion of the shared texture VRTrackedCameraFrameType_MaximumUndistorted.
+       * Instead, use GetVideoStreamTextureSize() with VRTrackedCameraFrameType_Undistorted to determine the proper interior subregion bounds along with GetVideoStreamTextureD3D11() with
+       * VRTrackedCameraFrameType_MaximumUndistorted to provide the texture. The VRTrackedCameraFrameType_MaximumUndistorted will yield an image where the invalid regions are decoded
+       * by the alpha channel having a zero component. The valid regions all have a non-zero alpha component. The subregion as described by VRTrackedCameraFrameType_Undistorted 
+       * guarantees a rectangle where all pixels are valid. */
+       virtual vr::EVRTrackedCameraError GetVideoStreamTextureD3D11( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, void *pD3D11DeviceOrResource, void **ppD3D11ShaderResourceView, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+
+       /** Access a shared GL texture for the specified tracked camera stream */
+       virtual vr::EVRTrackedCameraError GetVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::EVRTrackedCameraFrameType eFrameType, vr::glUInt_t *pglTextureId, vr::CameraVideoStreamFrameHeader_t *pFrameHeader, uint32_t nFrameHeaderSize ) = 0;
+       virtual vr::EVRTrackedCameraError ReleaseVideoStreamTextureGL( vr::TrackedCameraHandle_t hTrackedCamera, vr::glUInt_t glTextureId ) = 0;
+};
+
+static const char * const IVRTrackedCamera_Version = "IVRTrackedCamera_003";
+
+} // namespace vr
+
+
+// ivrscreenshots.h
+namespace vr
+{
+
+/** Errors that can occur with the VR compositor */
+enum EVRScreenshotError
+{
+       VRScreenshotError_None                                                 = 0,
+       VRScreenshotError_RequestFailed                                   = 1,
+       VRScreenshotError_IncompatibleVersion                     = 100,
+       VRScreenshotError_NotFound                                          = 101,
+       VRScreenshotError_BufferTooSmall                            = 102,
+       VRScreenshotError_ScreenshotAlreadyInProgress       = 108,
+};
+
+/** Allows the application to generate screenshots */
+class IVRScreenshots
+{
+public:
+       /** Request a screenshot of the requested type.
+        *  A request of the VRScreenshotType_Stereo type will always
+        *  work. Other types will depend on the underlying application
+        *  support.
+        *  The first file name is for the preview image and should be a
+        *  regular screenshot (ideally from the left eye). The second
+        *  is the VR screenshot in the correct format. They should be
+        *  in the same aspect ratio.  Formats per type:
+        *  VRScreenshotType_Mono: the VR filename is ignored (can be
+        *  nullptr), this is a normal flat single shot.
+        *  VRScreenshotType_Stereo:  The VR image should be a
+        *  side-by-side with the left eye image on the left.
+        *  VRScreenshotType_Cubemap: The VR image should be six square
+        *  images composited horizontally.
+        *  VRScreenshotType_StereoPanorama: above/below with left eye
+        *  panorama being the above image.  Image is typically square
+        *  with the panorama being 2x horizontal.
+        *  
+        *  Note that the VR dashboard will call this function when
+        *  the user presses the screenshot binding (currently System
+        *  Button + Trigger).  If Steam is running, the destination
+        *  file names will be in %TEMP% and will be copied into
+        *  Steam's screenshot library for the running application
+        *  once SubmitScreenshot() is called.
+        *  If Steam is not running, the paths will be in the user's
+        *  documents folder under Documents\SteamVR\Screenshots.
+        *  Other VR applications can call this to initiate a
+        *  screenshot outside of user control.
+        *  The destination file names do not need an extension,
+        *  will be replaced with the correct one for the format
+        *  which is currently .png. */
+       virtual vr::EVRScreenshotError RequestScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, vr::EVRScreenshotType type, const char *pchPreviewFilename, const char *pchVRFilename ) = 0;
+
+       /** Called by the running VR application to indicate that it
+        *  wishes to be in charge of screenshots.  If the
+        *  application does not call this, the Compositor will only
+        *  support VRScreenshotType_Stereo screenshots that will be
+        *  captured without notification to the running app.
+        *  Once hooked your application will receive a
+        *  VREvent_RequestScreenshot event when the user presses the
+        *  buttons to take a screenshot. */
+       virtual vr::EVRScreenshotError HookScreenshot( VR_ARRAY_COUNT( numTypes ) const vr::EVRScreenshotType *pSupportedTypes, int numTypes ) = 0;
+
+       /** When your application receives a
+        *  VREvent_RequestScreenshot event, call these functions to get
+        *  the details of the screenshot request. */
+       virtual vr::EVRScreenshotType GetScreenshotPropertyType( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotError *pError ) = 0;
+
+       /** Get the filename for the preview or vr image (see
+        *  vr::EScreenshotPropertyFilenames).  The return value is
+        *  the size of the string.   */
+        virtual uint32_t GetScreenshotPropertyFilename( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotPropertyFilenames filenameType, VR_OUT_STRING() char *pchFilename, uint32_t cchFilename, vr::EVRScreenshotError *pError ) = 0;
+
+       /** Call this if the application is taking the screen shot
+        *  will take more than a few ms processing. This will result
+        *  in an overlay being presented that shows a completion
+        *  bar. */
+       virtual vr::EVRScreenshotError UpdateScreenshotProgress( vr::ScreenshotHandle_t screenshotHandle, float flProgress ) = 0;
+
+       /** Tells the compositor to take an internal screenshot of
+        *  type VRScreenshotType_Stereo. It will take the current
+        *  submitted scene textures of the running application and
+        *  write them into the preview image and a side-by-side file
+        *  for the VR image.
+        *  This is similar to request screenshot, but doesn't ever
+        *  talk to the application, just takes the shot and submits. */
+       virtual vr::EVRScreenshotError TakeStereoScreenshot( vr::ScreenshotHandle_t *pOutScreenshotHandle, const char *pchPreviewFilename, const char *pchVRFilename ) = 0;
+
+       /** Submit the completed screenshot.  If Steam is running
+        *  this will call into the Steam client and upload the
+        *  screenshot to the screenshots section of the library for
+        *  the running application.  If Steam is not running, this
+        *  function will display a notification to the user that the
+        *  screenshot was taken. The paths should be full paths with
+        *  extensions.
+        *  File paths should be absolute including extensions.
+        *  screenshotHandle can be k_unScreenshotHandleInvalid if this
+        *  was a new shot taking by the app to be saved and not
+        *  initiated by a user (achievement earned or something) */
+       virtual vr::EVRScreenshotError SubmitScreenshot( vr::ScreenshotHandle_t screenshotHandle, vr::EVRScreenshotType type, const char *pchSourcePreviewFilename, const char *pchSourceVRFilename ) = 0;
+};
+
+static const char * const IVRScreenshots_Version = "IVRScreenshots_001";
+
+} // namespace vr
+
+
+
+// ivrresources.h
+namespace vr
+{
+
+class IVRResources
+{
+public:
+
+       // ------------------------------------
+       // Shared Resource Methods
+       // ------------------------------------
+
+       /** Loads the specified resource into the provided buffer if large enough.
+       * Returns the size in bytes of the buffer required to hold the specified resource. */
+       virtual uint32_t LoadSharedResource( const char *pchResourceName, char *pchBuffer, uint32_t unBufferLen ) = 0;
+
+       /** Provides the full path to the specified resource. Resource names can include named directories for
+       * drivers and other things, and this resolves all of those and returns the actual physical path. 
+       * pchResourceTypeDirectory is the subdirectory of resources to look in. */
+       virtual uint32_t GetResourceFullPath( const char *pchResourceName, const char *pchResourceTypeDirectory, char *pchPathBuffer, uint32_t unBufferLen ) = 0;
+};
+
+static const char * const IVRResources_Version = "IVRResources_001";
+
+
+}
+// ivrdrivermanager.h
+namespace vr
+{
+
+class IVRDriverManager
+{
+public:
+       virtual uint32_t GetDriverCount() const = 0;
+
+       /** Returns the length of the number of bytes necessary to hold this string including the trailing null. */
+       virtual uint32_t GetDriverName( vr::DriverId_t nDriver, VR_OUT_STRING() char *pchValue, uint32_t unBufferSize ) = 0;
+};
+
+static const char * const IVRDriverManager_Version = "IVRDriverManager_001";
+
+} // namespace vr
+
+
+// End
+
+#endif // _OPENVR_API
+
+
+namespace vr
+{
+       /** Finds the active installation of the VR API and initializes it. The provided path must be absolute
+       * or relative to the current working directory. These are the local install versions of the equivalent
+       * functions in steamvr.h and will work without a local Steam install.
+       *
+       * This path is to the "root" of the VR API install. That's the directory with
+       * the "drivers" directory and a platform (i.e. "win32") directory in it, not the directory with the DLL itself.
+       *
+       * pStartupInfo is reserved for future use.
+       */
+       inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo = nullptr );
+
+       /** unloads vrclient.dll. Any interface pointers from the interface are
+       * invalid after this point */
+       inline void VR_Shutdown();
+
+       /** Returns true if there is an HMD attached. This check is as lightweight as possible and
+       * can be called outside of VR_Init/VR_Shutdown. It should be used when an application wants
+       * to know if initializing VR is a possibility but isn't ready to take that step yet.
+       */
+       VR_INTERFACE bool VR_CALLTYPE VR_IsHmdPresent();
+
+       /** Returns true if the OpenVR runtime is installed. */
+       VR_INTERFACE bool VR_CALLTYPE VR_IsRuntimeInstalled();
+
+       /** Returns where the OpenVR runtime is installed. */
+       VR_INTERFACE const char *VR_CALLTYPE VR_RuntimePath();
+
+       /** Returns the name of the enum value for an EVRInitError. This function may be called outside of VR_Init()/VR_Shutdown(). */
+       VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsSymbol( EVRInitError error );
+
+       /** Returns an English string for an EVRInitError. Applications should call VR_GetVRInitErrorAsSymbol instead and
+       * use that as a key to look up their own localized error message. This function may be called outside of VR_Init()/VR_Shutdown(). */
+       VR_INTERFACE const char *VR_CALLTYPE VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+
+       /** Returns the interface of the specified version. This method must be called after VR_Init. The
+       * pointer returned is valid until VR_Shutdown is called.
+       */
+       VR_INTERFACE void *VR_CALLTYPE VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+
+       /** Returns whether the interface of the specified version exists.
+       */
+       VR_INTERFACE bool VR_CALLTYPE VR_IsInterfaceVersionValid( const char *pchInterfaceVersion );
+
+       /** Returns a token that represents whether the VR interface handles need to be reloaded */
+       VR_INTERFACE uint32_t VR_CALLTYPE VR_GetInitToken();
+
+       // These typedefs allow old enum names from SDK 0.9.11 to be used in applications.
+       // They will go away in the future.
+       typedef EVRInitError HmdError;
+       typedef EVREye Hmd_Eye;
+       typedef EColorSpace ColorSpace;
+       typedef ETrackingResult HmdTrackingResult;
+       typedef ETrackedDeviceClass TrackedDeviceClass;
+       typedef ETrackingUniverseOrigin TrackingUniverseOrigin;
+       typedef ETrackedDeviceProperty TrackedDeviceProperty;
+       typedef ETrackedPropertyError TrackedPropertyError;
+       typedef EVRSubmitFlags VRSubmitFlags_t;
+       typedef EVRState VRState_t;
+       typedef ECollisionBoundsStyle CollisionBoundsStyle_t;
+       typedef EVROverlayError VROverlayError;
+       typedef EVRFirmwareError VRFirmwareError;
+       typedef EVRCompositorError VRCompositorError;
+       typedef EVRScreenshotError VRScreenshotsError;
+
+       inline uint32_t &VRToken()
+       {
+              static uint32_t token;
+              return token;
+       }
+
+       class COpenVRContext
+       {
+       public:
+              COpenVRContext() { Clear(); }
+              void Clear();
+
+              inline void CheckClear()
+              {
+                     if ( VRToken() != VR_GetInitToken() )
+                     {
+                            Clear();
+                            VRToken() = VR_GetInitToken();
+                     }
+              }
+
+              IVRSystem *VRSystem()
+              {
+                     CheckClear();
+                     if ( m_pVRSystem == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRSystem = ( IVRSystem * )VR_GetGenericInterface( IVRSystem_Version, &eError );
+                     }
+                     return m_pVRSystem;
+              }
+              IVRChaperone *VRChaperone()
+              {
+                     CheckClear();
+                     if ( m_pVRChaperone == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRChaperone = ( IVRChaperone * )VR_GetGenericInterface( IVRChaperone_Version, &eError );
+                     }
+                     return m_pVRChaperone;
+              }
+
+              IVRChaperoneSetup *VRChaperoneSetup()
+              {
+                     CheckClear();
+                     if ( m_pVRChaperoneSetup == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRChaperoneSetup = ( IVRChaperoneSetup * )VR_GetGenericInterface( IVRChaperoneSetup_Version, &eError );
+                     }
+                     return m_pVRChaperoneSetup;
+              }
+
+              IVRCompositor *VRCompositor()
+              {
+                     CheckClear();
+                     if ( m_pVRCompositor == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRCompositor = ( IVRCompositor * )VR_GetGenericInterface( IVRCompositor_Version, &eError );
+                     }
+                     return m_pVRCompositor;
+              }
+
+              IVROverlay *VROverlay()
+              {
+                     CheckClear();
+                     if ( m_pVROverlay == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVROverlay = ( IVROverlay * )VR_GetGenericInterface( IVROverlay_Version, &eError );
+                     }
+                     return m_pVROverlay;
+              }
+
+              IVRResources *VRResources()
+              {
+                     CheckClear();
+                     if ( m_pVRResources == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRResources = (IVRResources *)VR_GetGenericInterface( IVRResources_Version, &eError );
+                     }
+                     return m_pVRResources;
+              }
+
+              IVRScreenshots *VRScreenshots()
+              {
+                     CheckClear();
+                     if ( m_pVRScreenshots == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRScreenshots = ( IVRScreenshots * )VR_GetGenericInterface( IVRScreenshots_Version, &eError );
+                     }
+                     return m_pVRScreenshots;
+              }
+
+              IVRRenderModels *VRRenderModels()
+              {
+                     CheckClear();
+                     if ( m_pVRRenderModels == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRRenderModels = ( IVRRenderModels * )VR_GetGenericInterface( IVRRenderModels_Version, &eError );
+                     }
+                     return m_pVRRenderModels;
+              }
+
+              IVRExtendedDisplay *VRExtendedDisplay()
+              {
+                     CheckClear();
+                     if ( m_pVRExtendedDisplay == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRExtendedDisplay = ( IVRExtendedDisplay * )VR_GetGenericInterface( IVRExtendedDisplay_Version, &eError );
+                     }
+                     return m_pVRExtendedDisplay;
+              }
+
+              IVRSettings *VRSettings()
+              {
+                     CheckClear();
+                     if ( m_pVRSettings == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRSettings = ( IVRSettings * )VR_GetGenericInterface( IVRSettings_Version, &eError );
+                     }
+                     return m_pVRSettings;
+              }
+
+              IVRApplications *VRApplications()
+              {
+                     CheckClear();
+                     if ( m_pVRApplications == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRApplications = ( IVRApplications * )VR_GetGenericInterface( IVRApplications_Version, &eError );
+                     }
+                     return m_pVRApplications;
+              }
+
+              IVRTrackedCamera *VRTrackedCamera()
+              {
+                     CheckClear();
+                     if ( m_pVRTrackedCamera == nullptr )
+                     {
+                            EVRInitError eError;
+                            m_pVRTrackedCamera = ( IVRTrackedCamera * )VR_GetGenericInterface( IVRTrackedCamera_Version, &eError );
+                     }
+                     return m_pVRTrackedCamera;
+              }
+
+              IVRDriverManager *VRDriverManager()
+              {
+                     CheckClear();
+                     if ( !m_pVRDriverManager )
+                     {
+                            EVRInitError eError;
+                            m_pVRDriverManager = ( IVRDriverManager * )VR_GetGenericInterface( IVRDriverManager_Version, &eError );
+                     }
+                     return m_pVRDriverManager;
+              }
+
+       private:
+              IVRSystem                     *m_pVRSystem;
+              IVRChaperone              *m_pVRChaperone;
+              IVRChaperoneSetup       *m_pVRChaperoneSetup;
+              IVRCompositor              *m_pVRCompositor;
+              IVROverlay                     *m_pVROverlay;
+              IVRResources              *m_pVRResources;
+              IVRRenderModels              *m_pVRRenderModels;
+              IVRExtendedDisplay       *m_pVRExtendedDisplay;
+              IVRSettings                     *m_pVRSettings;
+              IVRApplications              *m_pVRApplications;
+              IVRTrackedCamera       *m_pVRTrackedCamera;
+              IVRScreenshots              *m_pVRScreenshots;
+              IVRDriverManager       *m_pVRDriverManager;
+       };
+
+       inline COpenVRContext &OpenVRInternal_ModuleContext()
+       {
+              static void *ctx[ sizeof( COpenVRContext ) / sizeof( void * ) ];
+              return *( COpenVRContext * )ctx; // bypass zero-init constructor
+       }
+
+       inline IVRSystem *VR_CALLTYPE VRSystem() { return OpenVRInternal_ModuleContext().VRSystem(); }
+       inline IVRChaperone *VR_CALLTYPE VRChaperone() { return OpenVRInternal_ModuleContext().VRChaperone(); }
+       inline IVRChaperoneSetup *VR_CALLTYPE VRChaperoneSetup() { return OpenVRInternal_ModuleContext().VRChaperoneSetup(); }
+       inline IVRCompositor *VR_CALLTYPE VRCompositor() { return OpenVRInternal_ModuleContext().VRCompositor(); }
+       inline IVROverlay *VR_CALLTYPE VROverlay() { return OpenVRInternal_ModuleContext().VROverlay(); }
+       inline IVRScreenshots *VR_CALLTYPE VRScreenshots() { return OpenVRInternal_ModuleContext().VRScreenshots(); }
+       inline IVRRenderModels *VR_CALLTYPE VRRenderModels() { return OpenVRInternal_ModuleContext().VRRenderModels(); }
+       inline IVRApplications *VR_CALLTYPE VRApplications() { return OpenVRInternal_ModuleContext().VRApplications(); }
+       inline IVRSettings *VR_CALLTYPE VRSettings() { return OpenVRInternal_ModuleContext().VRSettings(); }
+       inline IVRResources *VR_CALLTYPE VRResources() { return OpenVRInternal_ModuleContext().VRResources(); }
+       inline IVRExtendedDisplay *VR_CALLTYPE VRExtendedDisplay() { return OpenVRInternal_ModuleContext().VRExtendedDisplay(); }
+       inline IVRTrackedCamera *VR_CALLTYPE VRTrackedCamera() { return OpenVRInternal_ModuleContext().VRTrackedCamera(); }
+       inline IVRDriverManager *VR_CALLTYPE VRDriverManager() { return OpenVRInternal_ModuleContext().VRDriverManager(); }
+
+       inline void COpenVRContext::Clear()
+       {
+              m_pVRSystem = nullptr;
+              m_pVRChaperone = nullptr;
+              m_pVRChaperoneSetup = nullptr;
+              m_pVRCompositor = nullptr;
+              m_pVROverlay = nullptr;
+              m_pVRRenderModels = nullptr;
+              m_pVRExtendedDisplay = nullptr;
+              m_pVRSettings = nullptr;
+              m_pVRApplications = nullptr;
+              m_pVRTrackedCamera = nullptr;
+              m_pVRResources = nullptr;
+              m_pVRScreenshots = nullptr;
+              m_pVRDriverManager = nullptr;
+       }
+       
+       VR_INTERFACE uint32_t VR_CALLTYPE VR_InitInternal2( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo );
+       VR_INTERFACE void VR_CALLTYPE VR_ShutdownInternal();
+
+       /** Finds the active installation of vrclient.dll and initializes it */
+       inline IVRSystem *VR_Init( EVRInitError *peError, EVRApplicationType eApplicationType, const char *pStartupInfo )
+       {
+              IVRSystem *pVRSystem = nullptr;
+
+              EVRInitError eError;
+              VRToken() = VR_InitInternal2( &eError, eApplicationType, pStartupInfo );
+              COpenVRContext &ctx = OpenVRInternal_ModuleContext();
+              ctx.Clear();
+
+              if ( eError == VRInitError_None )
+              {
+                     if ( VR_IsInterfaceVersionValid( IVRSystem_Version ) )
+                     {
+                            pVRSystem = VRSystem();
+                     }
+                     else
+                     {
+                            VR_ShutdownInternal();
+                            eError = VRInitError_Init_InterfaceNotFound;
+                     }
+              }
+
+              if ( peError )
+                     *peError = eError;
+              return pVRSystem;
+       }
+
+       /** unloads vrclient.dll. Any interface pointers from the interface are
+       * invalid after this point */
+       inline void VR_Shutdown()
+       {
+              VR_ShutdownInternal();
+       }
+}
diff --git a/Source/ThirdParty/openvr/headers/openvr_api.cs b/Source/ThirdParty/openvr/headers/openvr_api.cs
new file mode 100644 (file)
index 0000000..5585af4
--- /dev/null
@@ -0,0 +1,4786 @@
+//======= 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 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 _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, char 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 _CaptureInputFocus();
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _CaptureInputFocus CaptureInputFocus;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate void _ReleaseInputFocus();
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _ReleaseInputFocus ReleaseInputFocus;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate bool _IsInputFocusCapturedByAnotherProcess();
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _IsInputFocusCapturedByAnotherProcess IsInputFocusCapturedByAnotherProcess;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate uint _DriverDebugRequest(uint unDeviceIndex, string pchRequest, string pchResponseBuffer, uint unResponseBufferSize);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _DriverDebugRequest DriverDebugRequest;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate EVRFirmwareError _PerformFirmwareUpdate(uint unDeviceIndex);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _PerformFirmwareUpdate PerformFirmwareUpdate;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate void _AcknowledgeQuit_Exiting();
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _AcknowledgeQuit_Exiting AcknowledgeQuit_Exiting;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate void _AcknowledgeQuit_UserPrompt();
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _AcknowledgeQuit_UserPrompt AcknowledgeQuit_UserPrompt;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRExtendedDisplay
+{
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate void _GetWindowBounds(ref int pnX, ref int pnY, ref uint pnWidth, ref uint pnHeight);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetWindowBounds GetWindowBounds;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate void _GetEyeOutputViewport(EVREye eEye, ref uint pnX, ref uint pnY, ref uint pnWidth, ref uint pnHeight);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetEyeOutputViewport GetEyeOutputViewport;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate void _GetDXGIOutputInfo(ref int pnAdapterIndex, ref int pnAdapterOutputIndex);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetDXGIOutputInfo GetDXGIOutputInfo;
+
+}
+
+[StructLayout(LayoutKind.Sequential)]
+public struct IVRTrackedCamera
+{
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate IntPtr _GetCameraErrorNameFromEnum(EVRTrackedCameraError eCameraError);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetCameraErrorNameFromEnum GetCameraErrorNameFromEnum;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate EVRTrackedCameraError _HasCamera(uint nDeviceIndex, ref bool pHasCamera);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _HasCamera HasCamera;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate EVRTrackedCameraError _GetCameraFrameSize(uint nDeviceIndex, EVRTrackedCameraFrameType eFrameType, ref uint pnWidth, ref uint pnHeight, ref uint pnFrameBufferSize);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetCameraFrameSize GetCameraFrameSize;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate EVRTrackedCameraError _GetCameraIntrinsics(uint nDeviceIndex, 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, 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, string 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, string pchAppKeyBuffer, uint unAppKeyBufferLen);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetDefaultApplicationForMimeType GetDefaultApplicationForMimeType;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate bool _GetApplicationSupportedMimeTypes(string pchAppKey, string pchMimeTypesBuffer, uint unMimeTypesBuffer);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetApplicationSupportedMimeTypes GetApplicationSupportedMimeTypes;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate uint _GetApplicationsThatSupportMimeType(string pchMimeType, string pchAppKeysThatSupportBuffer, uint unAppKeysThatSupportBuffer);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetApplicationsThatSupportMimeType GetApplicationsThatSupportMimeType;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate uint _GetApplicationLaunchArguments(uint unHandle, string pchArgs, uint unArgs);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetApplicationLaunchArguments GetApplicationLaunchArguments;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate EVRApplicationError _GetStartingApplication(string 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 _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 void _SetWorkingCollisionBoundsTagsInfo([In, Out] byte[] pTagsBuffer, uint unTagCount);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _SetWorkingCollisionBoundsTagsInfo SetWorkingCollisionBoundsTagsInfo;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate bool _GetLiveCollisionBoundsTagsInfo([In, Out] byte[] pTagsBuffer, ref uint punTagCount);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetLiveCollisionBoundsTagsInfo GetLiveCollisionBoundsTagsInfo;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate bool _SetWorkingPhysicalBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, uint unQuadsCount);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _SetWorkingPhysicalBoundsInfo SetWorkingPhysicalBoundsInfo;
+
+       [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+       internal delegate bool _GetLivePhysicalBoundsInfo([In, Out] HmdQuad_t[] pQuadsBuffer, ref uint punQuadsCount);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetLivePhysicalBoundsInfo GetLivePhysicalBoundsInfo;
+
+       [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;
+
+}
+
+[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(ref 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;
+
+}
+
+[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 pchOverlayFriendlyName, 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 _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 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, string pchComponentName, uint unComponentNameSize);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetOverlayTransformTrackedDeviceComponent GetOverlayTransformTrackedDeviceComponent;
+
+       [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 _HandleControllerOverlayInteractionAsMouse(ulong ulOverlayHandle, uint unControllerDeviceIndex);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _HandleControllerOverlayInteractionAsMouse HandleControllerOverlayInteractionAsMouse;
+
+       [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 _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;
+
+}
+
+[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 _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, string pchPathBuffer, uint unBufferLen);
+       [MarshalAs(UnmanagedType.FunctionPtr)]
+       internal _GetResourceFullPath GetResourceFullPath;
+
+}
+
+
+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 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 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);
+       }
+       public bool PollNextEvent(ref VREvent_t pEvent,uint uncbVREvent)
+       {
+              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 was
+// 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 ((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();
+                     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;
+              }
+              bool result = FnTable.GetControllerState(unControllerDeviceIndex,ref pControllerState,unControllerStateSize);
+              return result;
+       }
+// This is a terrible hack to workaround the fact that VRControllerState_t was
+// 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 ((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();
+                     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;
+              }
+              bool result = FnTable.GetControllerStateWithPose(eOrigin,unControllerDeviceIndex,ref pControllerState,unControllerStateSize,ref pTrackedDevicePose);
+              return result;
+       }
+       public void TriggerHapticPulse(uint unControllerDeviceIndex,uint unAxisId,char 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 CaptureInputFocus()
+       {
+              bool result = FnTable.CaptureInputFocus();
+              return result;
+       }
+       public void ReleaseInputFocus()
+       {
+              FnTable.ReleaseInputFocus();
+       }
+       public bool IsInputFocusCapturedByAnotherProcess()
+       {
+              bool result = FnTable.IsInputFocusCapturedByAnotherProcess();
+              return result;
+       }
+       public uint DriverDebugRequest(uint unDeviceIndex,string pchRequest,string pchResponseBuffer,uint unResponseBufferSize)
+       {
+              uint result = FnTable.DriverDebugRequest(unDeviceIndex,pchRequest,pchResponseBuffer,unResponseBufferSize);
+              return result;
+       }
+       public EVRFirmwareError PerformFirmwareUpdate(uint unDeviceIndex)
+       {
+              EVRFirmwareError result = FnTable.PerformFirmwareUpdate(unDeviceIndex);
+              return result;
+       }
+       public void AcknowledgeQuit_Exiting()
+       {
+              FnTable.AcknowledgeQuit_Exiting();
+       }
+       public void AcknowledgeQuit_UserPrompt()
+       {
+              FnTable.AcknowledgeQuit_UserPrompt();
+       }
+}
+
+
+public class CVRExtendedDisplay
+{
+       IVRExtendedDisplay FnTable;
+       internal CVRExtendedDisplay(IntPtr pInterface)
+       {
+              FnTable = (IVRExtendedDisplay)Marshal.PtrToStructure(pInterface, typeof(IVRExtendedDisplay));
+       }
+       public void GetWindowBounds(ref int pnX,ref int pnY,ref uint pnWidth,ref uint pnHeight)
+       {
+              pnX = 0;
+              pnY = 0;
+              pnWidth = 0;
+              pnHeight = 0;
+              FnTable.GetWindowBounds(ref pnX,ref pnY,ref pnWidth,ref pnHeight);
+       }
+       public void GetEyeOutputViewport(EVREye eEye,ref uint pnX,ref uint pnY,ref uint pnWidth,ref uint pnHeight)
+       {
+              pnX = 0;
+              pnY = 0;
+              pnWidth = 0;
+              pnHeight = 0;
+              FnTable.GetEyeOutputViewport(eEye,ref pnX,ref pnY,ref pnWidth,ref pnHeight);
+       }
+       public void GetDXGIOutputInfo(ref int pnAdapterIndex,ref int pnAdapterOutputIndex)
+       {
+              pnAdapterIndex = 0;
+              pnAdapterOutputIndex = 0;
+              FnTable.GetDXGIOutputInfo(ref pnAdapterIndex,ref pnAdapterOutputIndex);
+       }
+}
+
+
+public class CVRTrackedCamera
+{
+       IVRTrackedCamera FnTable;
+       internal CVRTrackedCamera(IntPtr pInterface)
+       {
+              FnTable = (IVRTrackedCamera)Marshal.PtrToStructure(pInterface, typeof(IVRTrackedCamera));
+       }
+       public string GetCameraErrorNameFromEnum(EVRTrackedCameraError eCameraError)
+       {
+              IntPtr result = FnTable.GetCameraErrorNameFromEnum(eCameraError);
+              return Marshal.PtrToStringAnsi(result);
+       }
+       public EVRTrackedCameraError HasCamera(uint nDeviceIndex,ref bool pHasCamera)
+       {
+              pHasCamera = false;
+              EVRTrackedCameraError result = FnTable.HasCamera(nDeviceIndex,ref pHasCamera);
+              return result;
+       }
+       public EVRTrackedCameraError GetCameraFrameSize(uint nDeviceIndex,EVRTrackedCameraFrameType eFrameType,ref uint pnWidth,ref uint pnHeight,ref uint pnFrameBufferSize)
+       {
+              pnWidth = 0;
+              pnHeight = 0;
+              pnFrameBufferSize = 0;
+              EVRTrackedCameraError result = FnTable.GetCameraFrameSize(nDeviceIndex,eFrameType,ref pnWidth,ref pnHeight,ref pnFrameBufferSize);
+              return result;
+       }
+       public EVRTrackedCameraError GetCameraIntrinsics(uint nDeviceIndex,EVRTrackedCameraFrameType eFrameType,ref HmdVector2_t pFocalLength,ref HmdVector2_t pCenter)
+       {
+              EVRTrackedCameraError result = FnTable.GetCameraIntrinsics(nDeviceIndex,eFrameType,ref pFocalLength,ref pCenter);
+              return result;
+       }
+       public EVRTrackedCameraError GetCameraProjection(uint nDeviceIndex,EVRTrackedCameraFrameType eFrameType,float flZNear,float flZFar,ref HmdMatrix44_t pProjection)
+       {
+              EVRTrackedCameraError result = FnTable.GetCameraProjection(nDeviceIndex,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,string 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,string pchAppKeyBuffer,uint unAppKeyBufferLen)
+       {
+              bool result = FnTable.GetDefaultApplicationForMimeType(pchMimeType,pchAppKeyBuffer,unAppKeyBufferLen);
+              return result;
+       }
+       public bool GetApplicationSupportedMimeTypes(string pchAppKey,string pchMimeTypesBuffer,uint unMimeTypesBuffer)
+       {
+              bool result = FnTable.GetApplicationSupportedMimeTypes(pchAppKey,pchMimeTypesBuffer,unMimeTypesBuffer);
+              return result;
+       }
+       public uint GetApplicationsThatSupportMimeType(string pchMimeType,string pchAppKeysThatSupportBuffer,uint unAppKeysThatSupportBuffer)
+       {
+              uint result = FnTable.GetApplicationsThatSupportMimeType(pchMimeType,pchAppKeysThatSupportBuffer,unAppKeysThatSupportBuffer);
+              return result;
+       }
+       public uint GetApplicationLaunchArguments(uint unHandle,string pchArgs,uint unArgs)
+       {
+              uint result = FnTable.GetApplicationLaunchArguments(unHandle,pchArgs,unArgs);
+              return result;
+       }
+       public EVRApplicationError GetStartingApplication(string 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 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 void SetWorkingCollisionBoundsTagsInfo(byte [] pTagsBuffer)
+       {
+              FnTable.SetWorkingCollisionBoundsTagsInfo(pTagsBuffer,(uint) pTagsBuffer.Length);
+       }
+       public bool GetLiveCollisionBoundsTagsInfo(out byte [] pTagsBuffer)
+       {
+              uint punTagCount = 0;
+              bool result = FnTable.GetLiveCollisionBoundsTagsInfo(null,ref punTagCount);
+              pTagsBuffer= new byte[punTagCount];
+              result = FnTable.GetLiveCollisionBoundsTagsInfo(pTagsBuffer,ref punTagCount);
+              return result;
+       }
+       public bool SetWorkingPhysicalBoundsInfo(HmdQuad_t [] pQuadsBuffer)
+       {
+              bool result = FnTable.SetWorkingPhysicalBoundsInfo(pQuadsBuffer,(uint) pQuadsBuffer.Length);
+              return result;
+       }
+       public bool GetLivePhysicalBoundsInfo(out HmdQuad_t [] pQuadsBuffer)
+       {
+              uint punQuadsCount = 0;
+              bool result = FnTable.GetLivePhysicalBoundsInfo(null,ref punQuadsCount);
+              pQuadsBuffer= new HmdQuad_t[punQuadsCount];
+              result = FnTable.GetLivePhysicalBoundsInfo(pQuadsBuffer,ref punQuadsCount);
+              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 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(ref Compositor_FrameTiming pTiming,uint nFrames)
+       {
+              uint result = FnTable.GetFrameTimings(ref pTiming,nFrames);
+              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 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 pchOverlayFriendlyName,ref ulong pOverlayHandle)
+       {
+              pOverlayHandle = 0;
+              EVROverlayError result = FnTable.CreateOverlay(pchOverlayKey,pchOverlayFriendlyName,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 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 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)
+       {</