Added an OpenVR video driver (thanks @cnlohr!)

CMakeLists.txt

@@ -337,6 +337,7 @@ dep_option(SDL_VIVANTE             "Use Vivante EGL video driver" ON "${UNIX_SYS
 dep_option(SDL_VULKAN              "Enable Vulkan support" ON "SDL_VIDEO;ANDROID OR APPLE OR LINUX OR FREEBSD OR WINDOWS" OFF)
 dep_option(SDL_RENDER_VULKAN       "Enable the Vulkan render driver" ON "SDL_RENDER;SDL_VULKAN" OFF)
 dep_option(SDL_METAL               "Enable Metal support" ON "APPLE" OFF)
+set_option(SDL_OPENVR              "Use OpenVR video driver" OFF)
 dep_option(SDL_KMSDRM              "Use KMS DRM video driver" ${UNIX_SYS} "SDL_VIDEO" OFF)
 dep_option(SDL_KMSDRM_SHARED       "Dynamically load KMS DRM support" ON "SDL_KMSDRM" OFF)
 set_option(SDL_OFFSCREEN           "Use offscreen video driver" ON)
@@ -1544,6 +1545,7 @@ elseif(UNIX AND NOT APPLE AND NOT RISCOS AND NOT HAIKU)
     CheckOpenGL()
     CheckOpenGLES()
     CheckWayland()
+    CheckOpenVR()
     CheckVivante()
     CheckVulkan()
     CheckQNXScreen()

cmake/sdlchecks.cmake

@@ -662,6 +662,19 @@ macro(CheckVivante)
   endif()
 endmacro()
 
+# Requires:
+# - n/a
+macro(CheckOpenVR)
+  if(SDL_OPENVR)
+    set(HAVE_OPENVR TRUE)
+    set(HAVE_OPENVR_VIDEO TRUE)
+
+    sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/openvr/*.c")
+    set(SDL_VIDEO_DRIVER_OPENVR 1)
+    sdl_link_dependency(egl LIBS EGL)
+  endif()
+endmacro()
+
 # Requires:
 # - nada
 macro(CheckGLX)

include/SDL3/SDL_hints.h

@@ -2629,6 +2629,17 @@ extern "C" {
  */
 #define SDL_HINT_OPENGL_ES_DRIVER "SDL_OPENGL_ES_DRIVER"
 
+/**
+ *  Mechanism to specify openvr_api library location
+ *
+ *  By default, when using the OpenVR driver, it will search for the API
+ *  library in the current folder.  But, if you wish to use a system API
+ *  you can specify that by using this hint.  This should be the full or
+ *  relative path to a .dll on Windows or .so on Linux.
+ *
+ */
+#define SDL_HINT_OPENVR_LIBRARY              "SDL_OPENVR_LIBRARY"
+
 /**
  * A variable controlling which orientations are allowed on iOS/Android.
  *

include/SDL3/SDL_video.h

@@ -1282,6 +1282,11 @@ extern SDL_DECLSPEC SDL_Window * SDLCALL SDL_GetWindowParent(SDL_Window *window)
  * - `SDL_PROP_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER`: the NSInteger tag
  *   assocated with metal views on the window
  *
+ * On OpenVR:
+ *
+ * - `SDL_PROP_WINDOW_OPENVR_OVERLAY_ID`: the OpenVR Overlay Handle ID for
+ *   the associated overlay window.
+ *
  * On Vivante:
  *
  * - `SDL_PROP_WINDOW_VIVANTE_DISPLAY_POINTER`: the EGLNativeDisplayType
@@ -1354,6 +1359,7 @@ extern SDL_DECLSPEC SDL_PropertiesID SDLCALL SDL_GetWindowProperties(SDL_Window
 #define SDL_PROP_WINDOW_KMSDRM_GBM_DEVICE_POINTER                   "SDL.window.kmsdrm.gbm_dev"
 #define SDL_PROP_WINDOW_COCOA_WINDOW_POINTER                        "SDL.window.cocoa.window"
 #define SDL_PROP_WINDOW_COCOA_METAL_VIEW_TAG_NUMBER                 "SDL.window.cocoa.metal_view_tag"
+#define SDL_PROP_WINDOW_OPENVR_OVERLAY_ID                           "SDL.window.openvr.overlay_id"
 #define SDL_PROP_WINDOW_VIVANTE_DISPLAY_POINTER                     "SDL.window.vivante.display"
 #define SDL_PROP_WINDOW_VIVANTE_WINDOW_POINTER                      "SDL.window.vivante.window"
 #define SDL_PROP_WINDOW_VIVANTE_SURFACE_POINTER                     "SDL.window.vivante.surface"

include/build_config/SDL_build_config.h.cmake

@@ -397,6 +397,7 @@
 #cmakedefine SDL_VIDEO_DRIVER_VITA @SDL_VIDEO_DRIVER_VITA@
 #cmakedefine SDL_VIDEO_DRIVER_VIVANTE @SDL_VIDEO_DRIVER_VIVANTE@
 #cmakedefine SDL_VIDEO_DRIVER_VIVANTE_VDK @SDL_VIDEO_DRIVER_VIVANTE_VDK@
+#cmakedefine SDL_VIDEO_DRIVER_OPENVR @SDL_VIDEO_DRIVER_OPENVR@
 #cmakedefine SDL_VIDEO_DRIVER_WAYLAND @SDL_VIDEO_DRIVER_WAYLAND@
 #cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC@
 #cmakedefine SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR @SDL_VIDEO_DRIVER_WAYLAND_DYNAMIC_CURSOR@

src/video/SDL_sysvideo.h

@@ -521,6 +521,7 @@ extern VideoBootStrap Emscripten_bootstrap;
 extern VideoBootStrap OFFSCREEN_bootstrap;
 extern VideoBootStrap NGAGE_bootstrap;
 extern VideoBootStrap QNX_bootstrap;
+extern VideoBootStrap OPENVR_bootstrap;
 
 // Use SDL_OnVideoThread() sparingly, to avoid regressions in use cases that currently happen to work
 extern bool SDL_OnVideoThread(void);

src/video/SDL_video.c

@@ -139,6 +139,9 @@ static VideoBootStrap *bootstrap[] = {
 #ifdef SDL_INPUT_LINUXEV
     &DUMMY_evdev_bootstrap,
 #endif
+#endif
+#ifdef SDL_VIDEO_DRIVER_OPENVR
+    &OPENVR_bootstrap,
 #endif
     NULL
 };
@@ -2339,6 +2342,10 @@ SDL_Window *SDL_CreateWindowWithProperties(SDL_PropertiesID props)
         flags |= SDL_DefaultGraphicsBackends(_this);
     }
 
+#if defined(SDL_VIDEO_OPENGL) && defined(SDL_VIDEO_DRIVER_OPENVR)
+    flags |= SDL_WINDOW_OPENGL;
+#endif
+
     if (flags & SDL_WINDOW_OPENGL) {
         if (!_this->GL_CreateContext) {
             SDL_ContextNotSupported("OpenGL");

src/video/openvr/SDL_openvrvideo.c

@@ -0,0 +1,1728 @@
+/*
+  Simple DirectMedia Layer
+  Copyright (C) 2022 Charles Lohr <charlesl@valvesoftware.com>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+*/
+#include "SDL_internal.h"
+
+#ifdef SDL_VIDEO_DRIVER_OPENVR
+
+#define DEBUG_OPENVR
+
+#include "../../events/SDL_mouse_c.h"
+#include "../../events/SDL_keyboard_c.h"
+#include "../../events/SDL_events_c.h"
+#include "../SDL_sysvideo.h"
+#include "../SDL_pixels_c.h"
+#include "../SDL_egl_c.h"
+#include "SDL_openvrvideo.h"
+
+#include <SDL3/SDL_opengl.h>
+
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+#include "../windows/SDL_windowsopengles.h"
+#include "../windows/SDL_windowsopengl.h"
+#include "../windows/SDL_windowsvulkan.h"
+#define DEFAULT_OPENGL "OPENGL32.DLL"
+static bool OPENVR_GL_LoadLibrary(SDL_VideoDevice *_this, const char *path);
+static SDL_GLContext OPENVR_GL_CreateContext(SDL_VideoDevice *_this, SDL_Window *window);
+
+struct SDL_GLContextState
+{
+    HGLRC hglrc;
+};
+#else
+#include <SDL3/SDL_opengles2_gl2.h>
+#endif
+
+#define MARKER_ID 0
+#define MARKER_STR "vr-marker,frame_end,type,application"
+
+#undef EXTERN_C
+
+// For access to functions that don't get the video data context.
+SDL_VideoData * global_openvr_driver;
+
+static void InitializeMouseFunctions();
+
+struct SDL_CursorData
+{
+    unsigned texture_id_handle;
+    int hot_x, hot_y;
+    int w, h;
+};
+
+// GL Extensions for functions we will be using.
+void (*ov_glGenFramebuffers)(GLsizei n, GLuint *framebuffers);
+void (*ov_glGenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
+void (*ov_glBindFramebuffer)(GLenum target, GLuint framebuffer);
+void (*ov_glBindRenderbuffer)(GLenum target, GLuint renderbuffer);
+void (*ov_glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
+void (*ov_glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
+void (*ov_glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
+GLenum (*ov_glCheckNamedFramebufferStatus)(GLuint framebuffer, GLenum target);
+GLenum (*ov_glGetError)();
+void (*ov_glFlush)();
+void (*ov_glFinish)();
+void (*ov_glGenTextures)(GLsizei n, GLuint *textures);
+void (*ov_glDeleteTextures)(GLsizei n, GLuint *textures);
+void (*ov_glTexParameterf)(GLenum target, GLenum pname, GLfloat param);
+void (*ov_glTexParameteri)(GLenum target, GLenum pname, GLenum param);
+void (*ov_glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *data);
+void (*ov_glBindTexture)(GLenum target, GLuint texture);
+void (*ov_glDrawBuffers)(GLsizei n, const GLenum *bufs);
+void (*ov_glGetIntegerv)(GLenum pname, GLint * data);
+const GLubyte *(*ov_glGetStringi)(GLenum name, GLuint index);
+void (*ov_glClear)(GLbitfield mask);
+void (*ov_glClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
+void (*ov_glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
+void (*ov_glDebugMessageInsert)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const char *message);
+
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+PROC(*ov_wglGetProcAddress)(LPCSTR);
+HGLRC(*ov_wglCreateContext)(HDC);
+BOOL(*ov_wglDeleteContext)(HGLRC);
+BOOL(*ov_wglMakeCurrent)(HDC, HGLRC);
+HGLRC(*ov_wglGetCurrentContext)();
+#endif
+
+
+#define OPENVR_DEFAULT_WIDTH 1920
+#define OPENVR_DEFAULT_HEIGHT 1080
+
+SDL_DisplayMode openvr_dm_default = {
+    .format = SDL_PIXELFORMAT_RGBA32,
+    .w = OPENVR_DEFAULT_WIDTH,
+    .h = OPENVR_DEFAULT_HEIGHT,
+    .refresh_rate = 120,
+    .internal = 0
+};
+
+SDL_VideoDisplay openvr_vd_default = {
+    .name = 0,
+    .max_fullscreen_modes = 0,
+    .num_fullscreen_modes = 0,
+    .fullscreen_modes = 0,
+    .desktop_mode = {
+        .format = SDL_PIXELFORMAT_RGBA32,
+        .w = OPENVR_DEFAULT_WIDTH,
+        .h = OPENVR_DEFAULT_HEIGHT,
+        .refresh_rate = 120,
+        .internal = 0
+    },
+    .current_mode = 0,
+    .natural_orientation = SDL_ORIENTATION_LANDSCAPE,
+    .current_orientation = SDL_ORIENTATION_LANDSCAPE,
+    .fullscreen_window = 0,
+    .device = 0,
+    .content_scale = 1.0f,
+    .internal = 0
+};
+
+#define OPENVR_SetupProc(proc) { proc = (void*)SDL_GL_GetProcAddress((#proc)+3); if (!proc) { failed_extension = (#proc)+3; } }
+
+static bool OPENVR_InitExtensions(SDL_VideoDevice *_this)
+{
+    if (!ov_glGetError) {
+        const char * failed_extension = 0;
+        OPENVR_SetupProc(ov_glGenFramebuffers);
+        OPENVR_SetupProc(ov_glGenRenderbuffers);
+        OPENVR_SetupProc(ov_glBindFramebuffer);
+        OPENVR_SetupProc(ov_glBindRenderbuffer);
+        OPENVR_SetupProc(ov_glRenderbufferStorage);
+        OPENVR_SetupProc(ov_glFramebufferRenderbuffer);
+        OPENVR_SetupProc(ov_glFramebufferTexture2D);
+        OPENVR_SetupProc(ov_glCheckNamedFramebufferStatus);
+        OPENVR_SetupProc(ov_glGetError);
+        OPENVR_SetupProc(ov_glFlush);
+        OPENVR_SetupProc(ov_glFinish);
+        OPENVR_SetupProc(ov_glGenTextures);
+        OPENVR_SetupProc(ov_glDeleteTextures);
+        OPENVR_SetupProc(ov_glTexParameterf);
+        OPENVR_SetupProc(ov_glTexParameteri);
+        OPENVR_SetupProc(ov_glTexImage2D);
+        OPENVR_SetupProc(ov_glBindTexture);
+        OPENVR_SetupProc(ov_glDrawBuffers);
+        OPENVR_SetupProc(ov_glClear);
+        OPENVR_SetupProc(ov_glClearColor);
+        OPENVR_SetupProc(ov_glColorMask);
+        OPENVR_SetupProc(ov_glGetStringi);
+        OPENVR_SetupProc(ov_glGetIntegerv);
+        OPENVR_SetupProc(ov_glDebugMessageInsert);
+        if (failed_extension) {
+            return SDL_SetError("Error loading GL extension for %s", failed_extension);
+        }
+    }
+    return true;
+}
+
+static bool OPENVR_SetOverlayError(EVROverlayError e)
+{
+    switch (e) {
+#define CASE(X) case EVROverlayError_VROverlayError_##X: return SDL_SetError("VROverlayError %s", #X)
+    CASE(UnknownOverlay);
+    CASE(InvalidHandle);
+    CASE(PermissionDenied);
+    CASE(OverlayLimitExceeded);
+    CASE(WrongVisibilityType);
+    CASE(KeyTooLong);
+    CASE(NameTooLong);
+    CASE(KeyInUse);
+    CASE(WrongTransformType);
+    CASE(InvalidTrackedDevice);
+    CASE(InvalidParameter);
+    CASE(ThumbnailCantBeDestroyed);
+    CASE(ArrayTooSmall);
+    CASE(RequestFailed);
+    CASE(InvalidTexture);
+    CASE(UnableToLoadFile);
+    CASE(KeyboardAlreadyInUse);
+    CASE(NoNeighbor);
+    CASE(TooManyMaskPrimitives);
+    CASE(BadMaskPrimitive);
+    CASE(TextureAlreadyLocked);
+    CASE(TextureLockCapacityReached);
+    CASE(TextureNotLocked);
+    CASE(TimedOut);
+#undef CASE
+    default:
+        return SDL_SetError("Unknown VROverlayError %d", e);
+    }
+}
+
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+
+#define STYLE_BASIC         (WS_CLIPSIBLINGS | WS_CLIPCHILDREN)
+#define STYLE_FULLSCREEN    (WS_POPUP | WS_MINIMIZEBOX)
+#define STYLE_BORDERLESS    (WS_POPUP | WS_MINIMIZEBOX)
+#define STYLE_BORDERLESS_WINDOWED (WS_POPUP | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX)
+#define STYLE_NORMAL        (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX)
+#define STYLE_RESIZABLE     (WS_THICKFRAME | WS_MAXIMIZEBOX)
+#define STYLE_MASK          (STYLE_FULLSCREEN | STYLE_BORDERLESS | STYLE_NORMAL | STYLE_RESIZABLE)
+
+static DWORD GetWindowStyle(SDL_Window *window)
+{
+    DWORD style = 0;
+
+    if (window->flags & SDL_WINDOW_FULLSCREEN) {
+        style |= STYLE_FULLSCREEN;
+    } else {
+        if (window->flags & SDL_WINDOW_BORDERLESS) {
+            /* SDL 2.1:
+               This behavior more closely matches other platform where the window is borderless
+               but still interacts with the window manager (e.g. task bar shows above it, it can
+               be resized to fit within usable desktop area, etc.) so this should be the behavior
+               for a future SDL release.
+
+               If you want a borderless window the size of the desktop that looks like a fullscreen
+               window, then you should use the SDL_WINDOW_FULLSCREEN_DESKTOP flag.
+             */
+            if (SDL_GetHintBoolean("SDL_BORDERLESS_WINDOWED_STYLE", false)) {
+                style |= STYLE_BORDERLESS_WINDOWED;
+            } else {
+                style |= STYLE_BORDERLESS;
+            }
+        } else {
+            style |= STYLE_NORMAL;
+        }
+
+        if (window->flags & SDL_WINDOW_RESIZABLE) {
+            /* You can have a borderless resizable window, but Windows doesn't always draw it correctly,
+               see https://bugzilla.libsdl.org/show_bug.cgi?id=4466
+             */
+            if (!(window->flags & SDL_WINDOW_BORDERLESS) ||
+                 SDL_GetHintBoolean("SDL_BORDERLESS_RESIZABLE_STYLE", false)) {
+                style |= STYLE_RESIZABLE;
+            }
+        }
+
+        // Need to set initialize minimize style, or when we call ShowWindow with WS_MINIMIZE it will activate a random window
+        if (window->flags & SDL_WINDOW_MINIMIZED) {
+            style |= WS_MINIMIZE;
+        }
+    }
+    return style;
+}
+// Importing from the Windows code.
+void WIN_ScreenPointFromSDL(int *x, int *y, int *dpiOut);
+void WIN_AdjustWindowRectWithStyle(SDL_Window *window, DWORD style, BOOL menu, int *x, int *y, int *width, int *height, bool use_current);
+
+#endif
+
+static bool OPENVR_InitializeOverlay(SDL_VideoDevice *_this, SDL_Window *window);
+
+static bool OPENVR_VideoInit(SDL_VideoDevice *_this)
+{
+    SDL_VideoData *data = (SDL_VideoData *)_this->internal;
+
+    {
+        const char * hintWidth = SDL_GetHint("SDL_DEFAULT_WIDTH");
+        const char * hintHeight = SDL_GetHint("SDL_DEFAULT_HEIGHT");
+        const char * hintFPS = SDL_GetHint("SDL_DEFAULT_FPS");
+        int width = hintWidth?atoi(hintWidth):0;
+        int height = hintHeight?atoi(hintHeight):0;
+        if (height > 0 && width > 0) {
+            openvr_vd_default.desktop_mode.w = width;
+            openvr_vd_default.desktop_mode.h = height;
+        }
+        int fps = hintFPS?atoi(hintFPS):0;
+        if (fps) {
+            openvr_vd_default.desktop_mode.refresh_rate = fps;
+        } else {
+            openvr_vd_default.desktop_mode.refresh_rate = data->oSystem->GetFloatTrackedDeviceProperty(k_unTrackedDeviceIndex_Hmd, ETrackedDeviceProperty_Prop_DisplayFrequency_Float, 0);
+        }
+    }
+
+    openvr_vd_default.internal = (SDL_DisplayData *)data;
+    openvr_vd_default.name = (char*)"OpenVRDisplay";
+    SDL_AddVideoDisplay(&openvr_vd_default, false);
+
+    return true;
+}
+
+static void OPENVR_VideoQuit(SDL_VideoDevice *_this)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    if (videodata->bDidCreateOverlay && videodata->overlayID != 0) {
+        videodata->oOverlay->DestroyOverlay(videodata->overlayID);
+    }
+}
+
+static void OPENVR_Destroy(SDL_VideoDevice *device)
+{
+    // Don't need to destroy and free internal, since it is already done in SDL_VideoQuit
+}
+
+static uint32_t *ImageSDLToOpenVRGL(SDL_Surface * surf, bool bFlipY)
+{
+    int w = surf->w;
+    int h = surf->h;
+    int pitch = surf->pitch;
+    int x, y;
+    uint32_t * pxd = SDL_malloc(4 * surf->w * surf->h);
+    for(y = 0; y < h; y++) {
+        uint32_t * iline = (uint32_t*)&(((uint8_t*)surf->pixels)[y*pitch]);
+        uint32_t * oline = &pxd[(bFlipY?(h-y-1):y)*w];
+        for(x = 0; x < w; x++)
+        {
+            uint32_t pr = iline[x];
+            oline[x] = (pr & 0xff00ff00) | ((pr & 0xff) << 16) | ((pr & 0xff0000)>>16);
+        }
+    }
+    return pxd;
+}
+
+static bool OPENVR_CheckRenderbuffer(SDL_VideoDevice *_this)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+
+    if (videodata->targw == 0 || videodata->targh == 0) {
+        videodata->targw = OPENVR_DEFAULT_WIDTH;
+        videodata->targh = OPENVR_DEFAULT_HEIGHT;
+    }
+
+    if (videodata->targh != videodata->last_targh
+     || videodata->targw != videodata->last_targw) {
+
+        struct HmdVector2_t ms;
+        int status;
+
+        if (videodata->fbo <= 0) {
+            ov_glGenFramebuffers(1, &videodata->fbo);
+            ov_glGenRenderbuffers(1, &videodata->rbo);
+            ov_glGenTextures(1, &videodata->overlaytexture);
+        }
+
+        // Generate the OpenGL Backing buffers/etc.
+        ov_glBindFramebuffer(GL_FRAMEBUFFER, videodata->fbo);
+        ov_glBindRenderbuffer(GL_RENDERBUFFER, videodata->rbo);
+        ov_glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT, videodata->targw, videodata->targh);
+        ov_glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, videodata->rbo);
+        ov_glBindTexture(GL_TEXTURE_2D, videodata->overlaytexture);
+        ov_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+        ov_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+        ov_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, videodata->targw, videodata->targh, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
+        ov_glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, videodata->overlaytexture, 0);
+        status = ov_glCheckNamedFramebufferStatus(videodata->fbo, GL_FRAMEBUFFER);
+        if (status != GL_FRAMEBUFFER_COMPLETE) {
+            return SDL_SetError("OPENVR: Can't generate overlay buffer");
+        }
+        ov_glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+        ms.v[0] = (float)videodata->targw;
+        ms.v[1] = (float)videodata->targh;
+        videodata->oOverlay->SetOverlayMouseScale(videodata->overlayID, &ms);
+
+        videodata->last_targh = videodata->targh;
+        videodata->last_targw = videodata->targw;
+    }
+    return true;
+}
+
+static bool OPENVR_VirtualControllerRumble(void *userdata, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
+{
+    // On XBOX Controllers Low/High maps to Left/Right
+    SDL_VideoData *videodata = (SDL_VideoData *)userdata;
+
+    const float k_flIntensity = 320.f; // Maximum frequency
+    float flLeftFrequency = (float)low_frequency_rumble * k_flIntensity / 65535.f;
+    float flRightFrequency = (float)high_frequency_rumble * k_flIntensity / 65535.f;
+    float flDurationSeconds = 2.f;
+    float flAmplitude = 1.f;
+
+    videodata->oInput->TriggerHapticVibrationAction(videodata->input_action_handles_haptics[0], 0, flDurationSeconds, flLeftFrequency, flAmplitude, 0);
+    videodata->oInput->TriggerHapticVibrationAction(videodata->input_action_handles_haptics[1], 0, flDurationSeconds, flRightFrequency, flAmplitude, 0);
+
+    return true;
+}
+
+static bool OPENVR_VirtualControllerRumbleTriggers(void *userdata, Uint16 left_rumble, Uint16 right_rumble)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)userdata;
+    videodata->oInput->TriggerHapticVibrationAction(videodata->input_action_handles_haptics[0], 0, 0.1f, left_rumble, 1.0, 0);
+    videodata->oInput->TriggerHapticVibrationAction(videodata->input_action_handles_haptics[1], 0, 0.1f, right_rumble, 1.0, 0);
+    return true;
+}
+
+static void OPENVR_VirtualControllerUpdate(void *userdata)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)userdata;
+    SDL_Joystick * joystick = videodata->virtual_joystick;
+    InputDigitalActionData_t digital_input_action;
+    InputAnalogActionData_t analog_input_action;
+    EVRInputError e;
+#ifdef DEBUG_OPENVR
+    //char cts[10240];
+    //char * ctsx = cts;
+#endif
+    VRActiveActionSet_t actionSet = { 0 };
+    actionSet.ulActionSet = videodata->input_action_set;
+    e = videodata->oInput->UpdateActionState(&actionSet, sizeof(actionSet), 1);
+    if (e)
+    {
+#ifdef DEBUG_OPENVR
+        SDL_Log("ERROR: Failed to update action state");
+#endif
+        return;
+    }
+
+    for (int d = 0; d < videodata->input_action_handles_buttons_count; d++)
+    {
+        if (videodata->input_action_handles_buttons[d] == k_ulInvalidActionHandle)
+            continue;
+        e = videodata->oInput->GetDigitalActionData(videodata->input_action_handles_buttons[d], &digital_input_action, sizeof(digital_input_action), k_ulInvalidInputValueHandle);
+        if (e)
+        {
+#ifdef DEBUG_OPENVR
+            SDL_Log("ERROR: Failed to get digital action data: %d", d);
+#endif
+            return;
+        }
+        SDL_SetJoystickVirtualButton(joystick, d, digital_input_action.bState);
+#ifdef DEBUG_OPENVR
+        //ctsx+=sprintf(ctsx,"%d", digital_input_action.bState);
+#endif
+    }
+
+    // Left Stick
+    e = videodata->oInput->GetAnalogActionData(videodata->input_action_handles_axes[0], &analog_input_action, sizeof(analog_input_action), k_ulInvalidInputValueHandle);
+    if (e)
+    {
+#ifdef DEBUG_OPENVR
+        SDL_Log("ERROR: Failed to get analog action data: left stick");
+#endif
+        return;
+    }
+    SDL_SetJoystickVirtualAxis(joystick, SDL_GAMEPAD_AXIS_LEFTX, (Sint16)(analog_input_action.x * SDL_JOYSTICK_AXIS_MAX));
+    SDL_SetJoystickVirtualAxis(joystick, SDL_GAMEPAD_AXIS_LEFTY, (Sint16)(-analog_input_action.y * SDL_JOYSTICK_AXIS_MAX));
+
+    // Right Stick
+    e = videodata->oInput->GetAnalogActionData(videodata->input_action_handles_axes[1], &analog_input_action, sizeof(analog_input_action), k_ulInvalidInputValueHandle);
+    if (e)
+    {
+#ifdef DEBUG_OPENVR
+        SDL_Log("ERROR: Failed to get analog action data: right stick");
+#endif
+        return;
+    }
+    SDL_SetJoystickVirtualAxis(joystick, SDL_GAMEPAD_AXIS_RIGHTX, (Sint16)(analog_input_action.x * SDL_JOYSTICK_AXIS_MAX));
+    SDL_SetJoystickVirtualAxis(joystick, SDL_GAMEPAD_AXIS_RIGHTY, (Sint16)(-analog_input_action.y * SDL_JOYSTICK_AXIS_MAX));
+
+    // Left Trigger
+    e = videodata->oInput->GetAnalogActionData(videodata->input_action_handles_axes[2], &analog_input_action, sizeof(analog_input_action), k_ulInvalidInputValueHandle);
+    if (e)
+    {
+#ifdef DEBUG_OPENVR
+        SDL_Log("ERROR: Failed to get analog action data: left trigger");
+#endif
+        return;
+    }
+    SDL_SetJoystickVirtualAxis(joystick, SDL_GAMEPAD_AXIS_LEFT_TRIGGER, (Sint16)((analog_input_action.x * 2.0f - 1.0f) * SDL_JOYSTICK_AXIS_MAX));
+
+    // Right Trigger
+    e = videodata->oInput->GetAnalogActionData(videodata->input_action_handles_axes[3], &analog_input_action, sizeof(analog_input_action), k_ulInvalidInputValueHandle);
+    if (e)
+    {
+#ifdef DEBUG_OPENVR
+        SDL_Log("ERROR: Failed to get analog action data: right trigger");
+#endif
+        return;
+    }
+    SDL_SetJoystickVirtualAxis(joystick, SDL_GAMEPAD_AXIS_RIGHT_TRIGGER, (Sint16)((analog_input_action.x * 2.0f - 1.0f) * SDL_JOYSTICK_AXIS_MAX));
+
+#if 0
+    for (a = 0; a < videodata->input_action_handles_axes_count; a++)
+    {
+        float xval = 0.0f;
+        e = videodata->oInput->GetAnalogActionData(videodata->input_action_handles_axes[a], &analog_input_action, sizeof(analog_input_action), k_ulInvalidInputValueHandle);
+        if (e) goto updatefail;
+        xval = analog_input_action.x;
+        if (a == SDL_CONTROLLER_AXIS_LEFTY || a == SDL_CONTROLLER_AXIS_RIGHTY)
+          xval *= -1.0f;
+        if (a == SDL_GAMEPAD_AXIS_LEFT_TRIGGER || a == SDL_GAMEPAD_AXIS_RIGHT_TRIGGER)
+          xval = xval * 2.0f - 1.0f;
+        //SDL_SetJoystickVirtualAxis(joystick, a, analog_input_action.x*32767);
+        xval *= SDL_JOYSTICK_AXIS_MAX;
+        SDL_SetJoystickVirtualAxis(joystick, a, xval);
+#ifdef DEBUG_OPENVR
+        //ctsx+=sprintf(ctsx,"[%f]", analog_input_action.x);
+#endif
+    }
+#endif
+#ifdef DEBUG_OPENVR
+    //SDL_Log("Debug Input States: %s", cts);
+#endif
+    return;
+}
+
+static bool OPENVR_SetupJoystckBasedOnLoadedActionManifest(SDL_VideoData * videodata)
+{
+    SDL_VirtualJoystickDesc desc;
+    int virtual_index;
+
+    EVRInputError e = 0;
+
+    char * k_pchBooleanActionPaths[SDL_GAMEPAD_BUTTON_COUNT] = {
+        "/actions/virtualgamepad/in/a",
+        "/actions/virtualgamepad/in/b",
+        "/actions/virtualgamepad/in/x",
+        "/actions/virtualgamepad/in/y",
+        "/actions/virtualgamepad/in/back",
+        "/actions/virtualgamepad/in/guide",
+        "/actions/virtualgamepad/in/start",
+        "/actions/virtualgamepad/in/stick_click_left",
+        "/actions/virtualgamepad/in/stick_click_right",
+        "/actions/virtualgamepad/in/shoulder_left",
+        "/actions/virtualgamepad/in/shoulder_right",
+        "/actions/virtualgamepad/in/dpad_up",
+        "/actions/virtualgamepad/in/dpad_down",
+        "/actions/virtualgamepad/in/dpad_left",
+        "/actions/virtualgamepad/in/dpad_right",
+        "/actions/virtualgamepad/in/misc_1",
+        "/actions/virtualgamepad/in/paddle_1",
+        "/actions/virtualgamepad/in/paddle_2",
+        "/actions/virtualgamepad/in/paddle_3",
+        "/actions/virtualgamepad/in/paddle_4",
+        "/actions/virtualgamepad/in/touchpad_click",
+        "/actions/virtualgamepad/in/misc_2",
+        "/actions/virtualgamepad/in/misc_3",
+        "/actions/virtualgamepad/in/misc_4",
+        "/actions/virtualgamepad/in/misc_5",
+        "/actions/virtualgamepad/in/misc_6",
+    };
+    char * k_pchAnalogActionPaths[4] = {
+        "/actions/virtualgamepad/in/stick_left",
+        "/actions/virtualgamepad/in/stick_right",
+        "/actions/virtualgamepad/in/trigger_left",
+        "/actions/virtualgamepad/in/trigger_right",
+    };
+
+    if ((e = videodata->oInput->GetActionSetHandle("/actions/virtualgamepad", &videodata->input_action_set)) != EVRInputError_VRInputError_None)
+    {
+#ifdef DEBUG_OPENVR
+        SDL_Log("ERROR: Failed to get action set handle: %d", e);
+#endif
+        return SDL_SetError("Failed to get action set handle");
+    }
+
+    videodata->input_action_handles_buttons_count = sizeof(k_pchBooleanActionPaths) / sizeof(k_pchBooleanActionPaths[0]);
+    videodata->input_action_handles_buttons = SDL_malloc(videodata->input_action_handles_buttons_count * sizeof(VRActionHandle_t));
+
+    for (int i = 0; i < videodata->input_action_handles_buttons_count; i++)
+    {
+        e = videodata->oInput->GetActionHandle(k_pchBooleanActionPaths[i], &videodata->input_action_handles_buttons[i]);
+        if (e)
+        {
+            SDL_Log("ERROR: Failed to get button action %d ('%s')", i, k_pchBooleanActionPaths[i]);
+            return SDL_SetError("ERROR: Failed to get button action");
+        }
+    }
+
+    videodata->input_action_handles_axes_count = sizeof(k_pchAnalogActionPaths) / sizeof(k_pchAnalogActionPaths[0]);
+    videodata->input_action_handles_axes = SDL_malloc(videodata->input_action_handles_axes_count * sizeof(VRActionHandle_t));
+
+    for (int i = 0; i < videodata->input_action_handles_axes_count; i++)
+    {
+        e = videodata->oInput->GetActionHandle(k_pchAnalogActionPaths[i], &videodata->input_action_handles_axes[i]);
+        if (e)
+        {
+            SDL_Log("ERROR: Failed to get analog action %d ('%s')", i, k_pchAnalogActionPaths[i]);
+            return SDL_SetError("ERROR: Failed to get analog action");
+        }
+    }
+
+    e  = videodata->oInput->GetActionHandle("/actions/virtualgamepad/out/haptic_left", &videodata->input_action_handles_haptics[0]);
+    e |= videodata->oInput->GetActionHandle("/actions/virtualgamepad/out/haptic_right", &videodata->input_action_handles_haptics[1]);
+    if (e)
+    {
+#ifdef DEBUG_OPENVR
+        SDL_Log("ERROR: Failed to get haptics action");
+#endif
+        return SDL_SetError("ERROR: Failed to get haptics action");
+    }
+
+    // Create a virtual joystick.
+    SDL_INIT_INTERFACE(&desc);
+    desc.type = SDL_JOYSTICK_TYPE_GAMEPAD;
+    desc.naxes = SDL_GAMEPAD_AXIS_COUNT;
+    desc.nbuttons = SDL_GAMEPAD_BUTTON_COUNT;
+    desc.Rumble = OPENVR_VirtualControllerRumble;
+    desc.RumbleTriggers = OPENVR_VirtualControllerRumbleTriggers;
+    desc.Update = OPENVR_VirtualControllerUpdate;
+    desc.userdata = videodata;
+    virtual_index = SDL_AttachVirtualJoystick(&desc);
+
+    if (virtual_index < 0) {
+        return SDL_SetError("OPENVR: Couldn't open virtual joystick device: %s", SDL_GetError());
+    } else {
+        videodata->virtual_joystick = SDL_OpenJoystick(virtual_index);
+        if (!videodata->virtual_joystick) {
+            return SDL_SetError("OPENVR: Couldn't open virtual joystick device: %s", SDL_GetError());
+        }
+    }
+
+#ifdef DEBUG_OPENVR
+    SDL_Log("Loaded virtual joystick with %d buttons and %d axes", videodata->input_action_handles_buttons_count, videodata->input_action_handles_axes_count);
+#endif
+
+    return false;
+}
+
+static bool OPENVR_InitializeOverlay(SDL_VideoDevice *_this,SDL_Window *window)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+
+    // Wait til here, to make sure we have our context setup correctly.
+    if (!OPENVR_InitExtensions(_this)) {
+        return false;
+    }
+
+    // Generate the overlay.
+    {
+        const char * hint = SDL_GetHint("SDL_OPENVR_OVERLAY_NAME");
+        char * cursorname = 0;
+        if (!hint) {
+            hint = "sdl";
+        }
+
+        SDL_asprintf(&videodata->sOverlayName, "%s-overlay",hint);
+        if (!videodata->sOverlayName) {
+            return false;
+        }
+        SDL_asprintf(&cursorname, "%s-cursor",hint);
+        if (!cursorname) {
+            return false;
+        }
+
+        EVROverlayError result = videodata->oOverlay->CreateDashboardOverlay(videodata->sOverlayName,
+            window->title, &videodata->overlayID, &videodata->thumbID);
+        if (result != EVROverlayError_VROverlayError_None) {
+            SDL_free(cursorname);
+            return SDL_SetError("Could not create dashboard overlay (%d)", result );
+        }
+        result = videodata->oOverlay->CreateOverlay(cursorname, window->title, &videodata->cursorID);
+        if (result != EVROverlayError_VROverlayError_None) {
+            SDL_free(cursorname);
+            return SDL_SetError("Could not create cursor overlay (%d)", result );
+        }
+        SDL_PropertiesID props = SDL_GetWindowProperties(window);
+        SDL_SetNumberProperty(props, SDL_PROP_WINDOW_OPENVR_OVERLAY_ID, videodata->overlayID);
+        SDL_free(cursorname);
+        videodata->bHasShownOverlay = false;
+    }
+    {
+        const char * hint = SDL_GetHint("SDL_OPENVR_OVERLAY_PANEL_WIDTH");
+        float fWidth = (float)(hint?atof(hint):1.0f);
+        videodata->oOverlay->SetOverlayWidthInMeters(videodata->overlayID, fWidth);
+    }
+    {
+        const char * hint = SDL_GetHint("SDL_OPENVR_CURSOR_WIDTH");
+        // Default is what SteamVR Does
+        float fCursorWidth = (float)(hint?atof(hint):0.06f);
+        videodata->oOverlay->SetOverlayWidthInMeters(videodata->cursorID, fCursorWidth * 0.5f);
+    }
+    {
+        const char * hint = SDL_GetHint("SDL_OPENVR_WINDOW_ICON_FILE");
+        videodata->bIconOverridden = false;
+        if (hint) {
+            char * tmpcopy = SDL_strdup(hint);
+            EVROverlayError err = videodata->oOverlay->SetOverlayFromFile(videodata->thumbID, tmpcopy);
+            SDL_free(tmpcopy);
+            if (err == EVROverlayError_VROverlayError_None) {
+                videodata->bIconOverridden = SDL_GetHintBoolean("SDL_OPENVR_WINDOW_ICON_OVERRIDE",false);
+            }
+        }
+    }
+    {
+        VRTextureBounds_t bounds;
+        bounds.uMin = 0;
+        bounds.uMax = 1;
+        bounds.vMin = 0;
+        bounds.vMax = 1;
+        videodata->oOverlay->SetOverlayTextureBounds(videodata->overlayID, &bounds);
+    }
+
+    if (!OPENVR_CheckRenderbuffer(_this)) {
+        return false;
+    }
+
+
+    global_openvr_driver = videodata;
+    InitializeMouseFunctions();
+
+    // Actually show the overlay.
+    videodata->oOverlay->SetOverlayFlag(videodata->overlayID, 1<<23, true); //vr::VROverlayFlags_EnableControlBar
+    videodata->oOverlay->SetOverlayFlag(videodata->overlayID, 1<<24, true); //vr::VROverlayFlags_EnableControlBarKeyboard
+    videodata->oOverlay->SetOverlayFlag(videodata->overlayID, 1<<25, true); //vr::VROverlayFlags_EnableControlBarClose
+    videodata->oOverlay->SetOverlayName(videodata->overlayID, window->title);
+
+    videodata->bDidCreateOverlay = true;
+    videodata->window = window;
+
+    return true;
+}
+
+
+static bool OPENVR_SetupFrame(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    static const GLenum buffers[8] = { GL_COLOR_ATTACHMENT0_EXT };
+
+    videodata->is_buffer_rendering = true;
+
+#ifdef DEBUG_OPENVR
+    {
+        int error = ov_glGetError();
+        if (error)
+            SDL_Log("Found GL Error before beginning frame: %d / (Framebuffer:%d)\n", error, ov_glCheckNamedFramebufferStatus(videodata->fbo, GL_FRAMEBUFFER));
+    }
+#endif
+
+    ov_glBindFramebuffer(GL_FRAMEBUFFER, videodata->fbo);
+    ov_glDrawBuffers(1, buffers);
+
+    // Set the alpha channel for non-transparent windows
+    if (!(window->flags & SDL_WINDOW_TRANSPARENT)) {
+        ov_glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+        ov_glColorMask(false, false, false, true);
+        ov_glClear(GL_COLOR_BUFFER_BIT);
+        ov_glColorMask(true, true, true, true);
+    }
+
+    ov_glBindTexture( GL_TEXTURE_2D, videodata->saved_texture_state );
+
+    return true;
+}
+
+static bool OPENVR_ReleaseFrame(SDL_VideoDevice *_this)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    ov_glGetIntegerv(GL_TEXTURE_BINDING_2D, &videodata->saved_texture_state);
+
+    if (!ov_glGetError) {
+        return true;
+    }
+
+    if (!videodata->is_buffer_rendering) {
+        return true;
+    }
+
+#ifdef DEBUG_OPENVR
+    {
+        int error = ov_glGetError();
+        if (error) {
+            SDL_Log("Found GL Error before release frame: %d / (Framebuffer:%d)\n", error, ov_glCheckNamedFramebufferStatus(videodata->fbo, GL_FRAMEBUFFER));
+        }
+    }
+#endif
+
+    videodata->is_buffer_rendering = false;
+
+    ov_glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    if (videodata->overlaytexture != 0 &&
+        videodata->targh == videodata->last_targh &&
+        videodata->targw == videodata->last_targw) {
+        // Only submit frames to OpenVR if the textu re exists.
+        struct Texture_t tex;
+
+        // Setup a Texture_t object to send in the texture.
+        tex.eColorSpace = EColorSpace_ColorSpace_Auto;
+        tex.eType = ETextureType_TextureType_OpenGL;
+        tex.handle = (void *)(intptr_t)videodata->overlaytexture;
+
+        // Send texture into OpenVR as the overlay.
+        videodata->oOverlay->SetOverlayTexture(videodata->overlayID, &tex);
+    }
+
+    if (!videodata->bHasShownOverlay && videodata->bDidCreateOverlay) {
+        videodata->oOverlay->ShowDashboard(videodata->sOverlayName);
+        videodata->bHasShownOverlay = true;
+    }
+
+    if (videodata->renderdoc_debugmarker_frame_end) {
+        ov_glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION,
+            GL_DEBUG_TYPE_MARKER, MARKER_ID, GL_DEBUG_SEVERITY_NOTIFICATION, -1,
+            MARKER_STR);
+    }
+
+    return OPENVR_CheckRenderbuffer(_this);
+}
+
+static void OPENVR_HandleResize(SDL_VideoDevice *_this, int w, int h)
+{
+    SDL_VideoData *data = (SDL_VideoData *)_this->internal;
+    data->targw = w;
+    data->targh = h;
+}
+
+static bool OPENVR_SetDisplayMode(SDL_VideoDevice *_this, SDL_VideoDisplay *display, SDL_DisplayMode *mode)
+{
+    return true;
+}
+
+
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+static LRESULT CALLBACK OpenVRVideoWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    switch (msg) {
+    case WM_DESTROY:
+        return 0;
+    }
+    return DefWindowProc(hwnd, msg, wParam, lParam);
+}
+
+static bool OPENVR_GL_LoadLibrary(SDL_VideoDevice *_this, const char *path)
+{
+    if (path == NULL) {
+        path = SDL_GetHint(SDL_HINT_OPENGL_LIBRARY);
+    }
+
+    if (path == NULL) {
+        path = DEFAULT_OPENGL;
+    }
+    _this->gl_config.dll_handle = SDL_LoadObject(path);
+    if (!_this->gl_config.dll_handle) {
+        return false;
+    }
+    SDL_strlcpy(_this->gl_config.driver_path, path,
+                 SDL_arraysize(_this->gl_config.driver_path));
+
+    // Allocate OpenGL memory
+    _this->gl_data = (struct SDL_GLDriverData *)SDL_calloc(1, sizeof(struct SDL_GLDriverData));
+    if (!_this->gl_data) {
+        return false;
+    }
+    _this->gl_config.driver_loaded = true;
+
+    return true;
+}
+
+static SDL_FunctionPointer OPENVR_GL_GetProcAddress(SDL_VideoDevice *_this, const char *proc)
+{
+    SDL_FunctionPointer result = NULL;
+    if (ov_wglGetProcAddress) {
+        result = (SDL_FunctionPointer)ov_wglGetProcAddress(proc);
+        if (result) {
+            return result;
+        }
+    }
+
+    return SDL_LoadFunction(_this->gl_config.dll_handle, proc);
+}
+
+static void OPENVR_GL_UnloadLibrary(SDL_VideoDevice *_this)
+{
+    SDL_GL_UnloadLibrary();
+}
+
+static SDL_GLContext OPENVR_GL_CreateContext(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    GLint numExtensions;
+    int i;
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    if (!videodata->hglrc) {
+        // Crate a surfaceless EGL Context
+        HWND hwnd;
+
+        WNDCLASSA wnd;
+        wnd.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
+        wnd.lpfnWndProc = OpenVRVideoWndProc;
+        wnd.cbClsExtra = 0;
+        wnd.cbWndExtra = 0;
+        wnd.hInstance = GetModuleHandle(NULL);
+        wnd.hIcon = LoadIcon(NULL, IDI_APPLICATION);
+        wnd.hCursor = LoadCursor(NULL, IDC_ARROW);
+        wnd.hbrBackground = (HBRUSH)(COLOR_BACKGROUND);
+        wnd.lpszMenuName = NULL;
+        wnd.lpszClassName = "SDL_openvrvideo_classname";
+        RegisterClassA(&wnd);
+        hwnd = CreateWindowA("SDL_openvrvideo_classname", "SDL_openvrvideo_windowname", (WS_OVERLAPPEDWINDOW), 0, 0,
+                              100, 100, NULL, NULL, GetModuleHandle(NULL), NULL);
+
+        MSG msg;
+        while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
+            TranslateMessage(&msg);
+            DispatchMessage(&msg);
+        }
+
+        videodata->hdc = GetDC(hwnd);
+
+        static  PIXELFORMATDESCRIPTOR pfd =
+        {
+            sizeof(PIXELFORMATDESCRIPTOR),
+            1,
+            PFD_DRAW_TO_WINDOW |
+            PFD_SUPPORT_OPENGL |
+            PFD_DOUBLEBUFFER,
+            PFD_TYPE_RGBA,
+            24,
+            8, 0, 8, 8, 8, 16,
+            8,
+            24,
+            32,
+            8, 8, 8, 8,
+            16,
+            0,
+            0,
+            PFD_MAIN_PLANE,
+            0,
+            0, 0, 0
+        };
+        GLuint PixelFormat = ChoosePixelFormat(videodata->hdc, &pfd);
+        if (!SetPixelFormat(videodata->hdc, PixelFormat, &pfd)) {
+            SDL_SetError( "Could not set pixel format" );
+            return NULL;
+        }
+        HMODULE opengl = GetModuleHandleA(DEFAULT_OPENGL);
+        if (!opengl) {
+            SDL_SetError("Could not open OpenGL Library %s", DEFAULT_OPENGL);
+            return NULL;
+        }
+
+        ov_wglMakeCurrent = (BOOL(*)(HDC, HGLRC))GetProcAddress(opengl, "wglMakeCurrent");
+        ov_wglCreateContext = (HGLRC(*)(HDC))GetProcAddress(opengl, "wglCreateContext");
+        ov_wglGetProcAddress = (PROC(*)(LPCSTR))GetProcAddress(opengl, "wglGetProcAddress");
+        ov_wglDeleteContext = (BOOL(*)(HGLRC))GetProcAddress(opengl, "wglDeleteContext");
+        if (!ov_wglMakeCurrent || !ov_wglCreateContext) {
+            SDL_SetError("Cannot get wgl context procs(%p, %p)", ov_wglMakeCurrent, ov_wglCreateContext);
+            return NULL;
+        }
+
+        videodata->hglrc = ov_wglCreateContext(videodata->hdc);
+        if (!videodata->hglrc || !ov_wglMakeCurrent(videodata->hdc, videodata->hglrc)) {
+            SDL_SetError("Could not make current OpenGL context.");
+            return NULL;
+        }
+    }
+
+    i = OPENVR_InitExtensions(_this);
+    if (i == 0) {
+        return NULL;
+    }
+
+    videodata->renderdoc_debugmarker_frame_end = false;
+
+    ov_glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
+    for (i = 0; i < numExtensions; i++) {
+        const char *ccc = (const char *)ov_glGetStringi(GL_EXTENSIONS, i);
+        if (SDL_strcmp(ccc, "GL_KHR_debug") == 0) {
+#ifdef DEBUG_OPENVR
+            SDL_Log("Found renderdoc debug extension.\n");
+#endif
+            videodata->renderdoc_debugmarker_frame_end = true;
+        }
+    }
+
+    if (!videodata->bDidCreateOverlay) {
+        if (!OPENVR_InitializeOverlay(_this, window)) {
+            return NULL;
+        }
+    }
+
+    OPENVR_CheckRenderbuffer(_this);
+
+    OPENVR_SetupFrame(_this, window);
+
+    SDL_GLContext result = malloc(sizeof(struct SDL_GLContextState));
+    result->hglrc = videodata->hglrc;
+    return result;
+}
+
+static bool OPENVR_GL_MakeCurrent(SDL_VideoDevice *_this, SDL_Window *wnd, SDL_GLContext context)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    ov_wglMakeCurrent(videodata->hdc, videodata->hglrc);
+    return true;
+}
+
+static bool OPENVR_GL_SetSwapInterval(SDL_VideoDevice *_this, int interval)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    videodata->swap_interval = interval;
+    return true;
+}
+
+static bool OPENVR_GL_GetSwapInterval(SDL_VideoDevice *_this, int *swapInterval)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    if (swapInterval)
+        *swapInterval = videodata->swap_interval;
+    else
+        return SDL_SetError("OPENVR: null passed in for GetSwapInterval");
+    return true;
+}
+
+static bool OPENVR_GL_DestroyContext(SDL_VideoDevice *_this, SDL_GLContext context)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    ov_wglMakeCurrent(videodata->hdc, NULL);
+    ov_wglDeleteContext(videodata->hglrc);
+    return true;
+}
+
+
+#else
+
+EGLint context_attribs[] = {
+    EGL_CONTEXT_CLIENT_VERSION, 2,
+    EGL_NONE
+};
+
+static bool SDL_EGL_InitInternal(SDL_VideoData * vd)
+{
+    // Crate a surfaceless EGL Context
+    EGLint major, minor;
+    EGLConfig eglCfg=NULL;
+    EGLBoolean b;
+
+    vd->eglDpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
+#ifdef DEBUG_OPENVR
+    SDL_Log("EGL Display: %p\n", vd->eglDpy);
+#endif
+
+    if (vd->eglDpy == 0) {
+        return SDL_SetError("No EGL Display");
+    }
+
+    b = eglInitialize(vd->eglDpy, &major, &minor);
+    if (!b) {
+        return SDL_SetError("eglInitialize failed");
+    }
+
+    eglBindAPI(EGL_OPENGL_API);
+#ifdef DEBUG_OPENVR
+    SDL_Log("EGL Major Minor: %d %d = %d", major, minor, b);
+#endif
+
+    vd->eglCtx = eglCreateContext(vd->eglDpy, eglCfg, EGL_NO_CONTEXT, context_attribs);
+
+#ifdef DEBUG_OPENVR
+    {
+        int err = eglGetError();
+        if (err != EGL_SUCCESS) {
+            return SDL_SetError("EGL Error after eglCreateContext %d", err);
+        }
+    }
+#endif
+
+    if (!vd->eglCtx) {
+        return SDL_SetError("No EGL context available");
+    }
+
+    eglMakeCurrent(vd->eglDpy, EGL_NO_SURFACE, EGL_NO_SURFACE, vd->eglCtx);
+
+    return true;
+}
+
+// Linux, EGL, etc.
+static bool OVR_EGL_LoadLibrary(SDL_VideoDevice *_this, const char *path)
+{
+    return SDL_EGL_LoadLibrary(_this, path, /*displaydata->native_display*/0, 0);
+}
+
+static SDL_FunctionPointer OVR_EGL_GetProcAddress(SDL_VideoDevice *_this, const char *proc)
+{
+    return SDL_EGL_GetProcAddress(proc);
+}
+static void OVR_EGL_UnloadLibrary(SDL_VideoDevice *_this)
+{
+    return SDL_EGL_UnloadLibrary(_this);
+}
+static SDL_GLContext OVR_EGL_CreateContext(SDL_VideoDevice *_this, SDL_Window * window)
+{
+    GLint numExtensions;
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    if (!videodata->eglCtx) {
+        if (!SDL_EGL_InitInternal(videodata)) {
+            return NULL;
+        }
+    }
+
+    if (!OPENVR_InitExtensions(_this)) {
+        return NULL;
+    }
+
+    videodata->renderdoc_debugmarker_frame_end = false;
+
+    ov_glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
+    for(int i = 0; i < numExtensions; i++) {
+        const char * ccc = (const char*)ov_glGetStringi(GL_EXTENSIONS, i);
+        if (SDL_strcmp(ccc, "GL_KHR_debug") == 0) {
+#ifdef DEBUG_OPENVR
+           SDL_Log("Found renderdoc debug extension.\n");
+#endif
+           videodata->renderdoc_debugmarker_frame_end = true;
+        }
+    }
+
+    if (!videodata->bDidCreateOverlay) {
+        if (!OPENVR_InitializeOverlay(_this, window)) {
+            return NULL;
+        }
+    }
+
+    OPENVR_CheckRenderbuffer(_this);
+
+    OPENVR_SetupFrame(_this, window);
+
+    return videodata->eglCtx;
+}
+
+static bool OVR_EGL_MakeCurrent(SDL_VideoDevice *_this, SDL_Window * wnd, SDL_GLContext context)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    eglMakeCurrent(videodata->eglDpy, EGL_NO_SURFACE, EGL_NO_SURFACE, videodata->eglCtx);
+    return true;
+}
+
+static bool OVR_EGL_SetSwapInterval(SDL_VideoDevice *_this, int interval)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    videodata->swap_interval = interval;
+    return true;
+}
+
+static bool OVR_EGL_GetSwapInterval(SDL_VideoDevice *_this, int * swapInterval)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    if (swapInterval)
+        *swapInterval = videodata->swap_interval;
+    else
+        return SDL_SetError("OPENVR: null passed in for GetSwapInterval");
+    return true;
+}
+
+static bool OVR_EGL_DestroyContext(SDL_VideoDevice *_this, SDL_GLContext context)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    if (videodata->eglDpy) {
+        eglTerminate(videodata->eglDpy);
+    }
+    return true;
+}
+
+#endif
+
+static bool OPENVR_CreateWindow(SDL_VideoDevice *_this, SDL_Window *window, SDL_PropertiesID create_props)
+{
+    SDL_WindowData *data;
+
+    // Allocate window internal data
+    data = (SDL_WindowData *)SDL_calloc(1, sizeof(SDL_WindowData));
+    if (data == NULL) {
+        return SDL_OutOfMemory();
+    }
+
+    window->max_w = 4096;
+    window->max_h = 4096;
+    window->min_w = 1;
+    window->min_h = 1;
+
+    // Setup driver data for this window
+    window->internal = data;
+    return true;
+}
+
+
+static void OPENVR_DestroyWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_WindowData *data;
+
+    data = window->internal;
+    if (data) {
+        SDL_free(data);
+    }
+    window->internal = NULL;
+}
+
+static void OPENVR_SetWindowTitle(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_VideoData * data = (SDL_VideoData *)_this->internal;
+    if (data->bDidCreateOverlay) {
+        data->oOverlay->SetOverlayName(data->overlayID, window->title);
+    }
+}
+
+static void OPENVR_SetWindowSize(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_VideoData *data = (SDL_VideoData *)_this->internal;
+
+    if (window->floating.w != window->w) {
+        window->w = window->floating.w;
+    }
+
+    if (window->floating.h != window->h) {
+        window->h = window->floating.h;
+    }
+
+    if (data->targh != window->h || data->targw != window->w) {
+        OPENVR_HandleResize(_this, window->w, window->h);
+    }
+
+    SDL_SendWindowEvent(window, SDL_EVENT_WINDOW_RESIZED, window->w, window->h);
+}
+
+static void OPENVR_GetWindowSizeInPixels(SDL_VideoDevice *_this, SDL_Window *window, int *w, int *h)
+{
+    SDL_VideoData *data = (SDL_VideoData *)_this->internal;
+    *w = data->targw;
+    *h = data->targh;
+}
+
+static void OPENVR_ShowWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_VideoData *data = (SDL_VideoData *)_this->internal;
+    if (data->targh != window->h || data->targw != window->w) {
+        OPENVR_HandleResize(_this, window->w, window->h);
+    }
+
+    data->oOverlay->ShowDashboard(data->sOverlayName);
+
+    window->flags |= (SDL_WINDOW_INPUT_FOCUS | SDL_WINDOW_MOUSE_FOCUS);
+    SDL_SetKeyboardFocus(window);
+}
+
+static void OPENVR_HideWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    return;
+}
+
+static bool OPENVR_GL_SwapWindow(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+
+    // This is a little weird.   On Windows, we don't necessarily call the normal
+    // context creation function, and we might get here without having our buffers
+    // initialized.
+    if (!videodata->bDidCreateOverlay) {
+        if (!OPENVR_InitializeOverlay(_this, window)) {
+            return false;
+        }
+    }
+
+    if (!OPENVR_ReleaseFrame(_this)) {
+        return false;
+    }
+
+    // If swap_interval is nonzero (i.e. -1 or 1) we want to wait for vsync on the compositor.
+    if (videodata->swap_interval != 0) {
+        videodata->oOverlay->WaitFrameSync(100);
+    }
+
+    if (!OPENVR_SetupFrame(_this, window)) {
+        return false;
+    }
+
+    return true;
+}
+
+static void OPENVR_HandleMouse(float x, float y, int btn, int evt)
+{
+    if (evt == 2) {
+        SDL_SendMouseMotion(0, 0, 0, false, (int)x, (int)y);
+    } else {
+        SDL_SendMouseButton(0, 0, 0, btn + 1, (evt != 0));
+    }
+}
+
+
+static bool OPENVR_HasScreenKeyboardSupport(SDL_VideoDevice *_this)
+{
+    return true;
+}
+
+static void OPENVR_ShowScreenKeyboard(SDL_VideoDevice *_this, SDL_Window *window, SDL_PropertiesID props)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    if (!videodata ||
+        videodata->oOverlay == 0 ||
+        videodata->overlayID == 0) {
+        return;
+    }
+    EGamepadTextInputMode input_mode;
+    switch (SDL_GetTextInputType(props)) {
+    case SDL_TEXTINPUT_TYPE_TEXT_PASSWORD_HIDDEN:
+    case SDL_TEXTINPUT_TYPE_NUMBER_PASSWORD_HIDDEN:
+        input_mode = EGamepadTextInputMode_k_EGamepadTextInputModePassword;
+        break;
+    default:
+        input_mode = EGamepadTextInputMode_k_EGamepadTextInputModeNormal;
+        break;
+    }
+    EGamepadTextInputLineMode line_mode;
+    if (SDL_GetTextInputMultiline(props)) {
+        line_mode = EGamepadTextInputLineMode_k_EGamepadTextInputLineModeMultipleLines;
+    } else {
+        line_mode = EGamepadTextInputLineMode_k_EGamepadTextInputLineModeSingleLine;
+    }
+    videodata->oOverlay->ShowKeyboardForOverlay(videodata->overlayID,
+           input_mode, line_mode,
+           EKeyboardFlags_KeyboardFlag_Minimal, "Virtual Keyboard", 128, "", 0);
+    videodata->bKeyboardShown = true;
+}
+
+static void OPENVR_HideScreenKeyboard(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    videodata->oOverlay->HideKeyboard();
+    videodata->bKeyboardShown = false;
+}
+
+static bool OPENVR_IsScreenKeyboardShown(SDL_VideoDevice *_this, SDL_Window *window)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    return videodata->bKeyboardShown;
+}
+
+static SDL_Cursor *OPENVR_CreateCursor(SDL_Surface * surface, int hot_x, int hot_y)
+{
+    SDL_Cursor *result = SDL_calloc(1, sizeof(SDL_Cursor));
+    if (!result) {
+        return NULL;
+    }
+
+    uint32_t * pixels = ImageSDLToOpenVRGL(surface, false);
+    SDL_CursorData *ovrc = (SDL_CursorData *)SDL_calloc(1, sizeof(*ovrc));
+    if (!ovrc) {
+        SDL_free(result);
+        return NULL;
+    }
+    result->internal = ovrc;
+
+    ov_glGenTextures(1, &ovrc->texture_id_handle);
+    ov_glBindTexture(GL_TEXTURE_2D, ovrc->texture_id_handle);
+    ov_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, surface->w, surface->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+    SDL_free(pixels);
+    ov_glBindTexture(GL_TEXTURE_2D, 0);
+
+    ovrc->hot_x = hot_x;
+    ovrc->hot_y = hot_y;
+    ovrc->w = surface->w;
+    ovrc->h = surface->h;
+
+    return result;
+}
+
+static bool OPENVR_ShowCursor(SDL_Cursor * cursor)
+{
+    SDL_CursorData * ovrc;
+    EVROverlayError e;
+    Texture_t texture;
+    HmdVector2_t hotspot;
+    VRTextureBounds_t tb;
+
+    if (!cursor) {
+        global_openvr_driver->oOverlay->SetOverlayFlag(global_openvr_driver->overlayID, VROverlayFlags_HideLaserIntersection, true);
+        e = global_openvr_driver->oOverlay->SetOverlayCursor(global_openvr_driver->overlayID, k_ulOverlayHandleInvalid);
+        if (e != EVROverlayError_VROverlayError_None) {
+            return OPENVR_SetOverlayError(e);
+        }
+        return true;
+    }
+
+    global_openvr_driver->oOverlay->SetOverlayFlag(global_openvr_driver->overlayID, VROverlayFlags_HideLaserIntersection, false);
+
+    ovrc = cursor->internal;
+
+    if (!ovrc) {
+        // Sometimes at boot there is a race condition where this is not ready.
+        return true;
+    }
+
+    hotspot.v[0] = (float)ovrc->hot_x / (float)ovrc->w;
+    hotspot.v[1] = (float)ovrc->hot_y / (float)ovrc->h;
+
+    texture.handle = (void*)(intptr_t)(ovrc->texture_id_handle);
+    texture.eType = ETextureType_TextureType_OpenGL;
+    texture.eColorSpace = EColorSpace_ColorSpace_Auto;
+
+    tb.uMin = 0;
+    tb.uMax = 1;
+    tb.vMin = 1;
+    tb.vMax = 0;
+
+    e = global_openvr_driver->oOverlay->SetOverlayTextureBounds(global_openvr_driver->cursorID, &tb);
+    if (e != EVROverlayError_VROverlayError_None) {
+        return OPENVR_SetOverlayError(e);
+    }
+
+    e = global_openvr_driver->oOverlay->SetOverlayTransformCursor(global_openvr_driver->cursorID, &hotspot);
+    if (e != EVROverlayError_VROverlayError_None) {
+        return OPENVR_SetOverlayError(e);
+    }
+
+    e = global_openvr_driver->oOverlay->SetOverlayTexture(global_openvr_driver->cursorID, &texture);
+    if (e != EVROverlayError_VROverlayError_None) {
+        return OPENVR_SetOverlayError(e);
+    }
+
+    e = global_openvr_driver->oOverlay->SetOverlayCursor(global_openvr_driver->overlayID, global_openvr_driver->cursorID);
+    if (e != EVROverlayError_VROverlayError_None) {
+        return OPENVR_SetOverlayError(e);
+    }
+
+    return true;
+}
+
+static void OPENVR_FreeCursor(SDL_Cursor * cursor)
+{
+    if (cursor) {
+        SDL_CursorData *ovrc = cursor->internal;
+        if (ovrc) {
+            ov_glDeleteTextures(1, &ovrc->texture_id_handle);
+            SDL_free(ovrc);
+        }
+        SDL_free(cursor);
+    }
+}
+
+
+static bool OPENVR_SetWindowIcon(SDL_VideoDevice *_this, SDL_Window * window, SDL_Surface * icon)
+{
+    if (!global_openvr_driver) {
+        return SDL_SetError("OpenVR Overlay not initialized");
+    }
+
+    unsigned texture_id_handle;
+    EVROverlayError e;
+    Texture_t texture;
+    uint32_t * pixels;
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    if (videodata->bIconOverridden) {
+        return SDL_SetError("OpenVR Icon is overridden.");
+    }
+
+    pixels = ImageSDLToOpenVRGL(icon, true);
+
+    ov_glGenTextures(1, &texture_id_handle);
+    ov_glBindTexture(GL_TEXTURE_2D, texture_id_handle);
+    ov_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, icon->w, icon->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+    SDL_free(pixels);
+    ov_glBindTexture(GL_TEXTURE_2D, 0);
+
+    texture.handle = (void*)(intptr_t)(texture_id_handle);
+    texture.eType = ETextureType_TextureType_OpenGL;
+    texture.eColorSpace = EColorSpace_ColorSpace_Auto;
+
+    e = global_openvr_driver->oOverlay->SetOverlayTexture(videodata->thumbID, &texture);
+    if (e != EVROverlayError_VROverlayError_None) {
+        return OPENVR_SetOverlayError(e);
+    }
+    return true;
+}
+
+static bool OPENVR_ShowMessageBox(SDL_VideoDevice *_this,const SDL_MessageBoxData *messageboxdata, int *buttonid)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    char empty = 0;
+    char * message = SDL_strdup(messageboxdata->message?messageboxdata->message:"");
+    char * title = SDL_strdup(messageboxdata->message?messageboxdata->message:"");
+    char * ok = SDL_strdup("Ok");
+    videodata->oOverlay->ShowMessageOverlay(message, title, ok, &empty, &empty, &empty);
+    SDL_free(ok);
+    SDL_free(title);
+    SDL_free(message);
+    return true;
+}
+
+static void InitializeMouseFunctions()
+{
+    SDL_Mouse *mouse = SDL_GetMouse();
+    mouse->CreateCursor = OPENVR_CreateCursor;
+    mouse->ShowCursor = OPENVR_ShowCursor;
+    mouse->FreeCursor = OPENVR_FreeCursor;
+}
+
+static void OPENVR_PumpEvents(SDL_VideoDevice *_this)
+{
+    SDL_VideoData *videodata = (SDL_VideoData *)_this->internal;
+    struct VREvent_t nEvent;
+    if (videodata->overlayID) {
+        while (videodata->oOverlay->PollNextOverlayEvent(videodata->overlayID, &nEvent, sizeof(nEvent))) {
+            switch (nEvent.eventType) {
+            case EVREventType_VREvent_ButtonPress:
+            case EVREventType_VREvent_ButtonUnpress:
+                break;
+            case EVREventType_VREvent_MouseMove:
+                OPENVR_HandleMouse(nEvent.data.mouse.x, videodata->targh - nEvent.data.mouse.y, nEvent.data.mouse.button, 2);
+                break;
+            case EVREventType_VREvent_MouseButtonDown:
+                OPENVR_HandleMouse(nEvent.data.mouse.x, videodata->targh - nEvent.data.mouse.y, 0, 1);
+                break;
+            case EVREventType_VREvent_MouseButtonUp:
+                OPENVR_HandleMouse(nEvent.data.mouse.x, videodata->targh - nEvent.data.mouse.y, 0, 0);
+                break;
+            case EVREventType_VREvent_KeyboardCharInput:
+                SDL_SendKeyboardUnicodeKey(SDL_GetTicksNS(), nEvent.data.keyboard.cNewInput[0]);
+                break;
+            case EVREventType_VREvent_OverlayShown:
+                SDL_SetKeyboardFocus(videodata->window);
+                SDL_SendWindowEvent(videodata->window, SDL_EVENT_WINDOW_RESTORED, 0, 0);
+                SDL_SendWindowEvent(videodata->window, SDL_EVENT_WINDOW_SHOWN, 0, 0);
+                break;
+            case EVREventType_VREvent_OverlayHidden:
+                SDL_SendWindowEvent(videodata->window, SDL_EVENT_WINDOW_HIDDEN, 0, 0);
+                SDL_SendWindowEvent(videodata->window, SDL_EVENT_WINDOW_MINIMIZED, 0, 0);
+                SDL_SetKeyboardFocus(NULL);
+                break;
+            case EVREventType_VREvent_OverlayClosed:
+            case EVREventType_VREvent_Quit:
+                SDL_Quit();
+                break;
+            }
+        }
+    }
+}
+
+
+static SDL_VideoDevice *OPENVR_CreateDevice(void)
+{
+    SDL_VideoDevice *device;
+    SDL_VideoData *data;
+
+#ifdef SDL_PLATFORM_WINDOWS
+    SDL_RegisterApp(NULL, 0, NULL);
+#endif
+
+    // Initialize all variables that we clean on shutdown
+    device = (SDL_VideoDevice *)SDL_calloc(1, sizeof(SDL_VideoDevice));
+    if (device) {
+        data = (struct SDL_VideoData *)SDL_calloc(1, sizeof(SDL_VideoData));
+    } else {
+        data = NULL;
+    }
+    if (!data) {
+        SDL_free(device);
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    {
+        const char * hint = SDL_GetHint(SDL_HINT_OPENVR_LIBRARY);
+        if (hint)
+            data->openVRLIB = SDL_LoadObject(hint);
+#ifdef SDL_PLATFORM_WINDOWS
+        if (!data->openVRLIB)
+            data->openVRLIB = SDL_LoadObject("openvr_api.dll");
+#else
+        if (!data->openVRLIB)
+            data->openVRLIB = SDL_LoadObject("openvr_api.so");
+#endif
+    }
+
+    if (data->openVRLIB) {
+        data->FN_VR_InitInternal = (intptr_t(*)(EVRInitError * peError, EVRApplicationType eType))SDL_LoadFunction(data->openVRLIB, "VR_InitInternal");
+        data->FN_VR_GetVRInitErrorAsEnglishDescription = (const char *(*)(EVRInitError error))SDL_LoadFunction(data->openVRLIB, "VR_GetVRInitErrorAsEnglishDescription");
+        data->FN_VR_GetGenericInterface = (intptr_t (*)(const char *pchInterfaceVersion, EVRInitError * peError))SDL_LoadFunction(data->openVRLIB, "VR_GetGenericInterface");
+    } else {
+        SDL_SetError("Could not open OpenVR API Library");
+        return NULL;
+    }
+
+    if (data->FN_VR_InitInternal) {
+        char fnname[128];
+        EVRInitError e;
+        data->vrtoken = data->FN_VR_InitInternal(&e, EVRApplicationType_VRApplication_Overlay);
+        if (!data->vrtoken) {
+            const char *err = "Can't get english description";
+            if (data->FN_VR_GetVRInitErrorAsEnglishDescription != NULL)
+                err = data->FN_VR_GetVRInitErrorAsEnglishDescription(e);
+            SDL_SetError("Could not generate OpenVR Context (%s)", err);
+            return NULL;
+        }
+
+        SDL_snprintf(fnname, 127, "FnTable:%s", IVRSystem_Version);
+        data->oSystem = (struct VR_IVRSystem_FnTable *)data->FN_VR_GetGenericInterface(fnname, &e);
+        SDL_snprintf(fnname, 127, "FnTable:%s", IVROverlay_Version);
+        data->oOverlay = (struct VR_IVROverlay_FnTable *)data->FN_VR_GetGenericInterface(fnname, &e);
+        SDL_snprintf(fnname, 127, "FnTable:%s", IVRInput_Version);
+        data->oInput = (struct VR_IVRInput_FnTable *)data->FN_VR_GetGenericInterface(fnname, &e);
+
+        if (!data->oOverlay || !data->oSystem) {
+            SDL_SetError("Could not get interfaces for the OpenVR System (%s), Overlay (%s) and Input (%s) versions", IVRSystem_Version, IVROverlay_Version, IVRInput_Version);
+        }
+    }
+
+    {
+        const char * hint = SDL_GetHint("SDL_OPENVR_INPUT_PROFILE");
+        char * loadpath = 0;
+        EVRInputError err;
+
+        if (hint) {
+            SDL_asprintf(&loadpath, "%s", hint);
+        } else {
+            const char *basepath = SDL_GetBasePath();
+            SDL_asprintf(&loadpath, "%ssdloverlay_actions.json", basepath);
+        }
+
+        if (!loadpath) {
+            return NULL;
+        }
+
+        err = data->oInput->SetActionManifestPath(loadpath);
+        #ifdef DEBUG_OPENVR
+        SDL_Log("Loaded action manifest at %s (%d)", loadpath, err);
+        #endif
+        SDL_free(loadpath);
+        if (err != EVRInputError_VRInputError_None) {
+            // I know we don't normally log, but this _really_ should be percolated
+            // up as far as we can.
+            SDL_Log("Could not load action manifest path");
+            // If we didn't have a hint, this is a soft fail.
+            // If we did have the hint, then it's a hard fail.
+            if (hint) {
+                return NULL;
+            }
+        }
+        else
+        {
+            int e = OPENVR_SetupJoystckBasedOnLoadedActionManifest(data);
+            if(e) {
+                return NULL;
+            }
+        }
+    }
+
+    device->internal = data;
+    device->wakeup_lock = SDL_CreateMutex();
+
+    // Setup amount of available displays
+    device->num_displays = 0;
+
+    // Set device free function
+    device->free = OPENVR_Destroy;
+
+    // Setup all functions which we can handle
+    device->VideoInit = OPENVR_VideoInit;
+    device->VideoQuit = OPENVR_VideoQuit;
+    device->SetDisplayMode = OPENVR_SetDisplayMode;
+    device->CreateSDLWindow = OPENVR_CreateWindow;
+    device->SetWindowTitle = OPENVR_SetWindowTitle;
+    device->SetWindowSize = OPENVR_SetWindowSize;
+    device->GetWindowSizeInPixels = OPENVR_GetWindowSizeInPixels;
+    device->ShowWindow = OPENVR_ShowWindow;
+    device->HideWindow = OPENVR_HideWindow;
+    device->DestroyWindow = OPENVR_DestroyWindow;
+    device->ShowMessageBox = OPENVR_ShowMessageBox;
+
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+#ifdef SDL_VIDEO_OPENGL_WGL
+    device->GL_LoadLibrary = OPENVR_GL_LoadLibrary;
+    device->GL_GetProcAddress = OPENVR_GL_GetProcAddress;
+    device->GL_UnloadLibrary = OPENVR_GL_UnloadLibrary;
+    device->GL_CreateContext = OPENVR_GL_CreateContext;
+    device->GL_MakeCurrent = OPENVR_GL_MakeCurrent;
+    device->GL_SetSwapInterval = OPENVR_GL_SetSwapInterval;
+    device->GL_GetSwapInterval = OPENVR_GL_GetSwapInterval;
+    device->GL_SwapWindow = OPENVR_GL_SwapWindow;
+    device->GL_DestroyContext = OPENVR_GL_DestroyContext;
+#elif SDL_VIDEO_OPENGL_EGL
+    device->GL_LoadLibrary = WIN_GLES_LoadLibrary;
+    device->GL_GetProcAddress = WIN_GLES_GetProcAddress;
+    device->GL_UnloadLibrary = WIN_GLES_UnloadLibrary;
+    device->GL_CreateContext = WIN_GLES_CreateContext;
+    device->GL_MakeCurrent = WIN_GLES_MakeCurrent;
+    device->GL_SetSwapInterval = WIN_GLES_SetSwapInterval;
+    device->GL_GetSwapInterval = WIN_GLES_GetSwapInterval;
+    device->GL_SwapWindow = WIN_GLES_SwapWindow;
+    device->GL_DestroyContext = WIN_GLES_DestroyContext;
+#endif
+#else
+    device->GL_LoadLibrary = OVR_EGL_LoadLibrary;
+    device->GL_GetProcAddress = OVR_EGL_GetProcAddress;
+    device->GL_UnloadLibrary = OVR_EGL_UnloadLibrary;
+    device->GL_CreateContext = OVR_EGL_CreateContext;
+    device->GL_MakeCurrent = OVR_EGL_MakeCurrent;
+    device->GL_SetSwapInterval = OVR_EGL_SetSwapInterval;
+    device->GL_GetSwapInterval = OVR_EGL_GetSwapInterval;
+    device->GL_DestroyContext = OVR_EGL_DestroyContext;
+    device->GL_SwapWindow = OPENVR_GL_SwapWindow;
+#endif
+
+#if defined(SDL_VIDEO_VULKAN) && defined(SDL_VIDEO_DRIVER_WINDOWS)
+    device->Vulkan_LoadLibrary = WIN_Vulkan_LoadLibrary;
+    device->Vulkan_UnloadLibrary = WIN_Vulkan_UnloadLibrary;
+    device->Vulkan_GetInstanceExtensions = WIN_Vulkan_GetInstanceExtensions;
+    device->Vulkan_CreateSurface = WIN_Vulkan_CreateSurface;
+#else
+    device->Vulkan_LoadLibrary = 0;
+    device->Vulkan_UnloadLibrary = 0;
+    device->Vulkan_GetInstanceExtensions = 0;
+    device->Vulkan_CreateSurface = 0;
+#endif
+
+    device->PumpEvents = OPENVR_PumpEvents;
+    device->VideoInit = OPENVR_VideoInit;
+    device->VideoQuit = OPENVR_VideoQuit;
+
+    device->HasScreenKeyboardSupport = OPENVR_HasScreenKeyboardSupport;
+    device->ShowScreenKeyboard = OPENVR_ShowScreenKeyboard;
+    device->HideScreenKeyboard = OPENVR_HideScreenKeyboard;
+    device->IsScreenKeyboardShown = OPENVR_IsScreenKeyboardShown;
+    device->SetWindowIcon = OPENVR_SetWindowIcon;
+
+    return device;
+}
+
+VideoBootStrap OPENVR_bootstrap = {
+    "openvr", "SDL OpenVR video driver", OPENVR_CreateDevice
+};
+
+#endif // SDL_VIDEO_DRIVER_WINDOWS
+

src/video/openvr/SDL_openvrvideo.h

@@ -0,0 +1,109 @@
+#ifndef _SDL_OPENVRVIDEO_H
+#define _SDL_OPENVRVIDEO_H
+
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+#ifdef EXTERN_C
+#undef EXTERN_C
+#endif
+#define GL_APIENTRY
+#define GL_APICALL
+#endif
+
+// OpenVR has a LOT of unused variables that GCC will freak out on.
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+#include "openvr_capi.h"
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+
+#include <stdint.h>
+
+#ifndef SDL_VIDEO_DRIVER_WINDOWS
+
+#include <GLES3/gl3.h>
+#include <GLES3/gl32.h>
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <GLES2/gl2ext.h>
+
+#endif
+
+
+typedef struct SDL_WindowData
+{
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+    SDL_Window *window;
+    HWND hwnd;
+    HWND parent;
+    HDC hdc;
+    HDC mdc;
+#else
+    int dummy;
+#endif
+} SDL_WindowData;
+
+typedef struct SDL_VideoData {
+    void * openVRLIB;
+    intptr_t vrtoken;
+    intptr_t (*FN_VR_InitInternal)( EVRInitError *peError, EVRApplicationType eType );
+    const char *(*FN_VR_GetVRInitErrorAsEnglishDescription)( EVRInitError error );
+    intptr_t (*FN_VR_GetGenericInterface)( const char *pchInterfaceVersion, EVRInitError *peError );
+
+    int is_buffer_rendering;
+
+    unsigned int overlaytexture;
+
+    unsigned int fbo, rbo;
+
+    int saved_texture_state;
+
+    struct VR_IVRSystem_FnTable *oSystem;
+    struct VR_IVROverlay_FnTable *oOverlay;
+	struct VR_IVRInput_FnTable * oInput;
+	VROverlayHandle_t overlayID, thumbID, cursorID;
+	
+	char * sOverlayName;
+
+	VRActionSetHandle_t input_action_set;
+	VRActionHandle_t * input_action_handles_buttons;
+	int input_action_handles_buttons_count;
+	VRActionHandle_t * input_action_handles_axes;
+	int input_action_handles_axes_count;
+	VRActionHandle_t input_action_handles_haptics[2];
+
+    bool bKeyboardShown;
+    bool bHasShownOverlay;
+    int targw, targh;
+    int last_targw, last_targh;
+    int swap_interval;
+
+    bool bDidCreateOverlay;
+	bool renderdoc_debugmarker_frame_end;
+	bool bIconOverridden;
+	
+	SDL_Window * window;
+	
+	SDL_Joystick *virtual_joystick;
+#ifdef SDL_VIDEO_DRIVER_WINDOWS
+    HDC hdc;
+    HGLRC hglrc;
+#else
+    EGLDisplay eglDpy;
+    EGLContext eglCtx;
+#endif
+} SDL_VideoData;
+
+
+typedef struct SDL_DisplayData
+{
+    int dummy;
+} SDL_DisplayData;
+
+
+#endif

src/video/openvr/openvr_capi.h

@@ -0,0 +1,3182 @@
+//======= Copyright (c) Valve Corporation, All rights reserved. ===============
+//
+// Purpose: Header for flatted SteamAPI. Use this for binding to other languages.
+// This file is auto-generated, do not edit it.
+//
+//=============================================================================
+
+#ifndef __OPENVR_API_FLAT_H__
+#define __OPENVR_API_FLAT_H__
+#if defined( _WIN32 ) || defined( __clang__ )
+#pragma once
+#endif
+
+#ifdef __cplusplus
+#define EXTERN_C extern "C"
+#else
+#define EXTERN_C
+#endif
+
+#if defined( _WIN32 )
+#define OPENVR_FNTABLE_CALLTYPE __stdcall
+#else
+#define OPENVR_FNTABLE_CALLTYPE 
+#endif
+
+// OPENVR API export macro
+#if defined( _WIN32 ) && !defined( _X360 )
+	#if defined( OPENVR_API_EXPORTS )
+	#define S_API EXTERN_C __declspec( dllexport )
+	#elif defined( OPENVR_API_NODLL )
+	#define S_API EXTERN_C
+	#else
+	#define S_API extern "C" __declspec( dllimport ) 
+	#endif // OPENVR_API_EXPORTS
+#elif defined( __GNUC__ )
+	#if defined( OPENVR_API_EXPORTS )
+	#define S_API EXTERN_C __attribute__ ((visibility("default")))
+	#else
+	#define S_API EXTERN_C
+	#endif // OPENVR_API_EXPORTS
+#else // !WIN32
+	#if defined( OPENVR_API_EXPORTS )
+	#define S_API EXTERN_C
+	#else
+	#define S_API EXTERN_C
+	#endif // OPENVR_API_EXPORTS
+#endif
+
+#include <stdint.h>
+
+#if defined( __WIN32 )
+typedef char bool;
+#else
+#include <stdbool.h>
+#endif
+
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+typedef uint64_t PathHandle_t;
+
+
+// OpenVR Constants
+
+static const unsigned long k_nDriverNone = 4294967295;
+static const unsigned long k_unMaxDriverDebugResponseSize = 32768;
+static const unsigned long k_unTrackedDeviceIndex_Hmd = 0;
+static const unsigned long k_unMaxTrackedDeviceCount = 64;
+static const unsigned long k_unTrackedDeviceIndexOther = 4294967294;
+static const unsigned long k_unTrackedDeviceIndexInvalid = 4294967295;
+static const unsigned long long k_ulInvalidPropertyContainer = 0;
+static const unsigned long k_unInvalidPropertyTag = 0;
+static const unsigned long long k_ulInvalidDriverHandle = 0;
+static const unsigned long k_unFloatPropertyTag = 1;
+static const unsigned long k_unInt32PropertyTag = 2;
+static const unsigned long k_unUint64PropertyTag = 3;
+static const unsigned long k_unBoolPropertyTag = 4;
+static const unsigned long k_unStringPropertyTag = 5;
+static const unsigned long k_unErrorPropertyTag = 6;
+static const unsigned long k_unDoublePropertyTag = 7;
+static const unsigned long k_unHmdMatrix34PropertyTag = 20;
+static const unsigned long k_unHmdMatrix44PropertyTag = 21;
+static const unsigned long k_unHmdVector3PropertyTag = 22;
+static const unsigned long k_unHmdVector4PropertyTag = 23;
+static const unsigned long k_unHmdVector2PropertyTag = 24;
+static const unsigned long k_unHmdQuadPropertyTag = 25;
+static const unsigned long k_unHiddenAreaPropertyTag = 30;
+static const unsigned long k_unPathHandleInfoTag = 31;
+static const unsigned long k_unActionPropertyTag = 32;
+static const unsigned long k_unInputValuePropertyTag = 33;
+static const unsigned long k_unWildcardPropertyTag = 34;
+static const unsigned long k_unHapticVibrationPropertyTag = 35;
+static const unsigned long k_unSkeletonPropertyTag = 36;
+static const unsigned long k_unSpatialAnchorPosePropertyTag = 40;
+static const unsigned long k_unJsonPropertyTag = 41;
+static const unsigned long k_unActiveActionSetPropertyTag = 42;
+static const unsigned long k_unOpenVRInternalReserved_Start = 1000;
+static const unsigned long k_unOpenVRInternalReserved_End = 10000;
+static const unsigned long k_unMaxPropertyStringSize = 32768;
+static const unsigned long long k_ulInvalidActionHandle = 0;
+static const unsigned long long k_ulInvalidActionSetHandle = 0;
+static const unsigned long long k_ulInvalidInputValueHandle = 0;
+static const unsigned long k_unControllerStateAxisCount = 5;
+static const unsigned long long k_ulOverlayHandleInvalid = 0;
+static const unsigned long k_unMaxDistortionFunctionParameters = 8;
+static const unsigned long k_unScreenshotHandleInvalid = 0;
+static const char * IVRSystem_Version = "IVRSystem_022";
+static const char * IVRExtendedDisplay_Version = "IVRExtendedDisplay_001";
+static const char * IVRTrackedCamera_Version = "IVRTrackedCamera_006";
+static const unsigned long k_unMaxApplicationKeyLength = 128;
+static const char * k_pch_MimeType_HomeApp = "vr/home";
+static const char * k_pch_MimeType_GameTheater = "vr/game_theater";
+static const char * IVRApplications_Version = "IVRApplications_007";
+static const char * IVRChaperone_Version = "IVRChaperone_004";
+static const char * IVRChaperoneSetup_Version = "IVRChaperoneSetup_006";
+static const char * IVRCompositor_Version = "IVRCompositor_027";
+static const unsigned long k_unVROverlayMaxKeyLength = 128;
+static const unsigned long k_unVROverlayMaxNameLength = 128;
+static const unsigned long k_unMaxOverlayCount = 128;
+static const unsigned long k_unMaxOverlayIntersectionMaskPrimitivesCount = 32;
+static const char * IVROverlay_Version = "IVROverlay_026";
+static const char * IVROverlayView_Version = "IVROverlayView_003";
+static const unsigned long k_unHeadsetViewMaxWidth = 3840;
+static const unsigned long k_unHeadsetViewMaxHeight = 2160;
+static const char * k_pchHeadsetViewOverlayKey = "system.HeadsetView";
+static const char * IVRHeadsetView_Version = "IVRHeadsetView_001";
+static const char * k_pch_Controller_Component_GDC2015 = "gdc2015";
+static const char * k_pch_Controller_Component_Base = "base";
+static const char * k_pch_Controller_Component_Tip = "tip";
+static const char * k_pch_Controller_Component_OpenXR_Aim = "openxr_aim";
+static const char * k_pch_Controller_Component_HandGrip = "handgrip";
+static const char * k_pch_Controller_Component_OpenXR_Grip = "openxr_grip";
+static const char * k_pch_Controller_Component_OpenXR_HandModel = "openxr_handmodel";
+static const char * k_pch_Controller_Component_Status = "status";
+static const char * IVRRenderModels_Version = "IVRRenderModels_006";
+static const unsigned long k_unNotificationTextMaxSize = 256;
+static const char * IVRNotifications_Version = "IVRNotifications_002";
+static const unsigned long k_unMaxSettingsKeyLength = 128;
+static const char * IVRSettings_Version = "IVRSettings_003";
+static const char * k_pch_SteamVR_Section = "steamvr";
+static const char * k_pch_SteamVR_RequireHmd_String = "requireHmd";
+static const char * k_pch_SteamVR_ForcedDriverKey_String = "forcedDriver";
+static const char * k_pch_SteamVR_ForcedHmdKey_String = "forcedHmd";
+static const char * k_pch_SteamVR_DisplayDebug_Bool = "displayDebug";
+static const char * k_pch_SteamVR_DebugProcessPipe_String = "debugProcessPipe";
+static const char * k_pch_SteamVR_DisplayDebugX_Int32 = "displayDebugX";
+static const char * k_pch_SteamVR_DisplayDebugY_Int32 = "displayDebugY";
+static const char * k_pch_SteamVR_SendSystemButtonToAllApps_Bool = "sendSystemButtonToAllApps";
+static const char * k_pch_SteamVR_LogLevel_Int32 = "loglevel";
+static const char * k_pch_SteamVR_IPD_Float = "ipd";
+static const char * k_pch_SteamVR_Background_String = "background";
+static const char * k_pch_SteamVR_BackgroundUseDomeProjection_Bool = "backgroundUseDomeProjection";
+static const char * k_pch_SteamVR_BackgroundCameraHeight_Float = "backgroundCameraHeight";
+static const char * k_pch_SteamVR_BackgroundDomeRadius_Float = "backgroundDomeRadius";
+static const char * k_pch_SteamVR_GridColor_String = "gridColor";
+static const char * k_pch_SteamVR_PlayAreaColor_String = "playAreaColor";
+static const char * k_pch_SteamVR_TrackingLossColor_String = "trackingLossColor";
+static const char * k_pch_SteamVR_ShowStage_Bool = "showStage";
+static const char * k_pch_SteamVR_DrawTrackingReferences_Bool = "drawTrackingReferences";
+static const char * k_pch_SteamVR_ActivateMultipleDrivers_Bool = "activateMultipleDrivers";
+static const char * k_pch_SteamVR_UsingSpeakers_Bool = "usingSpeakers";
+static const char * k_pch_SteamVR_SpeakersForwardYawOffsetDegrees_Float = "speakersForwardYawOffsetDegrees";
+static const char * k_pch_SteamVR_BaseStationPowerManagement_Int32 = "basestationPowerManagement";
+static const char * k_pch_SteamVR_ShowBaseStationPowerManagementTip_Int32 = "ShowBaseStationPowerManagementTip";
+static const char * k_pch_SteamVR_NeverKillProcesses_Bool = "neverKillProcesses";
+static const char * k_pch_SteamVR_SupersampleScale_Float = "supersampleScale";
+static const char * k_pch_SteamVR_MaxRecommendedResolution_Int32 = "maxRecommendedResolution";
+static const char * k_pch_SteamVR_MotionSmoothing_Bool = "motionSmoothing";
+static const char * k_pch_SteamVR_MotionSmoothingOverride_Int32 = "motionSmoothingOverride";
+static const char * k_pch_SteamVR_FramesToThrottle_Int32 = "framesToThrottle";
+static const char * k_pch_SteamVR_AdditionalFramesToPredict_Int32 = "additionalFramesToPredict";
+static const char * k_pch_SteamVR_WorldScale_Float = "worldScale";
+static const char * k_pch_SteamVR_FovScale_Int32 = "fovScale";
+static const char * k_pch_SteamVR_DisableAsyncReprojection_Bool = "disableAsync";
+static const char * k_pch_SteamVR_ForceFadeOnBadTracking_Bool = "forceFadeOnBadTracking";
+static const char * k_pch_SteamVR_DefaultMirrorView_Int32 = "mirrorView";
+static const char * k_pch_SteamVR_ShowLegacyMirrorView_Bool = "showLegacyMirrorView";
+static const char * k_pch_SteamVR_MirrorViewVisibility_Bool = "showMirrorView";
+static const char * k_pch_SteamVR_MirrorViewDisplayMode_Int32 = "mirrorViewDisplayMode";
+static const char * k_pch_SteamVR_MirrorViewEye_Int32 = "mirrorViewEye";
+static const char * k_pch_SteamVR_MirrorViewGeometry_String = "mirrorViewGeometry";
+static const char * k_pch_SteamVR_MirrorViewGeometryMaximized_String = "mirrorViewGeometryMaximized";
+static const char * k_pch_SteamVR_PerfGraphVisibility_Bool = "showPerfGraph";
+static const char * k_pch_SteamVR_StartMonitorFromAppLaunch = "startMonitorFromAppLaunch";
+static const char * k_pch_SteamVR_StartCompositorFromAppLaunch_Bool = "startCompositorFromAppLaunch";
+static const char * k_pch_SteamVR_StartDashboardFromAppLaunch_Bool = "startDashboardFromAppLaunch";
+static const char * k_pch_SteamVR_StartOverlayAppsFromDashboard_Bool = "startOverlayAppsFromDashboard";
+static const char * k_pch_SteamVR_EnableHomeApp = "enableHomeApp";
+static const char * k_pch_SteamVR_CycleBackgroundImageTimeSec_Int32 = "CycleBackgroundImageTimeSec";
+static const char * k_pch_SteamVR_RetailDemo_Bool = "retailDemo";
+static const char * k_pch_SteamVR_IpdOffset_Float = "ipdOffset";
+static const char * k_pch_SteamVR_AllowSupersampleFiltering_Bool = "allowSupersampleFiltering";
+static const char * k_pch_SteamVR_SupersampleManualOverride_Bool = "supersampleManualOverride";
+static const char * k_pch_SteamVR_EnableLinuxVulkanAsync_Bool = "enableLinuxVulkanAsync";
+static const char * k_pch_SteamVR_AllowDisplayLockedMode_Bool = "allowDisplayLockedMode";
+static const char * k_pch_SteamVR_HaveStartedTutorialForNativeChaperoneDriver_Bool = "haveStartedTutorialForNativeChaperoneDriver";
+static const char * k_pch_SteamVR_ForceWindows32bitVRMonitor = "forceWindows32BitVRMonitor";
+static const char * k_pch_SteamVR_DebugInputBinding = "debugInputBinding";
+static const char * k_pch_SteamVR_DoNotFadeToGrid = "doNotFadeToGrid";
+static const char * k_pch_SteamVR_RenderCameraMode = "renderCameraMode";
+static const char * k_pch_SteamVR_EnableSharedResourceJournaling = "enableSharedResourceJournaling";
+static const char * k_pch_SteamVR_EnableSafeMode = "enableSafeMode";
+static const char * k_pch_SteamVR_PreferredRefreshRate = "preferredRefreshRate";
+static const char * k_pch_SteamVR_LastVersionNotice = "lastVersionNotice";
+static const char * k_pch_SteamVR_LastVersionNoticeDate = "lastVersionNoticeDate";
+static const char * k_pch_SteamVR_HmdDisplayColorGainR_Float = "hmdDisplayColorGainR";
+static const char * k_pch_SteamVR_HmdDisplayColorGainG_Float = "hmdDisplayColorGainG";
+static const char * k_pch_SteamVR_HmdDisplayColorGainB_Float = "hmdDisplayColorGainB";
+static const char * k_pch_SteamVR_CustomIconStyle_String = "customIconStyle";
+static const char * k_pch_SteamVR_CustomOffIconStyle_String = "customOffIconStyle";
+static const char * k_pch_SteamVR_CustomIconForceUpdate_String = "customIconForceUpdate";
+static const char * k_pch_SteamVR_AllowGlobalActionSetPriority = "globalActionSetPriority";
+static const char * k_pch_SteamVR_OverlayRenderQuality = "overlayRenderQuality_2";
+static const char * k_pch_SteamVR_BlockOculusSDKOnOpenVRLaunchOption_Bool = "blockOculusSDKOnOpenVRLaunchOption";
+static const char * k_pch_SteamVR_BlockOculusSDKOnAllLaunches_Bool = "blockOculusSDKOnAllLaunches";
+static const char * k_pch_SteamVR_HDCPLegacyCompatibility_Bool = "hdcp14legacyCompatibility";
+static const char * k_pch_SteamVR_DisplayPortTrainingMode_Int = "displayPortTrainingMode";
+static const char * k_pch_SteamVR_UsePrism_Bool = "usePrism";
+static const char * k_pch_DirectMode_Section = "direct_mode";
+static const char * k_pch_DirectMode_Enable_Bool = "enable";
+static const char * k_pch_DirectMode_Count_Int32 = "count";
+static const char * k_pch_DirectMode_EdidVid_Int32 = "edidVid";
+static const char * k_pch_DirectMode_EdidPid_Int32 = "edidPid";
+static const char * k_pch_Lighthouse_Section = "driver_lighthouse";
+static const char * k_pch_Lighthouse_DisableIMU_Bool = "disableimu";
+static const char * k_pch_Lighthouse_DisableIMUExceptHMD_Bool = "disableimuexcepthmd";
+static const char * k_pch_Lighthouse_UseDisambiguation_String = "usedisambiguation";
+static const char * k_pch_Lighthouse_DisambiguationDebug_Int32 = "disambiguationdebug";
+static const char * k_pch_Lighthouse_PrimaryBasestation_Int32 = "primarybasestation";
+static const char * k_pch_Lighthouse_DBHistory_Bool = "dbhistory";
+static const char * k_pch_Lighthouse_EnableBluetooth_Bool = "enableBluetooth";
+static const char * k_pch_Lighthouse_PowerManagedBaseStations_String = "PowerManagedBaseStations";
+static const char * k_pch_Lighthouse_PowerManagedBaseStations2_String = "PowerManagedBaseStations2";
+static const char * k_pch_Lighthouse_InactivityTimeoutForBaseStations_Int32 = "InactivityTimeoutForBaseStations";
+static const char * k_pch_Lighthouse_EnableImuFallback_Bool = "enableImuFallback";
+static const char * k_pch_Null_Section = "driver_null";
+static const char * k_pch_Null_SerialNumber_String = "serialNumber";
+static const char * k_pch_Null_ModelNumber_String = "modelNumber";
+static const char * k_pch_Null_WindowX_Int32 = "windowX";
+static const char * k_pch_Null_WindowY_Int32 = "windowY";
+static const char * k_pch_Null_WindowWidth_Int32 = "windowWidth";
+static const char * k_pch_Null_WindowHeight_Int32 = "windowHeight";
+static const char * k_pch_Null_RenderWidth_Int32 = "renderWidth";
+static const char * k_pch_Null_RenderHeight_Int32 = "renderHeight";
+static const char * k_pch_Null_SecondsFromVsyncToPhotons_Float = "secondsFromVsyncToPhotons";
+static const char * k_pch_Null_DisplayFrequency_Float = "displayFrequency";
+static const char * k_pch_WindowsMR_Section = "driver_holographic";
+static const char * k_pch_UserInterface_Section = "userinterface";
+static const char * k_pch_UserInterface_StatusAlwaysOnTop_Bool = "StatusAlwaysOnTop";
+static const char * k_pch_UserInterface_MinimizeToTray_Bool = "MinimizeToTray";
+static const char * k_pch_UserInterface_HidePopupsWhenStatusMinimized_Bool = "HidePopupsWhenStatusMinimized";
+static const char * k_pch_UserInterface_Screenshots_Bool = "screenshots";
+static const char * k_pch_UserInterface_ScreenshotType_Int = "screenshotType";
+static const char * k_pch_Notifications_Section = "notifications";
+static const char * k_pch_Notifications_DoNotDisturb_Bool = "DoNotDisturb";
+static const char * k_pch_Keyboard_Section = "keyboard";
+static const char * k_pch_Keyboard_TutorialCompletions = "TutorialCompletions";
+static const char * k_pch_Keyboard_ScaleX = "ScaleX";
+static const char * k_pch_Keyboard_ScaleY = "ScaleY";
+static const char * k_pch_Keyboard_OffsetLeftX = "OffsetLeftX";
+static const char * k_pch_Keyboard_OffsetRightX = "OffsetRightX";
+static const char * k_pch_Keyboard_OffsetY = "OffsetY";
+static const char * k_pch_Keyboard_Smoothing = "Smoothing";
+static const char * k_pch_Perf_Section = "perfcheck";
+static const char * k_pch_Perf_PerfGraphInHMD_Bool = "perfGraphInHMD";
+static const char * k_pch_Perf_AllowTimingStore_Bool = "allowTimingStore";
+static const char * k_pch_Perf_SaveTimingsOnExit_Bool = "saveTimingsOnExit";
+static const char * k_pch_Perf_TestData_Float = "perfTestData";
+static const char * k_pch_Perf_GPUProfiling_Bool = "GPUProfiling";
+static const char * k_pch_CollisionBounds_Section = "collisionBounds";
+static const char * k_pch_CollisionBounds_Style_Int32 = "CollisionBoundsStyle";
+static const char * k_pch_CollisionBounds_GroundPerimeterOn_Bool = "CollisionBoundsGroundPerimeterOn";
+static const char * k_pch_CollisionBounds_CenterMarkerOn_Bool = "CollisionBoundsCenterMarkerOn";
+static const char * k_pch_CollisionBounds_PlaySpaceOn_Bool = "CollisionBoundsPlaySpaceOn";
+static const char * k_pch_CollisionBounds_FadeDistance_Float = "CollisionBoundsFadeDistance";
+static const char * k_pch_CollisionBounds_WallHeight_Float = "CollisionBoundsWallHeight";
+static const char * k_pch_CollisionBounds_ColorGammaR_Int32 = "CollisionBoundsColorGammaR";
+static const char * k_pch_CollisionBounds_ColorGammaG_Int32 = "CollisionBoundsColorGammaG";
+static const char * k_pch_CollisionBounds_ColorGammaB_Int32 = "CollisionBoundsColorGammaB";
+static const char * k_pch_CollisionBounds_ColorGammaA_Int32 = "CollisionBoundsColorGammaA";
+static const char * k_pch_CollisionBounds_EnableDriverImport = "enableDriverBoundsImport";
+static const char * k_pch_Camera_Section = "camera";
+static const char * k_pch_Camera_EnableCamera_Bool = "enableCamera";
+static const char * k_pch_Camera_ShowOnController_Bool = "showOnController";
+static const char * k_pch_Camera_EnableCameraForCollisionBounds_Bool = "enableCameraForCollisionBounds";
+static const char * k_pch_Camera_RoomView_Int32 = "roomView";
+static const char * k_pch_Camera_BoundsColorGammaR_Int32 = "cameraBoundsColorGammaR";
+static const char * k_pch_Camera_BoundsColorGammaG_Int32 = "cameraBoundsColorGammaG";
+static const char * k_pch_Camera_BoundsColorGammaB_Int32 = "cameraBoundsColorGammaB";
+static const char * k_pch_Camera_BoundsColorGammaA_Int32 = "cameraBoundsColorGammaA";
+static const char * k_pch_Camera_BoundsStrength_Int32 = "cameraBoundsStrength";
+static const char * k_pch_Camera_RoomViewStyle_Int32 = "roomViewStyle";
+static const char * k_pch_audio_Section = "audio";
+static const char * k_pch_audio_SetOsDefaultPlaybackDevice_Bool = "setOsDefaultPlaybackDevice";
+static const char * k_pch_audio_EnablePlaybackDeviceOverride_Bool = "enablePlaybackDeviceOverride";
+static const char * k_pch_audio_PlaybackDeviceOverride_String = "playbackDeviceOverride";
+static const char * k_pch_audio_PlaybackDeviceOverrideName_String = "playbackDeviceOverrideName";
+static const char * k_pch_audio_SetOsDefaultRecordingDevice_Bool = "setOsDefaultRecordingDevice";
+static const char * k_pch_audio_EnableRecordingDeviceOverride_Bool = "enableRecordingDeviceOverride";
+static const char * k_pch_audio_RecordingDeviceOverride_String = "recordingDeviceOverride";
+static const char * k_pch_audio_RecordingDeviceOverrideName_String = "recordingDeviceOverrideName";
+static const char * k_pch_audio_EnablePlaybackMirror_Bool = "enablePlaybackMirror";
+static const char * k_pch_audio_PlaybackMirrorDevice_String = "playbackMirrorDevice";
+static const char * k_pch_audio_PlaybackMirrorDeviceName_String = "playbackMirrorDeviceName";
+static const char * k_pch_audio_OldPlaybackMirrorDevice_String = "onPlaybackMirrorDevice";
+static const char * k_pch_audio_ActiveMirrorDevice_String = "activePlaybackMirrorDevice";
+static const char * k_pch_audio_EnablePlaybackMirrorIndependentVolume_Bool = "enablePlaybackMirrorIndependentVolume";
+static const char * k_pch_audio_LastHmdPlaybackDeviceId_String = "lastHmdPlaybackDeviceId";
+static const char * k_pch_audio_VIVEHDMIGain = "viveHDMIGain";
+static const char * k_pch_audio_DualSpeakerAndJackOutput_Bool = "dualSpeakerAndJackOutput";
+static const char * k_pch_audio_MuteMicMonitor_Bool = "muteMicMonitor";
+static const char * k_pch_Power_Section = "power";
+static const char * k_pch_Power_PowerOffOnExit_Bool = "powerOffOnExit";
+static const char * k_pch_Power_TurnOffScreensTimeout_Float = "turnOffScreensTimeout";
+static const char * k_pch_Power_TurnOffControllersTimeout_Float = "turnOffControllersTimeout";
+static const char * k_pch_Power_ReturnToWatchdogTimeout_Float = "returnToWatchdogTimeout";
+static const char * k_pch_Power_AutoLaunchSteamVROnButtonPress = "autoLaunchSteamVROnButtonPress";
+static const char * k_pch_Power_PauseCompositorOnStandby_Bool = "pauseCompositorOnStandby";
+static const char * k_pch_Dashboard_Section = "dashboard";
+static const char * k_pch_Dashboard_EnableDashboard_Bool = "enableDashboard";
+static const char * k_pch_Dashboard_ArcadeMode_Bool = "arcadeMode";
+static const char * k_pch_Dashboard_Position = "position";
+static const char * k_pch_Dashboard_DesktopScale = "desktopScale";
+static const char * k_pch_Dashboard_DashboardScale = "dashboardScale";
+static const char * k_pch_Dashboard_UseStandaloneSystemLayer = "standaloneSystemLayer";
+static const char * k_pch_Dashboard_StickyDashboard = "stickyDashboard";
+static const char * k_pch_modelskin_Section = "modelskins";
+static const char * k_pch_Driver_Enable_Bool = "enable";
+static const char * k_pch_Driver_BlockedBySafemode_Bool = "blocked_by_safe_mode";
+static const char * k_pch_Driver_LoadPriority_Int32 = "loadPriority";
+static const char * k_pch_WebInterface_Section = "WebInterface";
+static const char * k_pch_VRWebHelper_Section = "VRWebHelper";
+static const char * k_pch_VRWebHelper_DebuggerEnabled_Bool = "DebuggerEnabled";
+static const char * k_pch_VRWebHelper_DebuggerPort_Int32 = "DebuggerPort";
+static const char * k_pch_TrackingOverride_Section = "TrackingOverrides";
+static const char * k_pch_App_BindingAutosaveURLSuffix_String = "AutosaveURL";
+static const char * k_pch_App_BindingLegacyAPISuffix_String = "_legacy";
+static const char * k_pch_App_BindingSteamVRInputAPISuffix_String = "_steamvrinput";
+static const char * k_pch_App_BindingOpenXRAPISuffix_String = "_openxr";
+static const char * k_pch_App_BindingCurrentURLSuffix_String = "CurrentURL";
+static const char * k_pch_App_BindingPreviousURLSuffix_String = "PreviousURL";
+static const char * k_pch_App_NeedToUpdateAutosaveSuffix_Bool = "NeedToUpdateAutosave";
+static const char * k_pch_App_DominantHand_Int32 = "DominantHand";
+static const char * k_pch_App_BlockOculusSDK_Bool = "blockOculusSDK";
+static const char * k_pch_Trackers_Section = "trackers";
+static const char * k_pch_DesktopUI_Section = "DesktopUI";
+static const char * k_pch_LastKnown_Section = "LastKnown";
+static const char * k_pch_LastKnown_HMDManufacturer_String = "HMDManufacturer";
+static const char * k_pch_LastKnown_HMDModel_String = "HMDModel";
+static const char * k_pch_DismissedWarnings_Section = "DismissedWarnings";
+static const char * k_pch_Input_Section = "input";
+static const char * k_pch_Input_LeftThumbstickRotation_Float = "leftThumbstickRotation";
+static const char * k_pch_Input_RightThumbstickRotation_Float = "rightThumbstickRotation";
+static const char * k_pch_Input_ThumbstickDeadzone_Float = "thumbstickDeadzone";
+static const char * k_pch_GpuSpeed_Section = "GpuSpeed";
+static const char * IVRScreenshots_Version = "IVRScreenshots_001";
+static const char * IVRResources_Version = "IVRResources_001";
+static const char * IVRDriverManager_Version = "IVRDriverManager_001";
+static const unsigned long k_unMaxActionNameLength = 64;
+static const unsigned long k_unMaxActionSetNameLength = 64;
+static const unsigned long k_unMaxActionOriginCount = 16;
+static const unsigned long k_unMaxBoneNameLength = 32;
+static const int k_nActionSetOverlayGlobalPriorityMin = 16777216;
+static const int k_nActionSetOverlayGlobalPriorityMax = 33554431;
+static const int k_nActionSetPriorityReservedMin = 33554432;
+static const char * IVRInput_Version = "IVRInput_010";
+static const unsigned long long k_ulInvalidIOBufferHandle = 0;
+static const char * IVRIOBuffer_Version = "IVRIOBuffer_002";
+static const unsigned long k_ulInvalidSpatialAnchorHandle = 0;
+static const char * IVRSpatialAnchors_Version = "IVRSpatialAnchors_001";
+static const char * IVRDebug_Version = "IVRDebug_001";
+static const unsigned long long k_ulDisplayRedirectContainer = 25769803779;
+static const char * IVRProperties_Version = "IVRProperties_001";
+static const char * k_pchPathUserHandRight = "/user/hand/right";
+static const char * k_pchPathUserHandLeft = "/user/hand/left";
+static const char * k_pchPathUserHandPrimary = "/user/hand/primary";
+static const char * k_pchPathUserHandSecondary = "/user/hand/secondary";
+static const char * k_pchPathUserHead = "/user/head";
+static const char * k_pchPathUserGamepad = "/user/gamepad";
+static const char * k_pchPathUserTreadmill = "/user/treadmill";
+static const char * k_pchPathUserStylus = "/user/stylus";
+static const char * k_pchPathDevices = "/devices";
+static const char * k_pchPathDevicePath = "/device_path";
+static const char * k_pchPathBestAliasPath = "/best_alias_path";
+static const char * k_pchPathBoundTrackerAliasPath = "/bound_tracker_path";
+static const char * k_pchPathBoundTrackerRole = "/bound_tracker_role";
+static const char * k_pchPathPoseRaw = "/pose/raw";
+static const char * k_pchPathPoseTip = "/pose/tip";
+static const char * k_pchPathPoseGrip = "/pose/grip";
+static const char * k_pchPathSystemButtonClick = "/input/system/click";
+static const char * k_pchPathProximity = "/proximity";
+static const char * k_pchPathControllerTypePrefix = "/controller_type/";
+static const char * k_pchPathInputProfileSuffix = "/input_profile";
+static const char * k_pchPathBindingNameSuffix = "/binding_name";
+static const char * k_pchPathBindingUrlSuffix = "/binding_url";
+static const char * k_pchPathBindingErrorSuffix = "/binding_error";
+static const char * k_pchPathActiveActionSets = "/active_action_sets";
+static const char * k_pchPathComponentUpdates = "/total_component_updates";
+static const char * k_pchPathUserFootLeft = "/user/foot/left";
+static const char * k_pchPathUserFootRight = "/user/foot/right";
+static const char * k_pchPathUserShoulderLeft = "/user/shoulder/left";
+static const char * k_pchPathUserShoulderRight = "/user/shoulder/right";
+static const char * k_pchPathUserElbowLeft = "/user/elbow/left";
+static const char * k_pchPathUserElbowRight = "/user/elbow/right";
+static const char * k_pchPathUserKneeLeft = "/user/knee/left";
+static const char * k_pchPathUserKneeRight = "/user/knee/right";
+static const char * k_pchPathUserWaist = "/user/waist";
+static const char * k_pchPathUserChest = "/user/chest";
+static const char * k_pchPathUserCamera = "/user/camera";
+static const char * k_pchPathUserKeyboard = "/user/keyboard";
+static const char * k_pchPathClientAppKey = "/client_info/app_key";
+static const unsigned long long k_ulInvalidPathHandle = 0;
+static const char * IVRPaths_Version = "IVRPaths_001";
+static const char * IVRBlockQueue_Version = "IVRBlockQueue_005";
+
+// OpenVR Enums
+
+typedef enum EVREye
+{
+	EVREye_Eye_Left = 0,
+	EVREye_Eye_Right = 1,
+} EVREye;
+
+typedef enum ETextureType
+{
+	ETextureType_TextureType_Invalid = -1,
+	ETextureType_TextureType_DirectX = 0,
+	ETextureType_TextureType_OpenGL = 1,
+	ETextureType_TextureType_Vulkan = 2,
+	ETextureType_TextureType_IOSurface = 3,
+	ETextureType_TextureType_DirectX12 = 4,
+	ETextureType_TextureType_DXGISharedHandle = 5,
+	ETextureType_TextureType_Metal = 6,
+} ETextureType;
+
+typedef enum EColorSpace
+{
+	EColorSpace_ColorSpace_Auto = 0,
+	EColorSpace_ColorSpace_Gamma = 1,
+	EColorSpace_ColorSpace_Linear = 2,
+} EColorSpace;
+
+typedef enum ETrackingResult
+{
+	ETrackingResult_TrackingResult_Uninitialized = 1,
+	ETrackingResult_TrackingResult_Calibrating_InProgress = 100,
+	ETrackingResult_TrackingResult_Calibrating_OutOfRange = 101,
+	ETrackingResult_TrackingResult_Running_OK = 200,
+	ETrackingResult_TrackingResult_Running_OutOfRange = 201,
+	ETrackingResult_TrackingResult_Fallback_RotationOnly = 300,
+} ETrackingResult;
+
+typedef enum ETrackedDeviceClass
+{
+	ETrackedDeviceClass_TrackedDeviceClass_Invalid = 0,
+	ETrackedDeviceClass_TrackedDeviceClass_HMD = 1,
+	ETrackedDeviceClass_TrackedDeviceClass_Controller = 2,
+	ETrackedDeviceClass_TrackedDeviceClass_GenericTracker = 3,
+	ETrackedDeviceClass_TrackedDeviceClass_TrackingReference = 4,
+	ETrackedDeviceClass_TrackedDeviceClass_DisplayRedirect = 5,
+	ETrackedDeviceClass_TrackedDeviceClass_Max = 6,
+} ETrackedDeviceClass;
+
+typedef enum ETrackedControllerRole
+{
+	ETrackedControllerRole_TrackedControllerRole_Invalid = 0,
+	ETrackedControllerRole_TrackedControllerRole_LeftHand = 1,
+	ETrackedControllerRole_TrackedControllerRole_RightHand = 2,
+	ETrackedControllerRole_TrackedControllerRole_OptOut = 3,
+	ETrackedControllerRole_TrackedControllerRole_Treadmill = 4,
+	ETrackedControllerRole_TrackedControllerRole_Stylus = 5,
+	ETrackedControllerRole_TrackedControllerRole_Max = 5,
+} ETrackedControllerRole;
+
+typedef enum ETrackingUniverseOrigin
+{
+	ETrackingUniverseOrigin_TrackingUniverseSeated = 0,
+	ETrackingUniverseOrigin_TrackingUniverseStanding = 1,
+	ETrackingUniverseOrigin_TrackingUniverseRawAndUncalibrated = 2,
+} ETrackingUniverseOrigin;
+
+typedef enum EAdditionalRadioFeatures
+{
+	EAdditionalRadioFeatures_AdditionalRadioFeatures_None = 0,
+	EAdditionalRadioFeatures_AdditionalRadioFeatures_HTCLinkBox = 1,
+	EAdditionalRadioFeatures_AdditionalRadioFeatures_InternalDongle = 2,
+	EAdditionalRadioFeatures_AdditionalRadioFeatures_ExternalDongle = 4,
+} EAdditionalRadioFeatures;
+
+typedef enum ETrackedDeviceProperty
+{
+	ETrackedDeviceProperty_Prop_Invalid = 0,
+	ETrackedDeviceProperty_Prop_TrackingSystemName_String = 1000,
+	ETrackedDeviceProperty_Prop_ModelNumber_String = 1001,
+	ETrackedDeviceProperty_Prop_SerialNumber_String = 1002,
+	ETrackedDeviceProperty_Prop_RenderModelName_String = 1003,
+	ETrackedDeviceProperty_Prop_WillDriftInYaw_Bool = 1004,
+	ETrackedDeviceProperty_Prop_ManufacturerName_String = 1005,
+	ETrackedDeviceProperty_Prop_TrackingFirmwareVersion_String = 1006,
+	ETrackedDeviceProperty_Prop_HardwareRevision_String = 1007,
+	ETrackedDeviceProperty_Prop_AllWirelessDongleDescriptions_String = 1008,
+	ETrackedDeviceProperty_Prop_ConnectedWirelessDongle_String = 1009,
+	ETrackedDeviceProperty_Prop_DeviceIsWireless_Bool = 1010,
+	ETrackedDeviceProperty_Prop_DeviceIsCharging_Bool = 1011,
+	ETrackedDeviceProperty_Prop_DeviceBatteryPercentage_Float = 1012,
+	ETrackedDeviceProperty_Prop_StatusDisplayTransform_Matrix34 = 1013,
+	ETrackedDeviceProperty_Prop_Firmware_UpdateAvailable_Bool = 1014,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdate_Bool = 1015,
+	ETrackedDeviceProperty_Prop_Firmware_ManualUpdateURL_String = 1016,
+	ETrackedDeviceProperty_Prop_HardwareRevision_Uint64 = 1017,
+	ETrackedDeviceProperty_Prop_FirmwareVersion_Uint64 = 1018,
+	ETrackedDeviceProperty_Prop_FPGAVersion_Uint64 = 1019,
+	ETrackedDeviceProperty_Prop_VRCVersion_Uint64 = 1020,
+	ETrackedDeviceProperty_Prop_RadioVersion_Uint64 = 1021,
+	ETrackedDeviceProperty_Prop_DongleVersion_Uint64 = 1022,
+	ETrackedDeviceProperty_Prop_BlockServerShutdown_Bool = 1023,
+	ETrackedDeviceProperty_Prop_CanUnifyCoordinateSystemWithHmd_Bool = 1024,
+	ETrackedDeviceProperty_Prop_ContainsProximitySensor_Bool = 1025,
+	ETrackedDeviceProperty_Prop_DeviceProvidesBatteryStatus_Bool = 1026,
+	ETrackedDeviceProperty_Prop_DeviceCanPowerOff_Bool = 1027,
+	ETrackedDeviceProperty_Prop_Firmware_ProgrammingTarget_String = 1028,
+	ETrackedDeviceProperty_Prop_DeviceClass_Int32 = 1029,
+	ETrackedDeviceProperty_Prop_HasCamera_Bool = 1030,
+	ETrackedDeviceProperty_Prop_DriverVersion_String = 1031,
+	ETrackedDeviceProperty_Prop_Firmware_ForceUpdateRequired_Bool = 1032,
+	ETrackedDeviceProperty_Prop_ViveSystemButtonFixRequired_Bool = 1033,
+	ETrackedDeviceProperty_Prop_ParentDriver_Uint64 = 1034,
+	ETrackedDeviceProperty_Prop_ResourceRoot_String = 1035,
+	ETrackedDeviceProperty_Prop_RegisteredDeviceType_String = 1036,
+	ETrackedDeviceProperty_Prop_InputProfilePath_String = 1037,
+	ETrackedDeviceProperty_Prop_NeverTracked_Bool = 1038,
+	ETrackedDeviceProperty_Prop_NumCameras_Int32 = 1039,
+	ETrackedDeviceProperty_Prop_CameraFrameLayout_Int32 = 1040,
+	ETrackedDeviceProperty_Prop_CameraStreamFormat_Int32 = 1041,
+	ETrackedDeviceProperty_Prop_AdditionalDeviceSettingsPath_String = 1042,
+	ETrackedDeviceProperty_Prop_Identifiable_Bool = 1043,
+	ETrackedDeviceProperty_Prop_BootloaderVersion_Uint64 = 1044,
+	ETrackedDeviceProperty_Prop_AdditionalSystemReportData_String = 1045,
+	ETrackedDeviceProperty_Prop_CompositeFirmwareVersion_String = 1046,
+	ETrackedDeviceProperty_Prop_Firmware_RemindUpdate_Bool = 1047,
+	ETrackedDeviceProperty_Prop_PeripheralApplicationVersion_Uint64 = 1048,
+	ETrackedDeviceProperty_Prop_ManufacturerSerialNumber_String = 1049,
+	ETrackedDeviceProperty_Prop_ComputedSerialNumber_String = 1050,
+	ETrackedDeviceProperty_Prop_EstimatedDeviceFirstUseTime_Int32 = 1051,
+	ETrackedDeviceProperty_Prop_DevicePowerUsage_Float = 1052,
+	ETrackedDeviceProperty_Prop_IgnoreMotionForStandby_Bool = 1053,
+	ETrackedDeviceProperty_Prop_ReportsTimeSinceVSync_Bool = 2000,
+	ETrackedDeviceProperty_Prop_SecondsFromVsyncToPhotons_Float = 2001,
+	ETrackedDeviceProperty_Prop_DisplayFrequency_Float = 2002,
+	ETrackedDeviceProperty_Prop_UserIpdMeters_Float = 2003,
+	ETrackedDeviceProperty_Prop_CurrentUniverseId_Uint64 = 2004,
+	ETrackedDeviceProperty_Prop_PreviousUniverseId_Uint64 = 2005,
+	ETrackedDeviceProperty_Prop_DisplayFirmwareVersion_Uint64 = 2006,
+	ETrackedDeviceProperty_Prop_IsOnDesktop_Bool = 2007,
+	ETrackedDeviceProperty_Prop_DisplayMCType_Int32 = 2008,
+	ETrackedDeviceProperty_Prop_DisplayMCOffset_Float = 2009,
+	ETrackedDeviceProperty_Prop_DisplayMCScale_Float = 2010,
+	ETrackedDeviceProperty_Prop_EdidVendorID_Int32 = 2011,
+	ETrackedDeviceProperty_Prop_DisplayMCImageLeft_String = 2012,
+	ETrackedDeviceProperty_Prop_DisplayMCImageRight_String = 2013,
+	ETrackedDeviceProperty_Prop_DisplayGCBlackClamp_Float = 2014,
+	ETrackedDeviceProperty_Prop_EdidProductID_Int32 = 2015,
+	ETrackedDeviceProperty_Prop_CameraToHeadTransform_Matrix34 = 2016,
+	ETrackedDeviceProperty_Prop_DisplayGCType_Int32 = 2017,
+	ETrackedDeviceProperty_Prop_DisplayGCOffset_Float = 2018,
+	ETrackedDeviceProperty_Prop_DisplayGCScale_Float = 2019,
+	ETrackedDeviceProperty_Prop_DisplayGCPrescale_Float = 2020,
+	ETrackedDeviceProperty_Prop_DisplayGCImage_String = 2021,
+	ETrackedDeviceProperty_Prop_LensCenterLeftU_Float = 2022,
+	ETrackedDeviceProperty_Prop_LensCenterLeftV_Float = 2023,
+	ETrackedDeviceProperty_Prop_LensCenterRightU_Float = 2024,
+	ETrackedDeviceProperty_Prop_LensCenterRightV_Float = 2025,
+	ETrackedDeviceProperty_Prop_UserHeadToEyeDepthMeters_Float = 2026,
+	ETrackedDeviceProperty_Prop_CameraFirmwareVersion_Uint64 = 2027,
+	ETrackedDeviceProperty_Prop_CameraFirmwareDescription_String = 2028,
+	ETrackedDeviceProperty_Prop_DisplayFPGAVersion_Uint64 = 2029,
+	ETrackedDeviceProperty_Prop_DisplayBootloaderVersion_Uint64 = 2030,
+	ETrackedDeviceProperty_Prop_DisplayHardwareVersion_Uint64 = 2031,
+	ETrackedDeviceProperty_Prop_AudioFirmwareVersion_Uint64 = 2032,
+	ETrackedDeviceProperty_Prop_CameraCompatibilityMode_Int32 = 2033,
+	ETrackedDeviceProperty_Prop_ScreenshotHorizontalFieldOfViewDegrees_Float = 2034,
+	ETrackedDeviceProperty_Prop_ScreenshotVerticalFieldOfViewDegrees_Float = 2035,
+	ETrackedDeviceProperty_Prop_DisplaySuppressed_Bool = 2036,
+	ETrackedDeviceProperty_Prop_DisplayAllowNightMode_Bool = 2037,
+	ETrackedDeviceProperty_Prop_DisplayMCImageWidth_Int32 = 2038,
+	ETrackedDeviceProperty_Prop_DisplayMCImageHeight_Int32 = 2039,
+	ETrackedDeviceProperty_Prop_DisplayMCImageNumChannels_Int32 = 2040,
+	ETrackedDeviceProperty_Prop_DisplayMCImageData_Binary = 2041,
+	ETrackedDeviceProperty_Prop_SecondsFromPhotonsToVblank_Float = 2042,
+	ETrackedDeviceProperty_Prop_DriverDirectModeSendsVsyncEvents_Bool = 2043,
+	ETrackedDeviceProperty_Prop_DisplayDebugMode_Bool = 2044,
+	ETrackedDeviceProperty_Prop_GraphicsAdapterLuid_Uint64 = 2045,
+	ETrackedDeviceProperty_Prop_DriverProvidedChaperonePath_String = 2048,
+	ETrackedDeviceProperty_Prop_ExpectedTrackingReferenceCount_Int32 = 2049,
+	ETrackedDeviceProperty_Prop_ExpectedControllerCount_Int32 = 2050,
+	ETrackedDeviceProperty_Prop_NamedIconPathControllerLeftDeviceOff_String = 2051,
+	ETrackedDeviceProperty_Prop_NamedIconPathControllerRightDeviceOff_String = 2052,
+	ETrackedDeviceProperty_Prop_NamedIconPathTrackingReferenceDeviceOff_String = 2053,
+	ETrackedDeviceProperty_Prop_DoNotApplyPrediction_Bool = 2054,
+	ETrackedDeviceProperty_Prop_CameraToHeadTransforms_Matrix34_Array = 2055,
+	ETrackedDeviceProperty_Prop_DistortionMeshResolution_Int32 = 2056,
+	ETrackedDeviceProperty_Prop_DriverIsDrawingControllers_Bool = 2057,
+	ETrackedDeviceProperty_Prop_DriverRequestsApplicationPause_Bool = 2058,
+	ETrackedDeviceProperty_Prop_DriverRequestsReducedRendering_Bool = 2059,
+	ETrackedDeviceProperty_Prop_MinimumIpdStepMeters_Float = 2060,
+	ETrackedDeviceProperty_Prop_AudioBridgeFirmwareVersion_Uint64 = 2061,
+	ETrackedDeviceProperty_Prop_ImageBridgeFirmwareVersion_Uint64 = 2062,
+	ETrackedDeviceProperty_Prop_ImuToHeadTransform_Matrix34 = 2063,
+	ETrackedDeviceProperty_Prop_ImuFactoryGyroBias_Vector3 = 2064,
+	ETrackedDeviceProperty_Prop_ImuFactoryGyroScale_Vector3 = 2065,
+	ETrackedDeviceProperty_Prop_ImuFactoryAccelerometerBias_Vector3 = 2066,
+	ETrackedDeviceProperty_Prop_ImuFactoryAccelerometerScale_Vector3 = 2067,
+	ETrackedDeviceProperty_Prop_ConfigurationIncludesLighthouse20Features_Bool = 2069,
+	ETrackedDeviceProperty_Prop_AdditionalRadioFeatures_Uint64 = 2070,
+	ETrackedDeviceProperty_Prop_CameraWhiteBalance_Vector4_Array = 2071,
+	ETrackedDeviceProperty_Prop_CameraDistortionFunction_Int32_Array = 2072,
+	ETrackedDeviceProperty_Prop_CameraDistortionCoefficients_Float_Array = 2073,
+	ETrackedDeviceProperty_Prop_ExpectedControllerType_String = 2074,
+	ETrackedDeviceProperty_Prop_HmdTrackingStyle_Int32 = 2075,
+	ETrackedDeviceProperty_Prop_DriverProvidedChaperoneVisibility_Bool = 2076,
+	ETrackedDeviceProperty_Prop_HmdColumnCorrectionSettingPrefix_String = 2077,
+	ETrackedDeviceProperty_Prop_CameraSupportsCompatibilityModes_Bool = 2078,
+	ETrackedDeviceProperty_Prop_SupportsRoomViewDepthProjection_Bool = 2079,
+	ETrackedDeviceProperty_Prop_DisplayAvailableFrameRates_Float_Array = 2080,
+	ETrackedDeviceProperty_Prop_DisplaySupportsMultipleFramerates_Bool = 2081,
+	ETrackedDeviceProperty_Prop_DisplayColorMultLeft_Vector3 = 2082,
+	ETrackedDeviceProperty_Prop_DisplayColorMultRight_Vector3 = 2083,
+	ETrackedDeviceProperty_Prop_DisplaySupportsRuntimeFramerateChange_Bool = 2084,
+	ETrackedDeviceProperty_Prop_DisplaySupportsAnalogGain_Bool = 2085,
+	ETrackedDeviceProperty_Prop_DisplayMinAnalogGain_Float = 2086,
+	ETrackedDeviceProperty_Prop_DisplayMaxAnalogGain_Float = 2087,
+	ETrackedDeviceProperty_Prop_CameraExposureTime_Float = 2088,
+	ETrackedDeviceProperty_Prop_CameraGlobalGain_Float = 2089,
+	ETrackedDeviceProperty_Prop_DashboardScale_Float = 2091,
+	ETrackedDeviceProperty_Prop_PeerButtonInfo_String = 2092,
+	ETrackedDeviceProperty_Prop_Hmd_SupportsHDR10_Bool = 2093,
+	ETrackedDeviceProperty_Prop_IpdUIRangeMinMeters_Float = 2100,
+	ETrackedDeviceProperty_Prop_IpdUIRangeMaxMeters_Float = 2101,
+	ETrackedDeviceProperty_Prop_Hmd_SupportsHDCP14LegacyCompat_Bool = 2102,
+	ETrackedDeviceProperty_Prop_Hmd_SupportsMicMonitoring_Bool = 2103,
+	ETrackedDeviceProperty_Prop_Hmd_SupportsDisplayPortTrainingMode_Bool = 2104,
+	ETrackedDeviceProperty_Prop_SupportsRoomViewDirect_Bool = 2105,
+	ETrackedDeviceProperty_Prop_SupportsAppThrottling_Bool = 2106,
+	ETrackedDeviceProperty_Prop_DSCVersion_Int32 = 2110,
+	ETrackedDeviceProperty_Prop_DSCSliceCount_Int32 = 2111,
+	ETrackedDeviceProperty_Prop_DSCBPPx16_Int32 = 2112,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraCorrectionMode_Int32 = 2200,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_InnerLeft_Int32 = 2201,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_InnerRight_Int32 = 2202,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_InnerTop_Int32 = 2203,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_InnerBottom_Int32 = 2204,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_OuterLeft_Int32 = 2205,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_OuterRight_Int32 = 2206,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_OuterTop_Int32 = 2207,
+	ETrackedDeviceProperty_Prop_DriverRequestedMuraFeather_OuterBottom_Int32 = 2208,
+	ETrackedDeviceProperty_Prop_Audio_DefaultPlaybackDeviceId_String = 2300,
+	ETrackedDeviceProperty_Prop_Audio_DefaultRecordingDeviceId_String = 2301,
+	ETrackedDeviceProperty_Prop_Audio_DefaultPlaybackDeviceVolume_Float = 2302,
+	ETrackedDeviceProperty_Prop_Audio_SupportsDualSpeakerAndJackOutput_Bool = 2303,
+	ETrackedDeviceProperty_Prop_AttachedDeviceId_String = 3000,
+	ETrackedDeviceProperty_Prop_SupportedButtons_Uint64 = 3001,
+	ETrackedDeviceProperty_Prop_Axis0Type_Int32 = 3002,
+	ETrackedDeviceProperty_Prop_Axis1Type_Int32 = 3003,
+	ETrackedDeviceProperty_Prop_Axis2Type_Int32 = 3004,
+	ETrackedDeviceProperty_Prop_Axis3Type_Int32 = 3005,
+	ETrackedDeviceProperty_Prop_Axis4Type_Int32 = 3006,
+	ETrackedDeviceProperty_Prop_ControllerRoleHint_Int32 = 3007,
+	ETrackedDeviceProperty_Prop_FieldOfViewLeftDegrees_Float = 4000,
+	ETrackedDeviceProperty_Prop_FieldOfViewRightDegrees_Float = 4001,
+	ETrackedDeviceProperty_Prop_FieldOfViewTopDegrees_Float = 4002,
+	ETrackedDeviceProperty_Prop_FieldOfViewBottomDegrees_Float = 4003,
+	ETrackedDeviceProperty_Prop_TrackingRangeMinimumMeters_Float = 4004,
+	ETrackedDeviceProperty_Prop_TrackingRangeMaximumMeters_Float = 4005,
+	ETrackedDeviceProperty_Prop_ModeLabel_String = 4006,
+	ETrackedDeviceProperty_Prop_CanWirelessIdentify_Bool = 4007,
+	ETrackedDeviceProperty_Prop_Nonce_Int32 = 4008,
+	ETrackedDeviceProperty_Prop_IconPathName_String = 5000,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceOff_String = 5001,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearching_String = 5002,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceSearchingAlert_String = 5003,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReady_String = 5004,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceReadyAlert_String = 5005,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceNotReady_String = 5006,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandby_String = 5007,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceAlertLow_String = 5008,
+	ETrackedDeviceProperty_Prop_NamedIconPathDeviceStandbyAlert_String = 5009,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_Start = 5100,
+	ETrackedDeviceProperty_Prop_DisplayHiddenArea_Binary_End = 5150,
+	ETrackedDeviceProperty_Prop_ParentContainer = 5151,
+	ETrackedDeviceProperty_Prop_OverrideContainer_Uint64 = 5152,
+	ETrackedDeviceProperty_Prop_UserConfigPath_String = 6000,
+	ETrackedDeviceProperty_Prop_InstallPath_String = 6001,
+	ETrackedDeviceProperty_Prop_HasDisplayComponent_Bool = 6002,
+	ETrackedDeviceProperty_Prop_HasControllerComponent_Bool = 6003,
+	ETrackedDeviceProperty_Prop_HasCameraComponent_Bool = 6004,
+	ETrackedDeviceProperty_Prop_HasDriverDirectModeComponent_Bool = 6005,
+	ETrackedDeviceProperty_Prop_HasVirtualDisplayComponent_Bool = 6006,
+	ETrackedDeviceProperty_Prop_HasSpatialAnchorsSupport_Bool = 6007,
+	ETrackedDeviceProperty_Prop_ControllerType_String = 7000,
+	ETrackedDeviceProperty_Prop_ControllerHandSelectionPriority_Int32 = 7002,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_Start = 10000,
+	ETrackedDeviceProperty_Prop_VendorSpecific_Reserved_End = 10999,
+	ETrackedDeviceProperty_Prop_TrackedDeviceProperty_Max = 1000000,
+} ETrackedDeviceProperty;
+
+typedef enum ETrackedPropertyError
+{
+	ETrackedPropertyError_TrackedProp_Success = 0,
+	ETrackedPropertyError_TrackedProp_WrongDataType = 1,
+	ETrackedPropertyError_TrackedProp_WrongDeviceClass = 2,
+	ETrackedPropertyError_TrackedProp_BufferTooSmall = 3,
+	ETrackedPropertyError_TrackedProp_UnknownProperty = 4,
+	ETrackedPropertyError_TrackedProp_InvalidDevice = 5,
+	ETrackedPropertyError_TrackedProp_CouldNotContactServer = 6,
+	ETrackedPropertyError_TrackedProp_ValueNotProvidedByDevice = 7,
+	ETrackedPropertyError_TrackedProp_StringExceedsMaximumLength = 8,
+	ETrackedPropertyError_TrackedProp_NotYetAvailable = 9,
+	ETrackedPropertyError_TrackedProp_PermissionDenied = 10,
+	ETrackedPropertyError_TrackedProp_InvalidOperation = 11,
+	ETrackedPropertyError_TrackedProp_CannotWriteToWildcards = 12,
+	ETrackedPropertyError_TrackedProp_IPCReadFailure = 13,
+	ETrackedPropertyError_TrackedProp_OutOfMemory = 14,
+	ETrackedPropertyError_TrackedProp_InvalidContainer = 15,
+} ETrackedPropertyError;
+
+typedef enum EHmdTrackingStyle
+{
+	EHmdTrackingStyle_HmdTrackingStyle_Unknown = 0,
+	EHmdTrackingStyle_HmdTrackingStyle_Lighthouse = 1,
+	EHmdTrackingStyle_HmdTrackingStyle_OutsideInCameras = 2,
+	EHmdTrackingStyle_HmdTrackingStyle_InsideOutCameras = 3,
+} EHmdTrackingStyle;
+
+typedef enum EVRSubmitFlags
+{
+	EVRSubmitFlags_Submit_Default = 0,
+	EVRSubmitFlags_Submit_LensDistortionAlreadyApplied = 1,
+	EVRSubmitFlags_Submit_GlRenderBuffer = 2,
+	EVRSubmitFlags_Submit_Reserved = 4,
+	EVRSubmitFlags_Submit_TextureWithPose = 8,
+	EVRSubmitFlags_Submit_TextureWithDepth = 16,
+	EVRSubmitFlags_Submit_FrameDiscontinuty = 32,
+	EVRSubmitFlags_Submit_VulkanTextureWithArrayData = 64,
+	EVRSubmitFlags_Submit_GlArrayTexture = 128,
+	EVRSubmitFlags_Submit_Reserved2 = 32768,
+	EVRSubmitFlags_Submit_Reserved3 = 65536,
+} EVRSubmitFlags;
+
+typedef enum EVRState
+{
+	EVRState_VRState_Undefined = -1,
+	EVRState_VRState_Off = 0,
+	EVRState_VRState_Searching = 1,
+	EVRState_VRState_Searching_Alert = 2,
+	EVRState_VRState_Ready = 3,
+	EVRState_VRState_Ready_Alert = 4,
+	EVRState_VRState_NotReady = 5,
+	EVRState_VRState_Standby = 6,
+	EVRState_VRState_Ready_Alert_Low = 7,
+} EVRState;
+
+typedef enum EVREventType
+{
+	EVREventType_VREvent_None = 0,
+	EVREventType_VREvent_TrackedDeviceActivated = 100,
+	EVREventType_VREvent_TrackedDeviceDeactivated = 101,
+	EVREventType_VREvent_TrackedDeviceUpdated = 102,
+	EVREventType_VREvent_TrackedDeviceUserInteractionStarted = 103,
+	EVREventType_VREvent_TrackedDeviceUserInteractionEnded = 104,
+	EVREventType_VREvent_IpdChanged = 105,
+	EVREventType_VREvent_EnterStandbyMode = 106,
+	EVREventType_VREvent_LeaveStandbyMode = 107,
+	EVREventType_VREvent_TrackedDeviceRoleChanged = 108,
+	EVREventType_VREvent_WatchdogWakeUpRequested = 109,
+	EVREventType_VREvent_LensDistortionChanged = 110,
+	EVREventType_VREvent_PropertyChanged = 111,
+	EVREventType_VREvent_WirelessDisconnect = 112,
+	EVREventType_VREvent_WirelessReconnect = 113,
+	EVREventType_VREvent_ButtonPress = 200,
+	EVREventType_VREvent_ButtonUnpress = 201,
+	EVREventType_VREvent_ButtonTouch = 202,
+	EVREventType_VREvent_ButtonUntouch = 203,
+	EVREventType_VREvent_Modal_Cancel = 257,
+	EVREventType_VREvent_MouseMove = 300,
+	EVREventType_VREvent_MouseButtonDown = 301,
+	EVREventType_VREvent_MouseButtonUp = 302,
+	EVREventType_VREvent_FocusEnter = 303,
+	EVREventType_VREvent_FocusLeave = 304,
+	EVREventType_VREvent_ScrollDiscrete = 305,
+	EVREventType_VREvent_TouchPadMove = 306,
+	EVREventType_VREvent_OverlayFocusChanged = 307,
+	EVREventType_VREvent_ReloadOverlays = 308,
+	EVREventType_VREvent_ScrollSmooth = 309,
+	EVREventType_VREvent_LockMousePosition = 310,
+	EVREventType_VREvent_UnlockMousePosition = 311,
+	EVREventType_VREvent_InputFocusCaptured = 400,
+	EVREventType_VREvent_InputFocusReleased = 401,
+	EVREventType_VREvent_SceneApplicationChanged = 404,
+	EVREventType_VREvent_InputFocusChanged = 406,
+	EVREventType_VREvent_SceneApplicationUsingWrongGraphicsAdapter = 408,
+	EVREventType_VREvent_ActionBindingReloaded = 409,
+	EVREventType_VREvent_HideRenderModels = 410,
+	EVREventType_VREvent_ShowRenderModels = 411,
+	EVREventType_VREvent_SceneApplicationStateChanged = 412,
+	EVREventType_VREvent_SceneAppPipeDisconnected = 413,
+	EVREventType_VREvent_ConsoleOpened = 420,
+	EVREventType_VREvent_ConsoleClosed = 421,
+	EVREventType_VREvent_OverlayShown = 500,
+	EVREventType_VREvent_OverlayHidden = 501,
+	EVREventType_VREvent_DashboardActivated = 502,
+	EVREventType_VREvent_DashboardDeactivated = 503,
+	EVREventType_VREvent_DashboardRequested = 505,
+	EVREventType_VREvent_ResetDashboard = 506,
+	EVREventType_VREvent_ImageLoaded = 508,
+	EVREventType_VREvent_ShowKeyboard = 509,
+	EVREventType_VREvent_HideKeyboard = 510,
+	EVREventType_VREvent_OverlayGamepadFocusGained = 511,
+	EVREventType_VREvent_OverlayGamepadFocusLost = 512,
+	EVREventType_VREvent_OverlaySharedTextureChanged = 513,
+	EVREventType_VREvent_ScreenshotTriggered = 516,
+	EVREventType_VREvent_ImageFailed = 517,
+	EVREventType_VREvent_DashboardOverlayCreated = 518,
+	EVREventType_VREvent_SwitchGamepadFocus = 519,
+	EVREventType_VREvent_RequestScreenshot = 520,
+	EVREventType_VREvent_ScreenshotTaken = 521,
+	EVREventType_VREvent_ScreenshotFailed = 522,
+	EVREventType_VREvent_SubmitScreenshotToDashboard = 523,
+	EVREventType_VREvent_ScreenshotProgressToDashboard = 524,
+	EVREventType_VREvent_PrimaryDashboardDeviceChanged = 525,
+	EVREventType_VREvent_RoomViewShown = 526,
+	EVREventType_VREvent_RoomViewHidden = 527,
+	EVREventType_VREvent_ShowUI = 528,
+	EVREventType_VREvent_ShowDevTools = 529,
+	EVREventType_VREvent_DesktopViewUpdating = 530,
+	EVREventType_VREvent_DesktopViewReady = 531,
+	EVREventType_VREvent_StartDashboard = 532,
+	EVREventType_VREvent_ElevatePrism = 533,
+	EVREventType_VREvent_OverlayClosed = 534,
+	EVREventType_VREvent_Notification_Shown = 600,
+	EVREventType_VREvent_Notification_Hidden = 601,
+	EVREventType_VREvent_Notification_BeginInteraction = 602,
+	EVREventType_VREvent_Notification_Destroyed = 603,
+	EVREventType_VREvent_Quit = 700,
+	EVREventType_VREvent_ProcessQuit = 701,
+	EVREventType_VREvent_QuitAcknowledged = 703,
+	EVREventType_VREvent_DriverRequestedQuit = 704,
+	EVREventType_VREvent_RestartRequested = 705,
+	EVREventType_VREvent_InvalidateSwapTextureSets = 706,
+	EVREventType_VREvent_ChaperoneDataHasChanged = 800,
+	EVREventType_VREvent_ChaperoneUniverseHasChanged = 801,
+	EVREventType_VREvent_ChaperoneTempDataHasChanged = 802,
+	EVREventType_VREvent_ChaperoneSettingsHaveChanged = 803,
+	EVREventType_VREvent_SeatedZeroPoseReset = 804,
+	EVREventType_VREvent_ChaperoneFlushCache = 805,
+	EVREventType_VREvent_ChaperoneRoomSetupStarting = 806,
+	EVREventType_VREvent_ChaperoneRoomSetupFinished = 807,
+	EVREventType_VREvent_StandingZeroPoseReset = 808,
+	EVREventType_VREvent_AudioSettingsHaveChanged = 820,
+	EVREventType_VREvent_BackgroundSettingHasChanged = 850,
+	EVREventType_VREvent_CameraSettingsHaveChanged = 851,
+	EVREventType_VREvent_ReprojectionSettingHasChanged = 852,
+	EVREventType_VREvent_ModelSkinSettingsHaveChanged = 853,
+	EVREventType_VREvent_EnvironmentSettingsHaveChanged = 854,
+	EVREventType_VREvent_PowerSettingsHaveChanged = 855,
+	EVREventType_VREvent_EnableHomeAppSettingsHaveChanged = 856,
+	EVREventType_VREvent_SteamVRSectionSettingChanged = 857,
+	EVREventType_VREvent_LighthouseSectionSettingChanged = 858,
+	EVREventType_VREvent_NullSectionSettingChanged = 859,
+	EVREventType_VREvent_UserInterfaceSectionSettingChanged = 860,
+	EVREventType_VREvent_NotificationsSectionSettingChanged = 861,
+	EVREventType_VREvent_KeyboardSectionSettingChanged = 862,
+	EVREventType_VREvent_PerfSectionSettingChanged = 863,
+	EVREventType_VREvent_DashboardSectionSettingChanged = 864,
+	EVREventType_VREvent_WebInterfaceSectionSettingChanged = 865,
+	EVREventType_VREvent_TrackersSectionSettingChanged = 866,
+	EVREventType_VREvent_LastKnownSectionSettingChanged = 867,
+	EVREventType_VREvent_DismissedWarningsSectionSettingChanged = 868,
+	EVREventType_VREvent_GpuSpeedSectionSettingChanged = 869,
+	EVREventType_VREvent_WindowsMRSectionSettingChanged = 870,
+	EVREventType_VREvent_OtherSectionSettingChanged = 871,
+	EVREventType_VREvent_StatusUpdate = 900,
+	EVREventType_VREvent_WebInterface_InstallDriverCompleted = 950,
+	EVREventType_VREvent_MCImageUpdated = 1000,
+	EVREventType_VREvent_FirmwareUpdateStarted = 1100,
+	EVREventType_VREvent_FirmwareUpdateFinished = 1101,
+	EVREventType_VREvent_KeyboardClosed = 1200,
+	EVREventType_VREvent_KeyboardCharInput = 1201,
+	EVREventType_VREvent_KeyboardDone = 1202,
+	EVREventType_VREvent_ApplicationListUpdated = 1303,
+	EVREventType_VREvent_ApplicationMimeTypeLoad = 1304,
+	EVREventType_VREvent_ProcessConnected = 1306,
+	EVREventType_VREvent_ProcessDisconnected = 1307,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsShown = 1410,
+	EVREventType_VREvent_Compositor_ChaperoneBoundsHidden = 1411,
+	EVREventType_VREvent_Compositor_DisplayDisconnected = 1412,
+	EVREventType_VREvent_Compositor_DisplayReconnected = 1413,
+	EVREventType_VREvent_Compositor_HDCPError = 1414,
+	EVREventType_VREvent_Compositor_ApplicationNotResponding = 1415,
+	EVREventType_VREvent_Compositor_ApplicationResumed = 1416,
+	EVREventType_VREvent_Compositor_OutOfVideoMemory = 1417,
+	EVREventType_VREvent_Compositor_DisplayModeNotSupported = 1418,
+	EVREventType_VREvent_Compositor_StageOverrideReady = 1419,
+	EVREventType_VREvent_Compositor_RequestDisconnectReconnect = 1420,
+	EVREventType_VREvent_TrackedCamera_StartVideoStream = 1500,
+	EVREventType_VREvent_TrackedCamera_StopVideoStream = 1501,
+	EVREventType_VREvent_TrackedCamera_PauseVideoStream = 1502,
+	EVREventType_VREvent_TrackedCamera_ResumeVideoStream = 1503,
+	EVREventType_VREvent_TrackedCamera_EditingSurface = 1550,
+	EVREventType_VREvent_PerformanceTest_EnableCapture = 1600,
+	EVREventType_VREvent_PerformanceTest_DisableCapture = 1601,
+	EVREventType_VREvent_PerformanceTest_FidelityLevel = 1602,
+	EVREventType_VREvent_MessageOverlay_Closed = 1650,
+	EVREventType_VREvent_MessageOverlayCloseRequested = 1651,
+	EVREventType_VREvent_Input_HapticVibration = 1700,
+	EVREventType_VREvent_Input_BindingLoadFailed = 1701,
+	EVREventType_VREvent_Input_BindingLoadSuccessful = 1702,
+	EVREventType_VREvent_Input_ActionManifestReloaded = 1703,
+	EVREventType_VREvent_Input_ActionManifestLoadFailed = 1704,
+	EVREventType_VREvent_Input_ProgressUpdate = 1705,
+	EVREventType_VREvent_Input_TrackerActivated = 1706,
+	EVREventType_VREvent_Input_BindingsUpdated = 1707,
+	EVREventType_VREvent_Input_BindingSubscriptionChanged = 1708,
+	EVREventType_VREvent_SpatialAnchors_PoseUpdated = 1800,
+	EVREventType_VREvent_SpatialAnchors_DescriptorUpdated = 1801,
+	EVREventType_VREvent_SpatialAnchors_RequestPoseUpdate = 1802,
+	EVREventType_VREvent_SpatialAnchors_RequestDescriptorUpdate = 1803,
+	EVREventType_VREvent_SystemReport_Started = 1900,
+	EVREventType_VREvent_Monitor_ShowHeadsetView = 2000,
+	EVREventType_VREvent_Monitor_HideHeadsetView = 2001,
+	EVREventType_VREvent_VendorSpecific_Reserved_Start = 10000,
+	EVREventType_VREvent_VendorSpecific_Reserved_End = 19999,
+} EVREventType;
+
+typedef enum EDeviceActivityLevel
+{
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Unknown = -1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Idle = 0,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction = 1,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_UserInteraction_Timeout = 2,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Standby = 3,
+	EDeviceActivityLevel_k_EDeviceActivityLevel_Idle_Timeout = 4,
+} EDeviceActivityLevel;
+
+typedef enum EVRButtonId
+{
+	EVRButtonId_k_EButton_System = 0,
+	EVRButtonId_k_EButton_ApplicationMenu = 1,
+	EVRButtonId_k_EButton_Grip = 2,
+	EVRButtonId_k_EButton_DPad_Left = 3,
+	EVRButtonId_k_EButton_DPad_Up = 4,
+	EVRButtonId_k_EButton_DPad_Right = 5,
+	EVRButtonId_k_EButton_DPad_Down = 6,
+	EVRButtonId_k_EButton_A = 7,
+	EVRButtonId_k_EButton_ProximitySensor = 31,
+	EVRButtonId_k_EButton_Axis0 = 32,
+	EVRButtonId_k_EButton_Axis1 = 33,
+	EVRButtonId_k_EButton_Axis2 = 34,
+	EVRButtonId_k_EButton_Axis3 = 35,
+	EVRButtonId_k_EButton_Axis4 = 36,
+	EVRButtonId_k_EButton_SteamVR_Touchpad = 32,
+	EVRButtonId_k_EButton_SteamVR_Trigger = 33,
+	EVRButtonId_k_EButton_Dashboard_Back = 2,
+	EVRButtonId_k_EButton_IndexController_A = 2,
+	EVRButtonId_k_EButton_IndexController_B = 1,
+	EVRButtonId_k_EButton_IndexController_JoyStick = 35,
+	EVRButtonId_k_EButton_Max = 64,
+} EVRButtonId;
+
+typedef enum EVRMouseButton
+{
+	EVRMouseButton_VRMouseButton_Left = 1,
+	EVRMouseButton_VRMouseButton_Right = 2,
+	EVRMouseButton_VRMouseButton_Middle = 4,
+} EVRMouseButton;
+
+typedef enum EShowUIType
+{
+	EShowUIType_ShowUI_ControllerBinding = 0,
+	EShowUIType_ShowUI_ManageTrackers = 1,
+	EShowUIType_ShowUI_Pairing = 3,
+	EShowUIType_ShowUI_Settings = 4,
+	EShowUIType_ShowUI_DebugCommands = 5,
+	EShowUIType_ShowUI_FullControllerBinding = 6,
+	EShowUIType_ShowUI_ManageDrivers = 7,
+} EShowUIType;
+
+typedef enum EHDCPError
+{
+	EHDCPError_HDCPError_None = 0,
+	EHDCPError_HDCPError_LinkLost = 1,
+	EHDCPError_HDCPError_Tampered = 2,
+	EHDCPError_HDCPError_DeviceRevoked = 3,
+	EHDCPError_HDCPError_Unknown = 4,
+} EHDCPError;
+
+typedef enum EVRComponentProperty
+{
+	EVRComponentProperty_VRComponentProperty_IsStatic = 1,
+	EVRComponentProperty_VRComponentProperty_IsVisible = 2,
+	EVRComponentProperty_VRComponentProperty_IsTouched = 4,
+	EVRComponentProperty_VRComponentProperty_IsPressed = 8,
+	EVRComponentProperty_VRComponentProperty_IsScrolled = 16,
+	EVRComponentProperty_VRComponentProperty_IsHighlighted = 32,
+} EVRComponentProperty;
+
+typedef enum EVRInputError
+{
+	EVRInputError_VRInputError_None = 0,
+	EVRInputError_VRInputError_NameNotFound = 1,
+	EVRInputError_VRInputError_WrongType = 2,
+	EVRInputError_VRInputError_InvalidHandle = 3,
+	EVRInputError_VRInputError_InvalidParam = 4,
+	EVRInputError_VRInputError_NoSteam = 5,
+	EVRInputError_VRInputError_MaxCapacityReached = 6,
+	EVRInputError_VRInputError_IPCError = 7,
+	EVRInputError_VRInputError_NoActiveActionSet = 8,
+	EVRInputError_VRInputError_InvalidDevice = 9,
+	EVRInputError_VRInputError_InvalidSkeleton = 10,
+	EVRInputError_VRInputError_InvalidBoneCount = 11,
+	EVRInputError_VRInputError_InvalidCompressedData = 12,
+	EVRInputError_VRInputError_NoData = 13,
+	EVRInputError_VRInputError_BufferTooSmall = 14,
+	EVRInputError_VRInputError_MismatchedActionManifest = 15,
+	EVRInputError_VRInputError_MissingSkeletonData = 16,
+	EVRInputError_VRInputError_InvalidBoneIndex = 17,
+	EVRInputError_VRInputError_InvalidPriority = 18,
+	EVRInputError_VRInputError_PermissionDenied = 19,
+	EVRInputError_VRInputError_InvalidRenderModel = 20,
+} EVRInputError;
+
+typedef enum EVRSpatialAnchorError
+{
+	EVRSpatialAnchorError_VRSpatialAnchorError_Success = 0,
+	EVRSpatialAnchorError_VRSpatialAnchorError_Internal = 1,
+	EVRSpatialAnchorError_VRSpatialAnchorError_UnknownHandle = 2,
+	EVRSpatialAnchorError_VRSpatialAnchorError_ArrayTooSmall = 3,
+	EVRSpatialAnchorError_VRSpatialAnchorError_InvalidDescriptorChar = 4,
+	EVRSpatialAnchorError_VRSpatialAnchorError_NotYetAvailable = 5,
+	EVRSpatialAnchorError_VRSpatialAnchorError_NotAvailableInThisUniverse = 6,
+	EVRSpatialAnchorError_VRSpatialAnchorError_PermanentlyUnavailable = 7,
+	EVRSpatialAnchorError_VRSpatialAnchorError_WrongDriver = 8,
+	EVRSpatialAnchorError_VRSpatialAnchorError_DescriptorTooLong = 9,
+	EVRSpatialAnchorError_VRSpatialAnchorError_Unknown = 10,
+	EVRSpatialAnchorError_VRSpatialAnchorError_NoRoomCalibration = 11,
+	EVRSpatialAnchorError_VRSpatialAnchorError_InvalidArgument = 12,
+	EVRSpatialAnchorError_VRSpatialAnchorError_UnknownDriver = 13,
+} EVRSpatialAnchorError;
+
+typedef enum EHiddenAreaMeshType
+{
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Standard = 0,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Inverse = 1,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_LineLoop = 2,
+	EHiddenAreaMeshType_k_eHiddenAreaMesh_Max = 3,
+} EHiddenAreaMeshType;
+
+typedef enum EVRControllerAxisType
+{
+	EVRControllerAxisType_k_eControllerAxis_None = 0,
+	EVRControllerAxisType_k_eControllerAxis_TrackPad = 1,
+	EVRControllerAxisType_k_eControllerAxis_Joystick = 2,
+	EVRControllerAxisType_k_eControllerAxis_Trigger = 3,
+} EVRControllerAxisType;
+
+typedef enum EVRControllerEventOutputType
+{
+	EVRControllerEventOutputType_ControllerEventOutput_OSEvents = 0,
+	EVRControllerEventOutputType_ControllerEventOutput_VREvents = 1,
+} EVRControllerEventOutputType;
+
+typedef enum ECollisionBoundsStyle
+{
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_BEGINNER = 0,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_INTERMEDIATE = 1,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_SQUARES = 2,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_ADVANCED = 3,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_NONE = 4,
+	ECollisionBoundsStyle_COLLISION_BOUNDS_STYLE_COUNT = 5,
+} ECollisionBoundsStyle;
+
+typedef enum EVROverlayError
+{
+	EVROverlayError_VROverlayError_None = 0,
+	EVROverlayError_VROverlayError_UnknownOverlay = 10,
+	EVROverlayError_VROverlayError_InvalidHandle = 11,
+	EVROverlayError_VROverlayError_PermissionDenied = 12,
+	EVROverlayError_VROverlayError_OverlayLimitExceeded = 13,
+	EVROverlayError_VROverlayError_WrongVisibilityType = 14,
+	EVROverlayError_VROverlayError_KeyTooLong = 15,
+	EVROverlayError_VROverlayError_NameTooLong = 16,
+	EVROverlayError_VROverlayError_KeyInUse = 17,
+	EVROverlayError_VROverlayError_WrongTransformType = 18,
+	EVROverlayError_VROverlayError_InvalidTrackedDevice = 19,
+	EVROverlayError_VROverlayError_InvalidParameter = 20,
+	EVROverlayError_VROverlayError_ThumbnailCantBeDestroyed = 21,
+	EVROverlayError_VROverlayError_ArrayTooSmall = 22,
+	EVROverlayError_VROverlayError_RequestFailed = 23,
+	EVROverlayError_VROverlayError_InvalidTexture = 24,
+	EVROverlayError_VROverlayError_UnableToLoadFile = 25,
+	EVROverlayError_VROverlayError_KeyboardAlreadyInUse = 26,
+	EVROverlayError_VROverlayError_NoNeighbor = 27,
+	EVROverlayError_VROverlayError_TooManyMaskPrimitives = 29,
+	EVROverlayError_VROverlayError_BadMaskPrimitive = 30,
+	EVROverlayError_VROverlayError_TextureAlreadyLocked = 31,
+	EVROverlayError_VROverlayError_TextureLockCapacityReached = 32,
+	EVROverlayError_VROverlayError_TextureNotLocked = 33,
+	EVROverlayError_VROverlayError_TimedOut = 34,
+} EVROverlayError;
+
+typedef enum EVRApplicationType
+{
+	EVRApplicationType_VRApplication_Other = 0,
+	EVRApplicationType_VRApplication_Scene = 1,
+	EVRApplicationType_VRApplication_Overlay = 2,
+	EVRApplicationType_VRApplication_Background = 3,
+	EVRApplicationType_VRApplication_Utility = 4,
+	EVRApplicationType_VRApplication_VRMonitor = 5,
+	EVRApplicationType_VRApplication_SteamWatchdog = 6,
+	EVRApplicationType_VRApplication_Bootstrapper = 7,
+	EVRApplicationType_VRApplication_WebHelper = 8,
+	EVRApplicationType_VRApplication_OpenXRInstance = 9,
+	EVRApplicationType_VRApplication_OpenXRScene = 10,
+	EVRApplicationType_VRApplication_OpenXROverlay = 11,
+	EVRApplicationType_VRApplication_Prism = 12,
+	EVRApplicationType_VRApplication_RoomView = 13,
+	EVRApplicationType_VRApplication_Max = 14,
+} EVRApplicationType;
+
+typedef enum EVRFirmwareError
+{
+	EVRFirmwareError_VRFirmwareError_None = 0,
+	EVRFirmwareError_VRFirmwareError_Success = 1,
+	EVRFirmwareError_VRFirmwareError_Fail = 2,
+} EVRFirmwareError;
+
+typedef enum EVRNotificationError
+{
+	EVRNotificationError_VRNotificationError_OK = 0,
+	EVRNotificationError_VRNotificationError_InvalidNotificationId = 100,
+	EVRNotificationError_VRNotificationError_NotificationQueueFull = 101,
+	EVRNotificationError_VRNotificationError_InvalidOverlayHandle = 102,
+	EVRNotificationError_VRNotificationError_SystemWithUserValueAlreadyExists = 103,
+} EVRNotificationError;
+
+typedef enum EVRSkeletalMotionRange
+{
+	EVRSkeletalMotionRange_VRSkeletalMotionRange_WithController = 0,
+	EVRSkeletalMotionRange_VRSkeletalMotionRange_WithoutController = 1,
+} EVRSkeletalMotionRange;
+
+typedef enum EVRSkeletalTrackingLevel
+{
+	EVRSkeletalTrackingLevel_VRSkeletalTracking_Estimated = 0,
+	EVRSkeletalTrackingLevel_VRSkeletalTracking_Partial = 1,
+	EVRSkeletalTrackingLevel_VRSkeletalTracking_Full = 2,
+	EVRSkeletalTrackingLevel_VRSkeletalTrackingLevel_Count = 3,
+	EVRSkeletalTrackingLevel_VRSkeletalTrackingLevel_Max = 2,
+} EVRSkeletalTrackingLevel;
+
+typedef enum EVRInitError
+{
+	EVRInitError_VRInitError_None = 0,
+	EVRInitError_VRInitError_Unknown = 1,
+	EVRInitError_VRInitError_Init_InstallationNotFound = 100,
+	EVRInitError_VRInitError_Init_InstallationCorrupt = 101,
+	EVRInitError_VRInitError_Init_VRClientDLLNotFound = 102,
+	EVRInitError_VRInitError_Init_FileNotFound = 103,
+	EVRInitError_VRInitError_Init_FactoryNotFound = 104,
+	EVRInitError_VRInitError_Init_InterfaceNotFound = 105,
+	EVRInitError_VRInitError_Init_InvalidInterface = 106,
+	EVRInitError_VRInitError_Init_UserConfigDirectoryInvalid = 107,
+	EVRInitError_VRInitError_Init_HmdNotFound = 108,
+	EVRInitError_VRInitError_Init_NotInitialized = 109,
+	EVRInitError_VRInitError_Init_PathRegistryNotFound = 110,
+	EVRInitError_VRInitError_Init_NoConfigPath = 111,
+	EVRInitError_VRInitError_Init_NoLogPath = 112,
+	EVRInitError_VRInitError_Init_PathRegistryNotWritable = 113,
+	EVRInitError_VRInitError_Init_AppInfoInitFailed = 114,
+	EVRInitError_VRInitError_Init_Retry = 115,
+	EVRInitError_VRInitError_Init_InitCanceledByUser = 116,
+	EVRInitError_VRInitError_Init_AnotherAppLaunching = 117,
+	EVRInitError_VRInitError_Init_SettingsInitFailed = 118,
+	EVRInitError_VRInitError_Init_ShuttingDown = 119,
+	EVRInitError_VRInitError_Init_TooManyObjects = 120,
+	EVRInitError_VRInitError_Init_NoServerForBackgroundApp = 121,
+	EVRInitError_VRInitError_Init_NotSupportedWithCompositor = 122,
+	EVRInitError_VRInitError_Init_NotAvailableToUtilityApps = 123,
+	EVRInitError_VRInitError_Init_Internal = 124,
+	EVRInitError_VRInitError_Init_HmdDriverIdIsNone = 125,
+	EVRInitError_VRInitError_Init_HmdNotFoundPresenceFailed = 126,
+	EVRInitError_VRInitError_Init_VRMonitorNotFound = 127,
+	EVRInitError_VRInitError_Init_VRMonitorStartupFailed = 128,
+	EVRInitError_VRInitError_Init_LowPowerWatchdogNotSupported = 129,
+	EVRInitError_VRInitError_Init_InvalidApplicationType = 130,
+	EVRInitError_VRInitError_Init_NotAvailableToWatchdogApps = 131,
+	EVRInitError_VRInitError_Init_WatchdogDisabledInSettings = 132,
+	EVRInitError_VRInitError_Init_VRDashboardNotFound = 133,
+	EVRInitError_VRInitError_Init_VRDashboardStartupFailed = 134,
+	EVRInitError_VRInitError_Init_VRHomeNotFound = 135,
+	EVRInitError_VRInitError_Init_VRHomeStartupFailed = 136,
+	EVRInitError_VRInitError_Init_RebootingBusy = 137,
+	EVRInitError_VRInitError_Init_FirmwareUpdateBusy = 138,
+	EVRInitError_VRInitError_Init_FirmwareRecoveryBusy = 139,
+	EVRInitError_VRInitError_Init_USBServiceBusy = 140,
+	EVRInitError_VRInitError_Init_VRWebHelperStartupFailed = 141,
+	EVRInitError_VRInitError_Init_TrackerManagerInitFailed = 142,
+	EVRInitError_VRInitError_Init_AlreadyRunning = 143,
+	EVRInitError_VRInitError_Init_FailedForVrMonitor = 144,
+	EVRInitError_VRInitError_Init_PropertyManagerInitFailed = 145,
+	EVRInitError_VRInitError_Init_WebServerFailed = 146,
+	EVRInitError_VRInitError_Init_IllegalTypeTransition = 147,
+	EVRInitError_VRInitError_Init_MismatchedRuntimes = 148,
+	EVRInitError_VRInitError_Init_InvalidProcessId = 149,
+	EVRInitError_VRInitError_Init_VRServiceStartupFailed = 150,
+	EVRInitError_VRInitError_Init_PrismNeedsNewDrivers = 151,
+	EVRInitError_VRInitError_Init_PrismStartupTimedOut = 152,
+	EVRInitError_VRInitError_Init_CouldNotStartPrism = 153,
+	EVRInitError_VRInitError_Init_PrismClientInitFailed = 154,
+	EVRInitError_VRInitError_Init_PrismClientStartFailed = 155,
+	EVRInitError_VRInitError_Init_PrismExitedUnexpectedly = 156,
+	EVRInitError_VRInitError_Init_BadLuid = 157,
+	EVRInitError_VRInitError_Init_NoServerForAppContainer = 158,
+	EVRInitError_VRInitError_Init_DuplicateBootstrapper = 159,
+	EVRInitError_VRInitError_Init_VRDashboardServicePending = 160,
+	EVRInitError_VRInitError_Init_VRDashboardServiceTimeout = 161,
+	EVRInitError_VRInitError_Init_VRDashboardServiceStopped = 162,
+	EVRInitError_VRInitError_Init_VRDashboardAlreadyStarted = 163,
+	EVRInitError_VRInitError_Init_VRDashboardCopyFailed = 164,
+	EVRInitError_VRInitError_Init_VRDashboardTokenFailure = 165,
+	EVRInitError_VRInitError_Init_VRDashboardEnvironmentFailure = 166,
+	EVRInitError_VRInitError_Init_VRDashboardPathFailure = 167,
+	EVRInitError_VRInitError_Driver_Failed = 200,
+	EVRInitError_VRInitError_Driver_Unknown = 201,
+	EVRInitError_VRInitError_Driver_HmdUnknown = 202,
+	EVRInitError_VRInitError_Driver_NotLoaded = 203,
+	EVRInitError_VRInitError_Driver_RuntimeOutOfDate = 204,
+	EVRInitError_VRInitError_Driver_HmdInUse = 205,
+	EVRInitError_VRInitError_Driver_NotCalibrated = 206,
+	EVRInitError_VRInitError_Driver_CalibrationInvalid = 207,
+	EVRInitError_VRInitError_Driver_HmdDisplayNotFound = 208,
+	EVRInitError_VRInitError_Driver_TrackedDeviceInterfaceUnknown = 209,
+	EVRInitError_VRInitError_Driver_HmdDriverIdOutOfBounds = 211,
+	EVRInitError_VRInitError_Driver_HmdDisplayMirrored = 212,
+	EVRInitError_VRInitError_Driver_HmdDisplayNotFoundLaptop = 213,
+	EVRInitError_VRInitError_Driver_PeerDriverNotInstalled = 214,
+	EVRInitError_VRInitError_Driver_WirelessHmdNotConnected = 215,
+	EVRInitError_VRInitError_IPC_ServerInitFailed = 300,
+	EVRInitError_VRInitError_IPC_ConnectFailed = 301,
+	EVRInitError_VRInitError_IPC_SharedStateInitFailed = 302,
+	EVRInitError_VRInitError_IPC_CompositorInitFailed = 303,
+	EVRInitError_VRInitError_IPC_MutexInitFailed = 304,
+	EVRInitError_VRInitError_IPC_Failed = 305,
+	EVRInitError_VRInitError_IPC_CompositorConnectFailed = 306,
+	EVRInitError_VRInitError_IPC_CompositorInvalidConnectResponse = 307,
+	EVRInitError_VRInitError_IPC_ConnectFailedAfterMultipleAttempts = 308,
+	EVRInitError_VRInitError_IPC_ConnectFailedAfterTargetExited = 309,
+	EVRInitError_VRInitError_IPC_NamespaceUnavailable = 310,
+	EVRInitError_VRInitError_Compositor_Failed = 400,
+	EVRInitError_VRInitError_Compositor_D3D11HardwareRequired = 401,
+	EVRInitError_VRInitError_Compositor_FirmwareRequiresUpdate = 402,
+	EVRInitError_VRInitError_Compositor_OverlayInitFailed = 403,
+	EVRInitError_VRInitError_Compositor_ScreenshotsInitFailed = 404,
+	EVRInitError_VRInitError_Compositor_UnableToCreateDevice = 405,
+	EVRInitError_VRInitError_Compositor_SharedStateIsNull = 406,
+	EVRInitError_VRInitError_Compositor_NotificationManagerIsNull = 407,
+	EVRInitError_VRInitError_Compositor_ResourceManagerClientIsNull = 408,
+	EVRInitError_VRInitError_Compositor_MessageOverlaySharedStateInitFailure = 409,
+	EVRInitError_VRInitError_Compositor_PropertiesInterfaceIsNull = 410,
+	EVRInitError_VRInitError_Compositor_CreateFullscreenWindowFailed = 411,
+	EVRInitError_VRInitError_Compositor_SettingsInterfaceIsNull = 412,
+	EVRInitError_VRInitError_Compositor_FailedToShowWindow = 413,
+	EVRInitError_VRInitError_Compositor_DistortInterfaceIsNull = 414,
+	EVRInitError_VRInitError_Compositor_DisplayFrequencyFailure = 415,
+	EVRInitError_VRInitError_Compositor_RendererInitializationFailed = 416,
+	EVRInitError_VRInitError_Compositor_DXGIFactoryInterfaceIsNull = 417,
+	EVRInitError_VRInitError_Compositor_DXGIFactoryCreateFailed = 418,
+	EVRInitError_VRInitError_Compositor_DXGIFactoryQueryFailed = 419,
+	EVRInitError_VRInitError_Compositor_InvalidAdapterDesktop = 420,
+	EVRInitError_VRInitError_Compositor_InvalidHmdAttachment = 421,
+	EVRInitError_VRInitError_Compositor_InvalidOutputDesktop = 422,
+	EVRInitError_VRInitError_Compositor_InvalidDeviceProvided = 423,
+	EVRInitError_VRInitError_Compositor_D3D11RendererInitializationFailed = 424,
+	EVRInitError_VRInitError_Compositor_FailedToFindDisplayMode = 425,
+	EVRInitError_VRInitError_Compositor_FailedToCreateSwapChain = 426,
+	EVRInitError_VRInitError_Compositor_FailedToGetBackBuffer = 427,
+	EVRInitError_VRInitError_Compositor_FailedToCreateRenderTarget = 428,
+	EVRInitError_VRInitError_Compositor_FailedToCreateDXGI2SwapChain = 429,
+	EVRInitError_VRInitError_Compositor_FailedtoGetDXGI2BackBuffer = 430,
+	EVRInitError_VRInitError_Compositor_FailedToCreateDXGI2RenderTarget = 431,
+	EVRInitError_VRInitError_Compositor_FailedToGetDXGIDeviceInterface = 432,
+	EVRInitError_VRInitError_Compositor_SelectDisplayMode = 433,
+	EVRInitError_VRInitError_Compositor_FailedToCreateNvAPIRenderTargets = 434,
+	EVRInitError_VRInitError_Compositor_NvAPISetDisplayMode = 435,
+	EVRInitError_VRInitError_Compositor_FailedToCreateDirectModeDisplay = 436,
+	EVRInitError_VRInitError_Compositor_InvalidHmdPropertyContainer = 437,
+	EVRInitError_VRInitError_Compositor_UpdateDisplayFrequency = 438,
+	EVRInitError_VRInitError_Compositor_CreateRasterizerState = 439,
+	EVRInitError_VRInitError_Compositor_CreateWireframeRasterizerState = 440,
+	EVRInitError_VRInitError_Compositor_CreateSamplerState = 441,
+	EVRInitError_VRInitError_Compositor_CreateClampToBorderSamplerState = 442,
+	EVRInitError_VRInitError_Compositor_CreateAnisoSamplerState = 443,
+	EVRInitError_VRInitError_Compositor_CreateOverlaySamplerState = 444,
+	EVRInitError_VRInitError_Compositor_CreatePanoramaSamplerState = 445,
+	EVRInitError_VRInitError_Compositor_CreateFontSamplerState = 446,
+	EVRInitError_VRInitError_Compositor_CreateNoBlendState = 447,
+	EVRInitError_VRInitError_Compositor_CreateBlendState = 448,
+	EVRInitError_VRInitError_Compositor_CreateAlphaBlendState = 449,
+	EVRInitError_VRInitError_Compositor_CreateBlendStateMaskR = 450,
+	EVRInitError_VRInitError_Compositor_CreateBlendStateMaskG = 451,
+	EVRInitError_VRInitError_Compositor_CreateBlendStateMaskB = 452,
+	EVRInitError_VRInitError_Compositor_CreateDepthStencilState = 453,
+	EVRInitError_VRInitError_Compositor_CreateDepthStencilStateNoWrite = 454,
+	EVRInitError_VRInitError_Compositor_CreateDepthStencilStateNoDepth = 455,
+	EVRInitError_VRInitError_Compositor_CreateFlushTexture = 456,
+	EVRInitError_VRInitError_Compositor_CreateDistortionSurfaces = 457,
+	EVRInitError_VRInitError_Compositor_CreateConstantBuffer = 458,
+	EVRInitError_VRInitError_Compositor_CreateHmdPoseConstantBuffer = 459,
+	EVRInitError_VRInitError_Compositor_CreateHmdPoseStagingConstantBuffer = 460,
+	EVRInitError_VRInitError_Compositor_CreateSharedFrameInfoConstantBuffer = 461,
+	EVRInitError_VRInitError_Compositor_CreateOverlayConstantBuffer = 462,
+	EVRInitError_VRInitError_Compositor_CreateSceneTextureIndexConstantBuffer = 463,
+	EVRInitError_VRInitError_Compositor_CreateReadableSceneTextureIndexConstantBuffer = 464,
+	EVRInitError_VRInitError_Compositor_CreateLayerGraphicsTextureIndexConstantBuffer = 465,
+	EVRInitError_VRInitError_Compositor_CreateLayerComputeTextureIndexConstantBuffer = 466,
+	EVRInitError_VRInitError_Compositor_CreateLayerComputeSceneTextureIndexConstantBuffer = 467,
+	EVRInitError_VRInitError_Compositor_CreateComputeHmdPoseConstantBuffer = 468,
+	EVRInitError_VRInitError_Compositor_CreateGeomConstantBuffer = 469,
+	EVRInitError_VRInitError_Compositor_CreatePanelMaskConstantBuffer = 470,
+	EVRInitError_VRInitError_Compositor_CreatePixelSimUBO = 471,
+	EVRInitError_VRInitError_Compositor_CreateMSAARenderTextures = 472,
+	EVRInitError_VRInitError_Compositor_CreateResolveRenderTextures = 473,
+	EVRInitError_VRInitError_Compositor_CreateComputeResolveRenderTextures = 474,
+	EVRInitError_VRInitError_Compositor_CreateDriverDirectModeResolveTextures = 475,
+	EVRInitError_VRInitError_Compositor_OpenDriverDirectModeResolveTextures = 476,
+	EVRInitError_VRInitError_Compositor_CreateFallbackSyncTexture = 477,
+	EVRInitError_VRInitError_Compositor_ShareFallbackSyncTexture = 478,
+	EVRInitError_VRInitError_Compositor_CreateOverlayIndexBuffer = 479,
+	EVRInitError_VRInitError_Compositor_CreateOverlayVertexBuffer = 480,
+	EVRInitError_VRInitError_Compositor_CreateTextVertexBuffer = 481,
+	EVRInitError_VRInitError_Compositor_CreateTextIndexBuffer = 482,
+	EVRInitError_VRInitError_Compositor_CreateMirrorTextures = 483,
+	EVRInitError_VRInitError_Compositor_CreateLastFrameRenderTexture = 484,
+	EVRInitError_VRInitError_Compositor_CreateMirrorOverlay = 485,
+	EVRInitError_VRInitError_Compositor_FailedToCreateVirtualDisplayBackbuffer = 486,
+	EVRInitError_VRInitError_Compositor_DisplayModeNotSupported = 487,
+	EVRInitError_VRInitError_Compositor_CreateOverlayInvalidCall = 488,
+	EVRInitError_VRInitError_Compositor_CreateOverlayAlreadyInitialized = 489,
+	EVRInitError_VRInitError_Compositor_FailedToCreateMailbox = 490,
+	EVRInitError_VRInitError_Compositor_WindowInterfaceIsNull = 491,
+	EVRInitError_VRInitError_Compositor_SystemLayerCreateInstance = 492,
+	EVRInitError_VRInitError_Compositor_SystemLayerCreateSession = 493,
+	EVRInitError_VRInitError_Compoistor_CreateInverseDistortUVs = 494,
+	EVRInitError_VRInitError_Compoistor_CreateBackbufferDepth = 495,
+	EVRInitError_VRInitError_VendorSpecific_UnableToConnectToOculusRuntime = 1000,
+	EVRInitError_VRInitError_VendorSpecific_WindowsNotInDevMode = 1001,
+	EVRInitError_VRInitError_VendorSpecific_OculusLinkNotEnabled = 1002,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantOpenDevice = 1101,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToRequestConfigStart = 1102,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_NoStoredConfig = 1103,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooBig = 1104,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigTooSmall = 1105,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToInitZLib = 1106,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_CantReadFirmwareVersion = 1107,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToSendUserDataStart = 1108,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataStart = 1109,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnableToGetUserDataNext = 1110,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataAddressRange = 1111,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UserDataError = 1112,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_ConfigFailedSanityCheck = 1113,
+	EVRInitError_VRInitError_VendorSpecific_OculusRuntimeBadInstall = 1114,
+	EVRInitError_VRInitError_VendorSpecific_HmdFound_UnexpectedConfiguration_1 = 1115,
+	EVRInitError_VRInitError_Steam_SteamInstallationNotFound = 2000,
+	EVRInitError_VRInitError_LastError = 2001,
+} EVRInitError;
+
+typedef enum EVRScreenshotType
+{
+	EVRScreenshotType_VRScreenshotType_None = 0,
+	EVRScreenshotType_VRScreenshotType_Mono = 1,
+	EVRScreenshotType_VRScreenshotType_Stereo = 2,
+	EVRScreenshotType_VRScreenshotType_Cubemap = 3,
+	EVRScreenshotType_VRScreenshotType_MonoPanorama = 4,
+	EVRScreenshotType_VRScreenshotType_StereoPanorama = 5,
+} EVRScreenshotType;
+
+typedef enum EVRScreenshotPropertyFilenames
+{
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_Preview = 0,
+	EVRScreenshotPropertyFilenames_VRScreenshotPropertyFilenames_VR = 1,
+} EVRScreenshotPropertyFilenames;
+
+typedef enum EVRTrackedCameraError
+{
+	EVRTrackedCameraError_VRTrackedCameraError_None = 0,
+	EVRTrackedCameraError_VRTrackedCameraError_OperationFailed = 100,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidHandle = 101,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameHeaderVersion = 102,
+	EVRTrackedCameraError_VRTrackedCameraError_OutOfHandles = 103,
+	EVRTrackedCameraError_VRTrackedCameraError_IPCFailure = 104,
+	EVRTrackedCameraError_VRTrackedCameraError_NotSupportedForThisDevice = 105,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedMemoryFailure = 106,
+	EVRTrackedCameraError_VRTrackedCameraError_FrameBufferingFailure = 107,
+	EVRTrackedCameraError_VRTrackedCameraError_StreamSetupFailure = 108,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidGLTextureId = 109,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidSharedTextureHandle = 110,
+	EVRTrackedCameraError_VRTrackedCameraError_FailedToGetGLTextureId = 111,
+	EVRTrackedCameraError_VRTrackedCameraError_SharedTextureFailure = 112,
+	EVRTrackedCameraError_VRTrackedCameraError_NoFrameAvailable = 113,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidArgument = 114,
+	EVRTrackedCameraError_VRTrackedCameraError_InvalidFrameBufferSize = 115,
+} EVRTrackedCameraError;
+
+typedef enum EVRTrackedCameraFrameLayout
+{
+	EVRTrackedCameraFrameLayout_Mono = 1,
+	EVRTrackedCameraFrameLayout_Stereo = 2,
+	EVRTrackedCameraFrameLayout_VerticalLayout = 16,
+	EVRTrackedCameraFrameLayout_HorizontalLayout = 32,
+} EVRTrackedCameraFrameLayout;
+
+typedef enum EVRTrackedCameraFrameType
+{
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Distorted = 0,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_Undistorted = 1,
+	EVRTrackedCameraFrameType_VRTrackedCameraFrameType_MaximumUndistorted = 2,
+	EVRTrackedCameraFrameType_MAX_CAMERA_FRAME_TYPES = 3,
+} EVRTrackedCameraFrameType;
+
+typedef enum EVRDistortionFunctionType
+{
+	EVRDistortionFunctionType_VRDistortionFunctionType_None = 0,
+	EVRDistortionFunctionType_VRDistortionFunctionType_FTheta = 1,
+	EVRDistortionFunctionType_VRDistortionFunctionType_Extended_FTheta = 2,
+	EVRDistortionFunctionType_MAX_DISTORTION_FUNCTION_TYPES = 3,
+} EVRDistortionFunctionType;
+
+typedef enum EVSync
+{
+	EVSync_VSync_None = 0,
+	EVSync_VSync_WaitRender = 1,
+	EVSync_VSync_NoWaitRender = 2,
+} EVSync;
+
+typedef enum EVRMuraCorrectionMode
+{
+	EVRMuraCorrectionMode_Default = 0,
+	EVRMuraCorrectionMode_NoCorrection = 1,
+} EVRMuraCorrectionMode;
+
+typedef enum Imu_OffScaleFlags
+{
+	Imu_OffScaleFlags_OffScale_AccelX = 1,
+	Imu_OffScaleFlags_OffScale_AccelY = 2,
+	Imu_OffScaleFlags_OffScale_AccelZ = 4,
+	Imu_OffScaleFlags_OffScale_GyroX = 8,
+	Imu_OffScaleFlags_OffScale_GyroY = 16,
+	Imu_OffScaleFlags_OffScale_GyroZ = 32,
+} Imu_OffScaleFlags;
+
+typedef enum EVRApplicationError
+{
+	EVRApplicationError_VRApplicationError_None = 0,
+	EVRApplicationError_VRApplicationError_AppKeyAlreadyExists = 100,
+	EVRApplicationError_VRApplicationError_NoManifest = 101,
+	EVRApplicationError_VRApplicationError_NoApplication = 102,
+	EVRApplicationError_VRApplicationError_InvalidIndex = 103,
+	EVRApplicationError_VRApplicationError_UnknownApplication = 104,
+	EVRApplicationError_VRApplicationError_IPCFailed = 105,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyRunning = 106,
+	EVRApplicationError_VRApplicationError_InvalidManifest = 107,
+	EVRApplicationError_VRApplicationError_InvalidApplication = 108,
+	EVRApplicationError_VRApplicationError_LaunchFailed = 109,
+	EVRApplicationError_VRApplicationError_ApplicationAlreadyStarting = 110,
+	EVRApplicationError_VRApplicationError_LaunchInProgress = 111,
+	EVRApplicationError_VRApplicationError_OldApplicationQuitting = 112,
+	EVRApplicationError_VRApplicationError_TransitionAborted = 113,
+	EVRApplicationError_VRApplicationError_IsTemplate = 114,
+	EVRApplicationError_VRApplicationError_SteamVRIsExiting = 115,
+	EVRApplicationError_VRApplicationError_BufferTooSmall = 200,
+	EVRApplicationError_VRApplicationError_PropertyNotSet = 201,
+	EVRApplicationError_VRApplicationError_UnknownProperty = 202,
+	EVRApplicationError_VRApplicationError_InvalidParameter = 203,
+	EVRApplicationError_VRApplicationError_NotImplemented = 300,
+} EVRApplicationError;
+
+typedef enum EVRApplicationProperty
+{
+	EVRApplicationProperty_VRApplicationProperty_Name_String = 0,
+	EVRApplicationProperty_VRApplicationProperty_LaunchType_String = 11,
+	EVRApplicationProperty_VRApplicationProperty_WorkingDirectory_String = 12,
+	EVRApplicationProperty_VRApplicationProperty_BinaryPath_String = 13,
+	EVRApplicationProperty_VRApplicationProperty_Arguments_String = 14,
+	EVRApplicationProperty_VRApplicationProperty_URL_String = 15,
+	EVRApplicationProperty_VRApplicationProperty_Description_String = 50,
+	EVRApplicationProperty_VRApplicationProperty_NewsURL_String = 51,
+	EVRApplicationProperty_VRApplicationProperty_ImagePath_String = 52,
+	EVRApplicationProperty_VRApplicationProperty_Source_String = 53,
+	EVRApplicationProperty_VRApplicationProperty_ActionManifestURL_String = 54,
+	EVRApplicationProperty_VRApplicationProperty_IsDashboardOverlay_Bool = 60,
+	EVRApplicationProperty_VRApplicationProperty_IsTemplate_Bool = 61,
+	EVRApplicationProperty_VRApplicationProperty_IsInstanced_Bool = 62,
+	EVRApplicationProperty_VRApplicationProperty_IsInternal_Bool = 63,
+	EVRApplicationProperty_VRApplicationProperty_WantsCompositorPauseInStandby_Bool = 64,
+	EVRApplicationProperty_VRApplicationProperty_IsHidden_Bool = 65,
+	EVRApplicationProperty_VRApplicationProperty_LastLaunchTime_Uint64 = 70,
+} EVRApplicationProperty;
+
+typedef enum EVRSceneApplicationState
+{
+	EVRSceneApplicationState_None = 0,
+	EVRSceneApplicationState_Starting = 1,
+	EVRSceneApplicationState_Quitting = 2,
+	EVRSceneApplicationState_Running = 3,
+	EVRSceneApplicationState_Waiting = 4,
+} EVRSceneApplicationState;
+
+typedef enum ChaperoneCalibrationState
+{
+	ChaperoneCalibrationState_OK = 1,
+	ChaperoneCalibrationState_Warning = 100,
+	ChaperoneCalibrationState_Warning_BaseStationMayHaveMoved = 101,
+	ChaperoneCalibrationState_Warning_BaseStationRemoved = 102,
+	ChaperoneCalibrationState_Warning_SeatedBoundsInvalid = 103,
+	ChaperoneCalibrationState_Error = 200,
+	ChaperoneCalibrationState_Error_BaseStationUninitialized = 201,
+	ChaperoneCalibrationState_Error_BaseStationConflict = 202,
+	ChaperoneCalibrationState_Error_PlayAreaInvalid = 203,
+	ChaperoneCalibrationState_Error_CollisionBoundsInvalid = 204,
+} ChaperoneCalibrationState;
+
+typedef enum EChaperoneConfigFile
+{
+	EChaperoneConfigFile_Live = 1,
+	EChaperoneConfigFile_Temp = 2,
+} EChaperoneConfigFile;
+
+typedef enum EChaperoneImportFlags
+{
+	EChaperoneImportFlags_EChaperoneImport_BoundsOnly = 1,
+} EChaperoneImportFlags;
+
+typedef enum EVRCompositorError
+{
+	EVRCompositorError_VRCompositorError_None = 0,
+	EVRCompositorError_VRCompositorError_RequestFailed = 1,
+	EVRCompositorError_VRCompositorError_IncompatibleVersion = 100,
+	EVRCompositorError_VRCompositorError_DoNotHaveFocus = 101,
+	EVRCompositorError_VRCompositorError_InvalidTexture = 102,
+	EVRCompositorError_VRCompositorError_IsNotSceneApplication = 103,
+	EVRCompositorError_VRCompositorError_TextureIsOnWrongDevice = 104,
+	EVRCompositorError_VRCompositorError_TextureUsesUnsupportedFormat = 105,
+	EVRCompositorError_VRCompositorError_SharedTexturesNotSupported = 106,
+	EVRCompositorError_VRCompositorError_IndexOutOfRange = 107,
+	EVRCompositorError_VRCompositorError_AlreadySubmitted = 108,
+	EVRCompositorError_VRCompositorError_InvalidBounds = 109,
+	EVRCompositorError_VRCompositorError_AlreadySet = 110,
+} EVRCompositorError;
+
+typedef enum EVRCompositorTimingMode
+{
+	EVRCompositorTimingMode_VRCompositorTimingMode_Implicit = 0,
+	EVRCompositorTimingMode_VRCompositorTimingMode_Explicit_RuntimePerformsPostPresentHandoff = 1,
+	EVRCompositorTimingMode_VRCompositorTimingMode_Explicit_ApplicationPerformsPostPresentHandoff = 2,
+} EVRCompositorTimingMode;
+
+typedef enum VROverlayInputMethod
+{
+	VROverlayInputMethod_None = 0,
+	VROverlayInputMethod_Mouse = 1,
+} VROverlayInputMethod;
+
+typedef enum VROverlayTransformType
+{
+	VROverlayTransformType_VROverlayTransform_Invalid = -1,
+	VROverlayTransformType_VROverlayTransform_Absolute = 0,
+	VROverlayTransformType_VROverlayTransform_TrackedDeviceRelative = 1,
+	VROverlayTransformType_VROverlayTransform_SystemOverlay = 2,
+	VROverlayTransformType_VROverlayTransform_TrackedComponent = 3,
+	VROverlayTransformType_VROverlayTransform_Cursor = 4,
+	VROverlayTransformType_VROverlayTransform_DashboardTab = 5,
+	VROverlayTransformType_VROverlayTransform_DashboardThumb = 6,
+	VROverlayTransformType_VROverlayTransform_Mountable = 7,
+	VROverlayTransformType_VROverlayTransform_Projection = 8,
+} VROverlayTransformType;
+
+typedef enum VROverlayFlags
+{
+	VROverlayFlags_NoDashboardTab = 8,
+	VROverlayFlags_SendVRDiscreteScrollEvents = 64,
+	VROverlayFlags_SendVRTouchpadEvents = 128,
+	VROverlayFlags_ShowTouchPadScrollWheel = 256,
+	VROverlayFlags_TransferOwnershipToInternalProcess = 512,
+	VROverlayFlags_SideBySide_Parallel = 1024,
+	VROverlayFlags_SideBySide_Crossed = 2048,
+	VROverlayFlags_Panorama = 4096,
+	VROverlayFlags_StereoPanorama = 8192,
+	VROverlayFlags_SortWithNonSceneOverlays = 16384,
+	VROverlayFlags_VisibleInDashboard = 32768,
+	VROverlayFlags_MakeOverlaysInteractiveIfVisible = 65536,
+	VROverlayFlags_SendVRSmoothScrollEvents = 131072,
+	VROverlayFlags_ProtectedContent = 262144,
+	VROverlayFlags_HideLaserIntersection = 524288,
+	VROverlayFlags_WantsModalBehavior = 1048576,
+	VROverlayFlags_IsPremultiplied = 2097152,
+	VROverlayFlags_IgnoreTextureAlpha = 4194304,
+	VROverlayFlags_EnableControlBar = 8388608,
+	VROverlayFlags_EnableControlBarKeyboard = 16777216,
+	VROverlayFlags_EnableControlBarClose = 33554432,
+} VROverlayFlags;
+
+typedef 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,
+} VRMessageOverlayResponse;
+
+typedef enum EGamepadTextInputMode
+{
+	EGamepadTextInputMode_k_EGamepadTextInputModeNormal = 0,
+	EGamepadTextInputMode_k_EGamepadTextInputModePassword = 1,
+	EGamepadTextInputMode_k_EGamepadTextInputModeSubmit = 2,
+} EGamepadTextInputMode;
+
+typedef enum EGamepadTextInputLineMode
+{
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeSingleLine = 0,
+	EGamepadTextInputLineMode_k_EGamepadTextInputLineModeMultipleLines = 1,
+} EGamepadTextInputLineMode;
+
+typedef enum EVROverlayIntersectionMaskPrimitiveType
+{
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Rectangle = 0,
+	EVROverlayIntersectionMaskPrimitiveType_OverlayIntersectionPrimitiveType_Circle = 1,
+} EVROverlayIntersectionMaskPrimitiveType;
+
+typedef enum EKeyboardFlags
+{
+	EKeyboardFlags_KeyboardFlag_Minimal = 1,
+	EKeyboardFlags_KeyboardFlag_Modal = 2,
+} EKeyboardFlags;
+
+typedef enum EDeviceType
+{
+	EDeviceType_DeviceType_Invalid = -1,
+	EDeviceType_DeviceType_DirectX11 = 0,
+	EDeviceType_DeviceType_Vulkan = 1,
+} EDeviceType;
+
+typedef enum HeadsetViewMode_t
+{
+	HeadsetViewMode_t_HeadsetViewMode_Left = 0,
+	HeadsetViewMode_t_HeadsetViewMode_Right = 1,
+	HeadsetViewMode_t_HeadsetViewMode_Both = 2,
+} HeadsetViewMode_t;
+
+typedef enum EVRRenderModelError
+{
+	EVRRenderModelError_VRRenderModelError_None = 0,
+	EVRRenderModelError_VRRenderModelError_Loading = 100,
+	EVRRenderModelError_VRRenderModelError_NotSupported = 200,
+	EVRRenderModelError_VRRenderModelError_InvalidArg = 300,
+	EVRRenderModelError_VRRenderModelError_InvalidModel = 301,
+	EVRRenderModelError_VRRenderModelError_NoShapes = 302,
+	EVRRenderModelError_VRRenderModelError_MultipleShapes = 303,
+	EVRRenderModelError_VRRenderModelError_TooManyVertices = 304,
+	EVRRenderModelError_VRRenderModelError_MultipleTextures = 305,
+	EVRRenderModelError_VRRenderModelError_BufferTooSmall = 306,
+	EVRRenderModelError_VRRenderModelError_NotEnoughNormals = 307,
+	EVRRenderModelError_VRRenderModelError_NotEnoughTexCoords = 308,
+	EVRRenderModelError_VRRenderModelError_InvalidTexture = 400,
+} EVRRenderModelError;
+
+typedef enum EVRRenderModelTextureFormat
+{
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_RGBA8_SRGB = 0,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_BC2 = 1,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_BC4 = 2,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_BC7 = 3,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_BC7_SRGB = 4,
+	EVRRenderModelTextureFormat_VRRenderModelTextureFormat_RGBA16_FLOAT = 5,
+} EVRRenderModelTextureFormat;
+
+typedef enum EVRNotificationType
+{
+	EVRNotificationType_Transient = 0,
+	EVRNotificationType_Persistent = 1,
+	EVRNotificationType_Transient_SystemWithUserValue = 2,
+} EVRNotificationType;
+
+typedef enum EVRNotificationStyle
+{
+	EVRNotificationStyle_None = 0,
+	EVRNotificationStyle_Application = 100,
+	EVRNotificationStyle_Contact_Disabled = 200,
+	EVRNotificationStyle_Contact_Enabled = 201,
+	EVRNotificationStyle_Contact_Active = 202,
+} EVRNotificationStyle;
+
+typedef enum EVRSettingsError
+{
+	EVRSettingsError_VRSettingsError_None = 0,
+	EVRSettingsError_VRSettingsError_IPCFailed = 1,
+	EVRSettingsError_VRSettingsError_WriteFailed = 2,
+	EVRSettingsError_VRSettingsError_ReadFailed = 3,
+	EVRSettingsError_VRSettingsError_JsonParseFailed = 4,
+	EVRSettingsError_VRSettingsError_UnsetSettingHasNoDefault = 5,
+} EVRSettingsError;
+
+typedef enum EVRScreenshotError
+{
+	EVRScreenshotError_VRScreenshotError_None = 0,
+	EVRScreenshotError_VRScreenshotError_RequestFailed = 1,
+	EVRScreenshotError_VRScreenshotError_IncompatibleVersion = 100,
+	EVRScreenshotError_VRScreenshotError_NotFound = 101,
+	EVRScreenshotError_VRScreenshotError_BufferTooSmall = 102,
+	EVRScreenshotError_VRScreenshotError_ScreenshotAlreadyInProgress = 108,
+} EVRScreenshotError;
+
+typedef enum EVRSkeletalTransformSpace
+{
+	EVRSkeletalTransformSpace_VRSkeletalTransformSpace_Model = 0,
+	EVRSkeletalTransformSpace_VRSkeletalTransformSpace_Parent = 1,
+} EVRSkeletalTransformSpace;
+
+typedef enum EVRSkeletalReferencePose
+{
+	EVRSkeletalReferencePose_VRSkeletalReferencePose_BindPose = 0,
+	EVRSkeletalReferencePose_VRSkeletalReferencePose_OpenHand = 1,
+	EVRSkeletalReferencePose_VRSkeletalReferencePose_Fist = 2,
+	EVRSkeletalReferencePose_VRSkeletalReferencePose_GripLimit = 3,
+} EVRSkeletalReferencePose;
+
+typedef enum EVRFinger
+{
+	EVRFinger_VRFinger_Thumb = 0,
+	EVRFinger_VRFinger_Index = 1,
+	EVRFinger_VRFinger_Middle = 2,
+	EVRFinger_VRFinger_Ring = 3,
+	EVRFinger_VRFinger_Pinky = 4,
+	EVRFinger_VRFinger_Count = 5,
+} EVRFinger;
+
+typedef enum EVRFingerSplay
+{
+	EVRFingerSplay_VRFingerSplay_Thumb_Index = 0,
+	EVRFingerSplay_VRFingerSplay_Index_Middle = 1,
+	EVRFingerSplay_VRFingerSplay_Middle_Ring = 2,
+	EVRFingerSplay_VRFingerSplay_Ring_Pinky = 3,
+	EVRFingerSplay_VRFingerSplay_Count = 4,
+} EVRFingerSplay;
+
+typedef enum EVRSummaryType
+{
+	EVRSummaryType_VRSummaryType_FromAnimation = 0,
+	EVRSummaryType_VRSummaryType_FromDevice = 1,
+} EVRSummaryType;
+
+typedef enum EVRInputFilterCancelType
+{
+	EVRInputFilterCancelType_VRInputFilterCancel_Timers = 0,
+	EVRInputFilterCancelType_VRInputFilterCancel_Momentum = 1,
+} EVRInputFilterCancelType;
+
+typedef enum EVRInputStringBits
+{
+	EVRInputStringBits_VRInputString_Hand = 1,
+	EVRInputStringBits_VRInputString_ControllerType = 2,
+	EVRInputStringBits_VRInputString_InputSource = 4,
+	EVRInputStringBits_VRInputString_All = -1,
+} EVRInputStringBits;
+
+typedef enum EIOBufferError
+{
+	EIOBufferError_IOBuffer_Success = 0,
+	EIOBufferError_IOBuffer_OperationFailed = 100,
+	EIOBufferError_IOBuffer_InvalidHandle = 101,
+	EIOBufferError_IOBuffer_InvalidArgument = 102,
+	EIOBufferError_IOBuffer_PathExists = 103,
+	EIOBufferError_IOBuffer_PathDoesNotExist = 104,
+	EIOBufferError_IOBuffer_Permission = 105,
+} EIOBufferError;
+
+typedef enum EIOBufferMode
+{
+	EIOBufferMode_IOBufferMode_Read = 1,
+	EIOBufferMode_IOBufferMode_Write = 2,
+	EIOBufferMode_IOBufferMode_Create = 512,
+} EIOBufferMode;
+
+typedef enum EVRDebugError
+{
+	EVRDebugError_VRDebugError_Success = 0,
+	EVRDebugError_VRDebugError_BadParameter = 1,
+} EVRDebugError;
+
+typedef enum EPropertyWriteType
+{
+	EPropertyWriteType_PropertyWrite_Set = 0,
+	EPropertyWriteType_PropertyWrite_Erase = 1,
+	EPropertyWriteType_PropertyWrite_SetError = 2,
+} EPropertyWriteType;
+
+typedef enum EBlockQueueError
+{
+	EBlockQueueError_BlockQueueError_None = 0,
+	EBlockQueueError_BlockQueueError_QueueAlreadyExists = 1,
+	EBlockQueueError_BlockQueueError_QueueNotFound = 2,
+	EBlockQueueError_BlockQueueError_BlockNotAvailable = 3,
+	EBlockQueueError_BlockQueueError_InvalidHandle = 4,
+	EBlockQueueError_BlockQueueError_InvalidParam = 5,
+	EBlockQueueError_BlockQueueError_ParamMismatch = 6,
+	EBlockQueueError_BlockQueueError_InternalError = 7,
+	EBlockQueueError_BlockQueueError_AlreadyInitialized = 8,
+	EBlockQueueError_BlockQueueError_OperationIsServerOnly = 9,
+	EBlockQueueError_BlockQueueError_TooManyConnections = 10,
+} EBlockQueueError;
+
+typedef enum EBlockQueueReadType
+{
+	EBlockQueueReadType_BlockQueueRead_Latest = 0,
+	EBlockQueueReadType_BlockQueueRead_New = 1,
+	EBlockQueueReadType_BlockQueueRead_Next = 2,
+} EBlockQueueReadType;
+
+typedef enum EBlockQueueCreationFlag
+{
+	EBlockQueueCreationFlag_BlockQueueFlag_OwnerIsReader = 1,
+} EBlockQueueCreationFlag;
+
+
+// OpenVR typedefs
+
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint32_t VRNotificationId;
+typedef uint64_t VROverlayHandle_t;
+
+typedef uint32_t PropertyTypeTag_t;
+typedef uint32_t SpatialAnchorHandle_t;
+typedef void * glSharedTextureHandle_t;
+typedef int32_t glInt_t;
+typedef uint32_t glUInt_t;
+typedef uint64_t SharedTextureHandle_t;
+typedef uint32_t DriverId_t;
+typedef uint32_t TrackedDeviceIndex_t;
+typedef uint64_t WebConsoleHandle_t;
+typedef uint64_t PropertyContainerHandle_t;
+typedef uint32_t PropertyTypeTag_t;
+typedef PropertyContainerHandle_t DriverHandle_t;
+typedef uint64_t VRActionHandle_t;
+typedef uint64_t VRActionSetHandle_t;
+typedef uint64_t VRInputValueHandle_t;
+typedef uint32_t VRComponentProperties;
+typedef uint64_t VROverlayHandle_t;
+typedef int32_t BoneIndex_t;
+typedef uint64_t TrackedCameraHandle_t;
+typedef uint32_t ScreenshotHandle_t;
+typedef int32_t TextureID_t;
+typedef uint32_t VRNotificationId;
+typedef uint64_t IOBufferHandle_t;
+typedef uint64_t VrProfilerEventHandle_t;
+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;
+typedef uint64_t PathHandle_t;
+
+// OpenVR Structs
+
+typedef struct HmdMatrix34_t
+{
+	float m[3][4]; //float[3][4]
+} HmdMatrix34_t;
+
+typedef struct HmdMatrix33_t
+{
+	float m[3][3]; //float[3][3]
+} HmdMatrix33_t;
+
+typedef struct HmdMatrix44_t
+{
+	float m[4][4]; //float[4][4]
+} HmdMatrix44_t;
+
+typedef struct HmdVector3_t
+{
+	float v[3]; //float[3]
+} HmdVector3_t;
+
+typedef struct HmdVector4_t
+{
+	float v[4]; //float[4]
+} HmdVector4_t;
+
+typedef struct HmdVector3d_t
+{
+	double v[3]; //double[3]
+} HmdVector3d_t;
+
+typedef struct HmdVector2_t
+{
+	float v[2]; //float[2]
+} HmdVector2_t;
+
+typedef struct HmdQuaternion_t
+{
+	double w;
+	double x;
+	double y;
+	double z;
+} HmdQuaternion_t;
+
+typedef struct HmdQuaternionf_t
+{
+	float w;
+	float x;
+	float y;
+	float z;
+} HmdQuaternionf_t;
+
+typedef struct HmdColor_t
+{
+	float r;
+	float g;
+	float b;
+	float a;
+} HmdColor_t;
+
+typedef struct HmdQuad_t
+{
+	struct HmdVector3_t vCorners[4]; //struct vr::HmdVector3_t[4]
+} HmdQuad_t;
+
+typedef struct HmdRect2_t
+{
+	struct HmdVector2_t vTopLeft;
+	struct HmdVector2_t vBottomRight;
+} HmdRect2_t;
+
+typedef struct VRBoneTransform_t
+{
+	struct HmdVector4_t position;
+	struct HmdQuaternionf_t orientation;
+} VRBoneTransform_t;
+
+typedef struct DistortionCoordinates_t
+{
+	float rfRed[2]; //float[2]
+	float rfGreen[2]; //float[2]
+	float rfBlue[2]; //float[2]
+} DistortionCoordinates_t;
+
+typedef struct Texture_t
+{
+	void * handle; // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+} Texture_t;
+
+typedef struct TrackedDevicePose_t
+{
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+	struct HmdVector3_t vVelocity;
+	struct HmdVector3_t vAngularVelocity;
+	enum ETrackingResult eTrackingResult;
+	bool bPoseIsValid;
+	bool bDeviceIsConnected;
+} TrackedDevicePose_t;
+
+typedef struct VRTextureBounds_t
+{
+	float uMin;
+	float vMin;
+	float uMax;
+	float vMax;
+} VRTextureBounds_t;
+
+typedef struct VRTextureWithPose_t
+{
+	void * handle; // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+} VRTextureWithPose_t;
+
+typedef struct VRTextureDepthInfo_t
+{
+	void * handle; // void *
+	struct HmdMatrix44_t mProjection;
+	struct HmdVector2_t vRange;
+} VRTextureDepthInfo_t;
+
+typedef struct VRTextureWithDepth_t
+{
+	void * handle; // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+	struct VRTextureDepthInfo_t depth;
+} VRTextureWithDepth_t;
+
+typedef struct VRTextureWithPoseAndDepth_t
+{
+	void * handle; // void *
+	enum ETextureType eType;
+	enum EColorSpace eColorSpace;
+	struct HmdMatrix34_t mDeviceToAbsoluteTracking;
+	struct VRTextureDepthInfo_t depth;
+} VRTextureWithPoseAndDepth_t;
+
+typedef struct VRVulkanTextureData_t
+{
+	uint64_t m_nImage;
+	struct VkDevice_T * m_pDevice; // struct VkDevice_T *
+	struct VkPhysicalDevice_T * m_pPhysicalDevice; // struct VkPhysicalDevice_T *
+	struct VkInstance_T * m_pInstance; // struct VkInstance_T *
+	struct VkQueue_T * m_pQueue; // struct VkQueue_T *
+	uint32_t m_nQueueFamilyIndex;
+	uint32_t m_nWidth;
+	uint32_t m_nHeight;
+	uint32_t m_nFormat;
+	uint32_t m_nSampleCount;
+} VRVulkanTextureData_t;
+
+typedef struct VRVulkanTextureArrayData_t
+{
+	uint32_t m_unArrayIndex;
+	uint32_t m_unArraySize;
+} VRVulkanTextureArrayData_t;
+
+typedef struct D3D12TextureData_t
+{
+	struct ID3D12Resource * m_pResource; // struct ID3D12Resource *
+	struct ID3D12CommandQueue * m_pCommandQueue; // struct ID3D12CommandQueue *
+	uint32_t m_nNodeMask;
+} D3D12TextureData_t;
+
+typedef struct VREvent_Controller_t
+{
+	uint32_t button;
+} VREvent_Controller_t;
+
+typedef struct VREvent_Mouse_t
+{
+	float x;
+	float y;
+	uint32_t button;
+} VREvent_Mouse_t;
+
+typedef struct VREvent_Scroll_t
+{
+	float xdelta;
+	float ydelta;
+	uint32_t unused;
+	float viewportscale;
+} VREvent_Scroll_t;
+
+typedef struct VREvent_TouchPadMove_t
+{
+	bool bFingerDown;
+	float flSecondsFingerDown;
+	float fValueXFirst;
+	float fValueYFirst;
+	float fValueXRaw;
+	float fValueYRaw;
+} VREvent_TouchPadMove_t;
+
+typedef struct VREvent_Notification_t
+{
+	uint64_t ulUserValue;
+	uint32_t notificationId;
+} VREvent_Notification_t;
+
+typedef struct VREvent_Process_t
+{
+	uint32_t pid;
+	uint32_t oldPid;
+	bool bForced;
+	bool bConnectionLost;
+} VREvent_Process_t;
+
+typedef struct VREvent_Overlay_t
+{
+	uint64_t overlayHandle;
+	uint64_t devicePath;
+	uint64_t memoryBlockId;
+} VREvent_Overlay_t;
+
+typedef struct VREvent_Status_t
+{
+	uint32_t statusState;
+} VREvent_Status_t;
+
+typedef struct VREvent_Keyboard_t
+{
+	char cNewInput[8]; //char[8]
+	uint64_t uUserValue;
+} VREvent_Keyboard_t;
+
+typedef struct VREvent_Ipd_t
+{
+	float ipdMeters;
+} VREvent_Ipd_t;
+
+typedef struct VREvent_Chaperone_t
+{
+	uint64_t m_nPreviousUniverse;
+	uint64_t m_nCurrentUniverse;
+} VREvent_Chaperone_t;
+
+typedef struct VREvent_Reserved_t
+{
+	uint64_t reserved0;
+	uint64_t reserved1;
+	uint64_t reserved2;
+	uint64_t reserved3;
+	uint64_t reserved4;
+	uint64_t reserved5;
+} VREvent_Reserved_t;
+
+typedef struct VREvent_PerformanceTest_t
+{
+	uint32_t m_nFidelityLevel;
+} VREvent_PerformanceTest_t;
+
+typedef struct VREvent_SeatedZeroPoseReset_t
+{
+	bool bResetBySystemMenu;
+} VREvent_SeatedZeroPoseReset_t;
+
+typedef struct VREvent_Screenshot_t
+{
+	uint32_t handle;
+	uint32_t type;
+} VREvent_Screenshot_t;
+
+typedef struct VREvent_ScreenshotProgress_t
+{
+	float progress;
+} VREvent_ScreenshotProgress_t;
+
+typedef struct VREvent_ApplicationLaunch_t
+{
+	uint32_t pid;
+	uint32_t unArgsHandle;
+} VREvent_ApplicationLaunch_t;
+
+typedef struct VREvent_EditingCameraSurface_t
+{
+	uint64_t overlayHandle;
+	uint32_t nVisualMode;
+} VREvent_EditingCameraSurface_t;
+
+typedef struct VREvent_MessageOverlay_t
+{
+	uint32_t unVRMessageOverlayResponse;
+} VREvent_MessageOverlay_t;
+
+typedef struct VREvent_Property_t
+{
+	PropertyContainerHandle_t container;
+	enum ETrackedDeviceProperty prop;
+} VREvent_Property_t;
+
+typedef struct VREvent_HapticVibration_t
+{
+	uint64_t containerHandle;
+	uint64_t componentHandle;
+	float fDurationSeconds;
+	float fFrequency;
+	float fAmplitude;
+} VREvent_HapticVibration_t;
+
+typedef struct VREvent_WebConsole_t
+{
+	WebConsoleHandle_t webConsoleHandle;
+} VREvent_WebConsole_t;
+
+typedef struct VREvent_InputBindingLoad_t
+{
+	PropertyContainerHandle_t ulAppContainer;
+	uint64_t pathMessage;
+	uint64_t pathUrl;
+	uint64_t pathControllerType;
+} VREvent_InputBindingLoad_t;
+
+typedef struct VREvent_InputActionManifestLoad_t
+{
+	uint64_t pathAppKey;
+	uint64_t pathMessage;
+	uint64_t pathMessageParam;
+	uint64_t pathManifestPath;
+} VREvent_InputActionManifestLoad_t;
+
+typedef struct VREvent_SpatialAnchor_t
+{
+	SpatialAnchorHandle_t unHandle;
+} VREvent_SpatialAnchor_t;
+
+typedef struct VREvent_ProgressUpdate_t
+{
+	uint64_t ulApplicationPropertyContainer;
+	uint64_t pathDevice;
+	uint64_t pathInputSource;
+	uint64_t pathProgressAction;
+	uint64_t pathIcon;
+	float fProgress;
+} VREvent_ProgressUpdate_t;
+
+typedef struct VREvent_ShowUI_t
+{
+	enum EShowUIType eType;
+} VREvent_ShowUI_t;
+
+typedef struct VREvent_ShowDevTools_t
+{
+	int32_t nBrowserIdentifier;
+} VREvent_ShowDevTools_t;
+
+typedef struct VREvent_HDCPError_t
+{
+	enum EHDCPError eCode;
+} VREvent_HDCPError_t;
+
+typedef struct RenderModel_ComponentState_t
+{
+	struct HmdMatrix34_t mTrackingToComponentRenderModel;
+	struct HmdMatrix34_t mTrackingToComponentLocal;
+	VRComponentProperties uProperties;
+} RenderModel_ComponentState_t;
+
+typedef struct HiddenAreaMesh_t
+{
+	struct HmdVector2_t * pVertexData; // const struct vr::HmdVector2_t *
+	uint32_t unTriangleCount;
+} HiddenAreaMesh_t;
+
+typedef struct VRControllerAxis_t
+{
+	float x;
+	float y;
+} VRControllerAxis_t;
+
+typedef struct VRControllerState_t
+{
+	uint32_t unPacketNum;
+	uint64_t ulButtonPressed;
+	uint64_t ulButtonTouched;
+	struct VRControllerAxis_t rAxis[5]; //struct vr::VRControllerAxis_t[5]
+} VRControllerState_t;
+
+typedef struct CameraVideoStreamFrameHeader_t
+{
+	enum EVRTrackedCameraFrameType eFrameType;
+	uint32_t nWidth;
+	uint32_t nHeight;
+	uint32_t nBytesPerPixel;
+	uint32_t nFrameSequence;
+	struct TrackedDevicePose_t trackedDevicePose;
+	uint64_t ulFrameExposureTime;
+} CameraVideoStreamFrameHeader_t;
+
+typedef struct Compositor_FrameTiming
+{
+	uint32_t m_nSize;
+	uint32_t m_nFrameIndex;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumMisPresented;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nReprojectionFlags;
+	double m_flSystemTimeInSeconds;
+	float m_flPreSubmitGpuMs;
+	float m_flPostSubmitGpuMs;
+	float m_flTotalRenderGpuMs;
+	float m_flCompositorRenderGpuMs;
+	float m_flCompositorRenderCpuMs;
+	float m_flCompositorIdleCpuMs;
+	float m_flClientFrameIntervalMs;
+	float m_flPresentCallCpuMs;
+	float m_flWaitForPresentCpuMs;
+	float m_flSubmitFrameMs;
+	float m_flWaitGetPosesCalledMs;
+	float m_flNewPosesReadyMs;
+	float m_flNewFrameReadyMs;
+	float m_flCompositorUpdateStartMs;
+	float m_flCompositorUpdateEndMs;
+	float m_flCompositorRenderStartMs;
+	TrackedDevicePose_t m_HmdPose;
+	uint32_t m_nNumVSyncsReadyForUse;
+	uint32_t m_nNumVSyncsToFirstView;
+} Compositor_FrameTiming;
+
+typedef struct Compositor_BenchmarkResults
+{
+	float m_flMegaPixelsPerSecond;
+	float m_flHmdRecommendedMegaPixelsPerSecond;
+} Compositor_BenchmarkResults;
+
+typedef struct DriverDirectMode_FrameTiming
+{
+	uint32_t m_nSize;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumMisPresented;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nReprojectionFlags;
+} DriverDirectMode_FrameTiming;
+
+typedef struct ImuSample_t
+{
+	double fSampleTime;
+	struct HmdVector3d_t vAccel;
+	struct HmdVector3d_t vGyro;
+	uint32_t unOffScaleFlags;
+} ImuSample_t;
+
+typedef struct AppOverrideKeys_t
+{
+	char * pchKey; // const char *
+	char * pchValue; // const char *
+} AppOverrideKeys_t;
+
+typedef struct Compositor_CumulativeStats
+{
+	uint32_t m_nPid;
+	uint32_t m_nNumFramePresents;
+	uint32_t m_nNumDroppedFrames;
+	uint32_t m_nNumReprojectedFrames;
+	uint32_t m_nNumFramePresentsOnStartup;
+	uint32_t m_nNumDroppedFramesOnStartup;
+	uint32_t m_nNumReprojectedFramesOnStartup;
+	uint32_t m_nNumLoading;
+	uint32_t m_nNumFramePresentsLoading;
+	uint32_t m_nNumDroppedFramesLoading;
+	uint32_t m_nNumReprojectedFramesLoading;
+	uint32_t m_nNumTimedOut;
+	uint32_t m_nNumFramePresentsTimedOut;
+	uint32_t m_nNumDroppedFramesTimedOut;
+	uint32_t m_nNumReprojectedFramesTimedOut;
+	uint32_t m_nNumFrameSubmits;
+	double m_flSumCompositorCPUTimeMS;
+	double m_flSumCompositorGPUTimeMS;
+	double m_flSumTargetFrameTimes;
+	double m_flSumApplicationCPUTimeMS;
+	double m_flSumApplicationGPUTimeMS;
+} Compositor_CumulativeStats;
+
+typedef struct Compositor_StageRenderSettings
+{
+	struct HmdColor_t m_PrimaryColor;
+	struct HmdColor_t m_SecondaryColor;
+	float m_flVignetteInnerRadius;
+	float m_flVignetteOuterRadius;
+	float m_flFresnelStrength;
+	bool m_bBackfaceCulling;
+	bool m_bGreyscale;
+	bool m_bWireframe;
+} Compositor_StageRenderSettings;
+
+typedef struct VROverlayIntersectionParams_t
+{
+	struct HmdVector3_t vSource;
+	struct HmdVector3_t vDirection;
+	enum ETrackingUniverseOrigin eOrigin;
+} VROverlayIntersectionParams_t;
+
+typedef struct VROverlayIntersectionResults_t
+{
+	struct HmdVector3_t vPoint;
+	struct HmdVector3_t vNormal;
+	struct HmdVector2_t vUVs;
+	float fDistance;
+} VROverlayIntersectionResults_t;
+
+typedef struct IntersectionMaskRectangle_t
+{
+	float m_flTopLeftX;
+	float m_flTopLeftY;
+	float m_flWidth;
+	float m_flHeight;
+} IntersectionMaskRectangle_t;
+
+typedef struct IntersectionMaskCircle_t
+{
+	float m_flCenterX;
+	float m_flCenterY;
+	float m_flRadius;
+} IntersectionMaskCircle_t;
+
+typedef struct VROverlayProjection_t
+{
+	float fLeft;
+	float fRight;
+	float fTop;
+	float fBottom;
+} VROverlayProjection_t;
+
+typedef struct VROverlayView_t
+{
+	VROverlayHandle_t overlayHandle;
+	struct Texture_t texture;
+	struct VRTextureBounds_t textureBounds;
+} VROverlayView_t;
+
+typedef struct VRVulkanDevice_t
+{
+	struct VkInstance_T * m_pInstance; // struct VkInstance_T *
+	struct VkDevice_T * m_pDevice; // struct VkDevice_T *
+	struct VkPhysicalDevice_T * m_pPhysicalDevice; // struct VkPhysicalDevice_T *
+	struct VkQueue_T * m_pQueue; // struct VkQueue_T *
+	uint32_t m_uQueueFamilyIndex;
+} VRVulkanDevice_t;
+
+typedef struct VRNativeDevice_t
+{
+	void * handle; // void *
+	enum EDeviceType eType;
+} VRNativeDevice_t;
+
+typedef struct RenderModel_Vertex_t
+{
+	struct HmdVector3_t vPosition;
+	struct HmdVector3_t vNormal;
+	float rfTextureCoord[2]; //float[2]
+} RenderModel_Vertex_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( push, 4 )
+#endif
+typedef struct RenderModel_TextureMap_t
+{
+	uint16_t unWidth;
+	uint16_t unHeight;
+	uint8_t * rubTextureMapData; // const uint8_t *
+	enum EVRRenderModelTextureFormat format;
+	uint16_t unMipLevels;
+} RenderModel_TextureMap_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( pop )
+#endif
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( push, 4 )
+#endif
+typedef struct RenderModel_t
+{
+	struct RenderModel_Vertex_t * rVertexData; // const struct vr::RenderModel_Vertex_t *
+	uint32_t unVertexCount;
+	uint16_t * rIndexData; // const uint16_t *
+	uint32_t unTriangleCount;
+	TextureID_t diffuseTextureId;
+} RenderModel_t;
+
+#if defined(__linux__) || defined(__APPLE__)
+#pragma pack( pop )
+#endif
+typedef struct RenderModel_ControllerMode_State_t
+{
+	bool bScrollWheelVisible;
+} RenderModel_ControllerMode_State_t;
+
+typedef struct NotificationBitmap_t
+{
+	void * m_pImageData; // void *
+	int32_t m_nWidth;
+	int32_t m_nHeight;
+	int32_t m_nBytesPerPixel;
+} NotificationBitmap_t;
+
+typedef struct CVRSettingHelper
+{
+	intptr_t m_pSettings; // class vr::IVRSettings *
+} CVRSettingHelper;
+
+typedef struct InputAnalogActionData_t
+{
+	bool bActive;
+	VRInputValueHandle_t activeOrigin;
+	float x;
+	float y;
+	float z;
+	float deltaX;
+	float deltaY;
+	float deltaZ;
+	float fUpdateTime;
+} InputAnalogActionData_t;
+
+typedef struct InputDigitalActionData_t
+{
+	bool bActive;
+	VRInputValueHandle_t activeOrigin;
+	bool bState;
+	bool bChanged;
+	float fUpdateTime;
+} InputDigitalActionData_t;
+
+typedef struct InputPoseActionData_t
+{
+	bool bActive;
+	VRInputValueHandle_t activeOrigin;
+	struct TrackedDevicePose_t pose;
+} InputPoseActionData_t;
+
+typedef struct InputSkeletalActionData_t
+{
+	bool bActive;
+	VRInputValueHandle_t activeOrigin;
+} InputSkeletalActionData_t;
+
+typedef struct InputOriginInfo_t
+{
+	VRInputValueHandle_t devicePath;
+	TrackedDeviceIndex_t trackedDeviceIndex;
+	char rchRenderModelComponentName[128]; //char[128]
+} InputOriginInfo_t;
+
+typedef struct InputBindingInfo_t
+{
+	char rchDevicePathName[128]; //char[128]
+	char rchInputPathName[128]; //char[128]
+	char rchModeName[128]; //char[128]
+	char rchSlotName[128]; //char[128]
+	char rchInputSourceType[32]; //char[32]
+} InputBindingInfo_t;
+
+typedef struct VRActiveActionSet_t
+{
+	VRActionSetHandle_t ulActionSet;
+	VRInputValueHandle_t ulRestrictedToDevice;
+	VRActionSetHandle_t ulSecondaryActionSet;
+	uint32_t unPadding;
+	int32_t nPriority;
+} VRActiveActionSet_t;
+
+typedef struct VRSkeletalSummaryData_t
+{
+	float flFingerCurl[5]; //float[5]
+	float flFingerSplay[4]; //float[4]
+} VRSkeletalSummaryData_t;
+
+typedef struct SpatialAnchorPose_t
+{
+	struct HmdMatrix34_t mAnchorToAbsoluteTracking;
+} SpatialAnchorPose_t;
+
+typedef struct COpenVRContext
+{
+	intptr_t m_pVRSystem; // class vr::IVRSystem *
+	intptr_t m_pVRChaperone; // class vr::IVRChaperone *
+	intptr_t m_pVRChaperoneSetup; // class vr::IVRChaperoneSetup *
+	intptr_t m_pVRCompositor; // class vr::IVRCompositor *
+	intptr_t m_pVRHeadsetView; // class vr::IVRHeadsetView *
+	intptr_t m_pVROverlay; // class vr::IVROverlay *
+	intptr_t m_pVROverlayView; // class vr::IVROverlayView *
+	intptr_t m_pVRResources; // class vr::IVRResources *
+	intptr_t m_pVRRenderModels; // class vr::IVRRenderModels *
+	intptr_t m_pVRExtendedDisplay; // class vr::IVRExtendedDisplay *
+	intptr_t m_pVRSettings; // class vr::IVRSettings *
+	intptr_t m_pVRApplications; // class vr::IVRApplications *
+	intptr_t m_pVRTrackedCamera; // class vr::IVRTrackedCamera *
+	intptr_t m_pVRScreenshots; // class vr::IVRScreenshots *
+	intptr_t m_pVRDriverManager; // class vr::IVRDriverManager *
+	intptr_t m_pVRInput; // class vr::IVRInput *
+	intptr_t m_pVRIOBuffer; // class vr::IVRIOBuffer *
+	intptr_t m_pVRSpatialAnchors; // class vr::IVRSpatialAnchors *
+	intptr_t m_pVRDebug; // class vr::IVRDebug *
+	intptr_t m_pVRNotifications; // class vr::IVRNotifications *
+} COpenVRContext;
+
+typedef struct PropertyWrite_t
+{
+	enum ETrackedDeviceProperty prop;
+	enum EPropertyWriteType writeType;
+	enum ETrackedPropertyError eSetError;
+	void * pvBuffer; // void *
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	enum ETrackedPropertyError eError;
+} PropertyWrite_t;
+
+typedef struct PropertyRead_t
+{
+	enum ETrackedDeviceProperty prop;
+	void * pvBuffer; // void *
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	uint32_t unRequiredBufferSize;
+	enum ETrackedPropertyError eError;
+} PropertyRead_t;
+
+typedef struct CVRPropertyHelpers
+{
+	intptr_t m_pProperties; // class vr::IVRProperties *
+} CVRPropertyHelpers;
+
+typedef struct PathWrite_t
+{
+	PathHandle_t ulPath;
+	enum EPropertyWriteType writeType;
+	enum ETrackedPropertyError eSetError;
+	void * pvBuffer; // void *
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	enum ETrackedPropertyError eError;
+	char * pszPath; // const char *
+} PathWrite_t;
+
+typedef struct PathRead_t
+{
+	PathHandle_t ulPath;
+	void * pvBuffer; // void *
+	uint32_t unBufferSize;
+	PropertyTypeTag_t unTag;
+	uint32_t unRequiredBufferSize;
+	enum ETrackedPropertyError eError;
+	char * pszPath; // const char *
+} PathRead_t;
+
+
+typedef union
+{
+	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_HapticVibration_t hapticVibration;
+	VREvent_WebConsole_t webConsole;
+	VREvent_InputBindingLoad_t inputBinding;
+	VREvent_InputActionManifestLoad_t actionManifest;
+	VREvent_SpatialAnchor_t spatialAnchor;
+} 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
+
+
+typedef union
+{
+	IntersectionMaskRectangle_t m_Rectangle;
+	IntersectionMaskCircle_t m_Circle;
+} VROverlayIntersectionMaskPrimitive_Data_t;
+
+struct VROverlayIntersectionMaskPrimitive_t
+{
+	EVROverlayIntersectionMaskPrimitiveType m_nPrimitiveType;
+	VROverlayIntersectionMaskPrimitive_Data_t m_Primitive;
+};
+
+
+// OpenVR Function Pointer Tables
+
+struct VR_IVRSystem_FnTable
+{
+	void (OPENVR_FNTABLE_CALLTYPE *GetRecommendedRenderTargetSize)(uint32_t * pnWidth, uint32_t * pnHeight);
+	struct HmdMatrix44_t (OPENVR_FNTABLE_CALLTYPE *GetProjectionMatrix)(EVREye eEye, float fNearZ, float fFarZ);
+	void (OPENVR_FNTABLE_CALLTYPE *GetProjectionRaw)(EVREye eEye, float * pfLeft, float * pfRight, float * pfTop, float * pfBottom);
+	bool (OPENVR_FNTABLE_CALLTYPE *ComputeDistortion)(EVREye eEye, float fU, float fV, struct DistortionCoordinates_t * pDistortionCoordinates);
+	struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetEyeToHeadTransform)(EVREye eEye);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetTimeSinceLastVsync)(float * pfSecondsSinceLastVsync, uint64_t * pulFrameCounter);
+	int32_t (OPENVR_FNTABLE_CALLTYPE *GetD3D9AdapterIndex)();
+	void (OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t * pnAdapterIndex);
+	void (OPENVR_FNTABLE_CALLTYPE *GetOutputDevice)(uint64_t * pnDevice, ETextureType textureType, struct VkInstance_T * pInstance);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsDisplayOnDesktop)();
+	bool (OPENVR_FNTABLE_CALLTYPE *SetDisplayVisibility)(bool bIsVisibleOnDesktop);
+	void (OPENVR_FNTABLE_CALLTYPE *GetDeviceToAbsoluteTrackingPose)(ETrackingUniverseOrigin eOrigin, float fPredictedSecondsToPhotonsFromNow, struct TrackedDevicePose_t * pTrackedDevicePoseArray, uint32_t unTrackedDevicePoseArrayCount);
+	struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetSeatedZeroPoseToStandingAbsoluteTrackingPose)();
+	struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetRawZeroPoseToStandingAbsoluteTrackingPose)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetSortedTrackedDeviceIndicesOfClass)(ETrackedDeviceClass eTrackedDeviceClass, TrackedDeviceIndex_t * punTrackedDeviceIndexArray, uint32_t unTrackedDeviceIndexArrayCount, TrackedDeviceIndex_t unRelativeToTrackedDeviceIndex);
+	EDeviceActivityLevel (OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceActivityLevel)(TrackedDeviceIndex_t unDeviceId);
+	void (OPENVR_FNTABLE_CALLTYPE *ApplyTransform)(struct TrackedDevicePose_t * pOutputPose, struct TrackedDevicePose_t * pTrackedDevicePose, struct HmdMatrix34_t * pTransform);
+	TrackedDeviceIndex_t (OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceIndexForControllerRole)(ETrackedControllerRole unDeviceType);
+	ETrackedControllerRole (OPENVR_FNTABLE_CALLTYPE *GetControllerRoleForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex);
+	ETrackedDeviceClass (OPENVR_FNTABLE_CALLTYPE *GetTrackedDeviceClass)(TrackedDeviceIndex_t unDeviceIndex);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsTrackedDeviceConnected)(TrackedDeviceIndex_t unDeviceIndex);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetBoolTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	float (OPENVR_FNTABLE_CALLTYPE *GetFloatTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	int32_t (OPENVR_FNTABLE_CALLTYPE *GetInt32TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	uint64_t (OPENVR_FNTABLE_CALLTYPE *GetUint64TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	struct HmdMatrix34_t (OPENVR_FNTABLE_CALLTYPE *GetMatrix34TrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, ETrackedPropertyError * pError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetArrayTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, PropertyTypeTag_t propType, void * pBuffer, uint32_t unBufferSize, ETrackedPropertyError * pError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetStringTrackedDeviceProperty)(TrackedDeviceIndex_t unDeviceIndex, ETrackedDeviceProperty prop, char * pchValue, uint32_t unBufferSize, ETrackedPropertyError * pError);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetPropErrorNameFromEnum)(ETrackedPropertyError error);
+	bool (OPENVR_FNTABLE_CALLTYPE *PollNextEvent)(struct VREvent_t * pEvent, uint32_t uncbVREvent);
+	bool (OPENVR_FNTABLE_CALLTYPE *PollNextEventWithPose)(ETrackingUniverseOrigin eOrigin, struct VREvent_t * pEvent, uint32_t uncbVREvent, TrackedDevicePose_t * pTrackedDevicePose);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetEventTypeNameFromEnum)(EVREventType eType);
+	struct HiddenAreaMesh_t (OPENVR_FNTABLE_CALLTYPE *GetHiddenAreaMesh)(EVREye eEye, EHiddenAreaMeshType type);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetControllerState)(TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetControllerStateWithPose)(ETrackingUniverseOrigin eOrigin, TrackedDeviceIndex_t unControllerDeviceIndex, VRControllerState_t * pControllerState, uint32_t unControllerStateSize, struct TrackedDevicePose_t * pTrackedDevicePose);
+	void (OPENVR_FNTABLE_CALLTYPE *TriggerHapticPulse)(TrackedDeviceIndex_t unControllerDeviceIndex, uint32_t unAxisId, unsigned short usDurationMicroSec);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetButtonIdNameFromEnum)(EVRButtonId eButtonId);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetControllerAxisTypeNameFromEnum)(EVRControllerAxisType eAxisType);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsInputAvailable)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsSteamVRDrawingControllers)();
+	bool (OPENVR_FNTABLE_CALLTYPE *ShouldApplicationPause)();
+	bool (OPENVR_FNTABLE_CALLTYPE *ShouldApplicationReduceRenderingWork)();
+	EVRFirmwareError (OPENVR_FNTABLE_CALLTYPE *PerformFirmwareUpdate)(TrackedDeviceIndex_t unDeviceIndex);
+	void (OPENVR_FNTABLE_CALLTYPE *AcknowledgeQuit_Exiting)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetAppContainerFilePaths)(char * pchBuffer, uint32_t unBufferSize);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetRuntimeVersion)();
+};
+
+struct VR_IVRExtendedDisplay_FnTable
+{
+	void (OPENVR_FNTABLE_CALLTYPE *GetWindowBounds)(int32_t * pnX, int32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+	void (OPENVR_FNTABLE_CALLTYPE *GetEyeOutputViewport)(EVREye eEye, uint32_t * pnX, uint32_t * pnY, uint32_t * pnWidth, uint32_t * pnHeight);
+	void (OPENVR_FNTABLE_CALLTYPE *GetDXGIOutputInfo)(int32_t * pnAdapterIndex, int32_t * pnAdapterOutputIndex);
+};
+
+struct VR_IVRTrackedCamera_FnTable
+{
+	char * (OPENVR_FNTABLE_CALLTYPE *GetCameraErrorNameFromEnum)(EVRTrackedCameraError eCameraError);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *HasCamera)(TrackedDeviceIndex_t nDeviceIndex, bool * pHasCamera);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraFrameSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, uint32_t * pnWidth, uint32_t * pnHeight, uint32_t * pnFrameBufferSize);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraIntrinsics)(TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, HmdVector2_t * pFocalLength, HmdVector2_t * pCenter);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetCameraProjection)(TrackedDeviceIndex_t nDeviceIndex, uint32_t nCameraIndex, EVRTrackedCameraFrameType eFrameType, float flZNear, float flZFar, HmdMatrix44_t * pProjection);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *AcquireVideoStreamingService)(TrackedDeviceIndex_t nDeviceIndex, TrackedCameraHandle_t * pHandle);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamingService)(TrackedCameraHandle_t hTrackedCamera);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetVideoStreamFrameBuffer)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pFrameBuffer, uint32_t nFrameBufferSize, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureSize)(TrackedDeviceIndex_t nDeviceIndex, EVRTrackedCameraFrameType eFrameType, VRTextureBounds_t * pTextureBounds, uint32_t * pnWidth, uint32_t * pnHeight);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureD3D11)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *GetVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, EVRTrackedCameraFrameType eFrameType, glUInt_t * pglTextureId, CameraVideoStreamFrameHeader_t * pFrameHeader, uint32_t nFrameHeaderSize);
+	EVRTrackedCameraError (OPENVR_FNTABLE_CALLTYPE *ReleaseVideoStreamTextureGL)(TrackedCameraHandle_t hTrackedCamera, glUInt_t glTextureId);
+	void (OPENVR_FNTABLE_CALLTYPE *SetCameraTrackingSpace)(ETrackingUniverseOrigin eUniverse);
+	ETrackingUniverseOrigin (OPENVR_FNTABLE_CALLTYPE *GetCameraTrackingSpace)();
+};
+
+struct VR_IVRApplications_FnTable
+{
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *AddApplicationManifest)(char * pchApplicationManifestFullPath, bool bTemporary);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *RemoveApplicationManifest)(char * pchApplicationManifestFullPath);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsApplicationInstalled)(char * pchAppKey);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationCount)();
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByIndex)(uint32_t unApplicationIndex, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *GetApplicationKeyByProcessId)(uint32_t unProcessId, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchApplication)(char * pchAppKey);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchTemplateApplication)(char * pchTemplateAppKey, char * pchNewAppKey, struct AppOverrideKeys_t * pKeys, uint32_t unKeys);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchApplicationFromMimeType)(char * pchMimeType, char * pchArgs);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchDashboardOverlay)(char * pchAppKey);
+	bool (OPENVR_FNTABLE_CALLTYPE *CancelApplicationLaunch)(char * pchAppKey);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *IdentifyApplication)(uint32_t unProcessId, char * pchAppKey);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationProcessId)(char * pchAppKey);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetApplicationsErrorNameFromEnum)(EVRApplicationError error);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyString)(char * pchAppKey, EVRApplicationProperty eProperty, char * pchPropertyValueBuffer, uint32_t unPropertyValueBufferLen, EVRApplicationError * peError);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyBool)(char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+	uint64_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationPropertyUint64)(char * pchAppKey, EVRApplicationProperty eProperty, EVRApplicationError * peError);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *SetApplicationAutoLaunch)(char * pchAppKey, bool bAutoLaunch);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetApplicationAutoLaunch)(char * pchAppKey);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *SetDefaultApplicationForMimeType)(char * pchAppKey, char * pchMimeType);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetDefaultApplicationForMimeType)(char * pchMimeType, char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetApplicationSupportedMimeTypes)(char * pchAppKey, char * pchMimeTypesBuffer, uint32_t unMimeTypesBuffer);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationsThatSupportMimeType)(char * pchMimeType, char * pchAppKeysThatSupportBuffer, uint32_t unAppKeysThatSupportBuffer);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetApplicationLaunchArguments)(uint32_t unHandle, char * pchArgs, uint32_t unArgs);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *GetStartingApplication)(char * pchAppKeyBuffer, uint32_t unAppKeyBufferLen);
+	EVRSceneApplicationState (OPENVR_FNTABLE_CALLTYPE *GetSceneApplicationState)();
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *PerformApplicationPrelaunchCheck)(char * pchAppKey);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetSceneApplicationStateNameFromEnum)(EVRSceneApplicationState state);
+	EVRApplicationError (OPENVR_FNTABLE_CALLTYPE *LaunchInternalProcess)(char * pchBinaryPath, char * pchArguments, char * pchWorkingDirectory);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneProcessId)();
+};
+
+struct VR_IVRChaperone_FnTable
+{
+	ChaperoneCalibrationState (OPENVR_FNTABLE_CALLTYPE *GetCalibrationState)();
+	bool (OPENVR_FNTABLE_CALLTYPE *GetPlayAreaSize)(float * pSizeX, float * pSizeZ);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetPlayAreaRect)(struct HmdQuad_t * rect);
+	void (OPENVR_FNTABLE_CALLTYPE *ReloadInfo)();
+	void (OPENVR_FNTABLE_CALLTYPE *SetSceneColor)(struct HmdColor_t color);
+	void (OPENVR_FNTABLE_CALLTYPE *GetBoundsColor)(struct HmdColor_t * pOutputColorArray, int nNumOutputColors, float flCollisionBoundsFadeDistance, struct HmdColor_t * pOutputCameraColor);
+	bool (OPENVR_FNTABLE_CALLTYPE *AreBoundsVisible)();
+	void (OPENVR_FNTABLE_CALLTYPE *ForceBoundsVisible)(bool bForce);
+	void (OPENVR_FNTABLE_CALLTYPE *ResetZeroPose)(ETrackingUniverseOrigin eTrackingUniverseOrigin);
+};
+
+struct VR_IVRChaperoneSetup_FnTable
+{
+	bool (OPENVR_FNTABLE_CALLTYPE *CommitWorkingCopy)(EChaperoneConfigFile configFile);
+	void (OPENVR_FNTABLE_CALLTYPE *RevertWorkingCopy)();
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaSize)(float * pSizeX, float * pSizeZ);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingPlayAreaRect)(struct HmdQuad_t * rect);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingCollisionBoundsInfo)(struct HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetLiveCollisionBoundsInfo)(struct HmdQuad_t * pQuadsBuffer, uint32_t * punQuadsCount);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pmatStandingZeroPoseToRawTrackingPose);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingPlayAreaSize)(float sizeX, float sizeZ);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingCollisionBoundsInfo)(struct HmdQuad_t * pQuadsBuffer, uint32_t unQuadsCount);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingPerimeter)(struct HmdVector2_t * pPointBuffer, uint32_t unPointCount);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pMatSeatedZeroPoseToRawTrackingPose);
+	void (OPENVR_FNTABLE_CALLTYPE *SetWorkingStandingZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pMatStandingZeroPoseToRawTrackingPose);
+	void (OPENVR_FNTABLE_CALLTYPE *ReloadFromDisk)(EChaperoneConfigFile configFile);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetLiveSeatedZeroPoseToRawTrackingPose)(struct HmdMatrix34_t * pmatSeatedZeroPoseToRawTrackingPose);
+	bool (OPENVR_FNTABLE_CALLTYPE *ExportLiveToBuffer)(char * pBuffer, uint32_t * pnBufferLength);
+	bool (OPENVR_FNTABLE_CALLTYPE *ImportFromBufferToWorking)(char * pBuffer, uint32_t nImportFlags);
+	void (OPENVR_FNTABLE_CALLTYPE *ShowWorkingSetPreview)();
+	void (OPENVR_FNTABLE_CALLTYPE *HideWorkingSetPreview)();
+	void (OPENVR_FNTABLE_CALLTYPE *RoomSetupStarting)();
+};
+
+struct VR_IVRCompositor_FnTable
+{
+	void (OPENVR_FNTABLE_CALLTYPE *SetTrackingSpace)(ETrackingUniverseOrigin eOrigin);
+	ETrackingUniverseOrigin (OPENVR_FNTABLE_CALLTYPE *GetTrackingSpace)();
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *WaitGetPoses)(struct TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetLastPoses)(struct TrackedDevicePose_t * pRenderPoseArray, uint32_t unRenderPoseArrayCount, struct TrackedDevicePose_t * pGamePoseArray, uint32_t unGamePoseArrayCount);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetLastPoseForTrackedDeviceIndex)(TrackedDeviceIndex_t unDeviceIndex, struct TrackedDevicePose_t * pOutputPose, struct TrackedDevicePose_t * pOutputGamePose);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *Submit)(EVREye eEye, struct Texture_t * pTexture, struct VRTextureBounds_t * pBounds, EVRSubmitFlags nSubmitFlags);
+	void (OPENVR_FNTABLE_CALLTYPE *ClearLastSubmittedFrame)();
+	void (OPENVR_FNTABLE_CALLTYPE *PostPresentHandoff)();
+	bool (OPENVR_FNTABLE_CALLTYPE *GetFrameTiming)(struct Compositor_FrameTiming * pTiming, uint32_t unFramesAgo);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetFrameTimings)(struct Compositor_FrameTiming * pTiming, uint32_t nFrames);
+	float (OPENVR_FNTABLE_CALLTYPE *GetFrameTimeRemaining)();
+	void (OPENVR_FNTABLE_CALLTYPE *GetCumulativeStats)(struct Compositor_CumulativeStats * pStats, uint32_t nStatsSizeInBytes);
+	void (OPENVR_FNTABLE_CALLTYPE *FadeToColor)(float fSeconds, float fRed, float fGreen, float fBlue, float fAlpha, bool bBackground);
+	struct HmdColor_t (OPENVR_FNTABLE_CALLTYPE *GetCurrentFadeColor)(bool bBackground);
+	void (OPENVR_FNTABLE_CALLTYPE *FadeGrid)(float fSeconds, bool bFadeGridIn);
+	float (OPENVR_FNTABLE_CALLTYPE *GetCurrentGridAlpha)();
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *SetSkyboxOverride)(struct Texture_t * pTextures, uint32_t unTextureCount);
+	void (OPENVR_FNTABLE_CALLTYPE *ClearSkyboxOverride)();
+	void (OPENVR_FNTABLE_CALLTYPE *CompositorBringToFront)();
+	void (OPENVR_FNTABLE_CALLTYPE *CompositorGoToBack)();
+	void (OPENVR_FNTABLE_CALLTYPE *CompositorQuit)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsFullscreen)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetCurrentSceneFocusProcess)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetLastFrameRenderer)();
+	bool (OPENVR_FNTABLE_CALLTYPE *CanRenderScene)();
+	void (OPENVR_FNTABLE_CALLTYPE *ShowMirrorWindow)();
+	void (OPENVR_FNTABLE_CALLTYPE *HideMirrorWindow)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsMirrorWindowVisible)();
+	void (OPENVR_FNTABLE_CALLTYPE *CompositorDumpImages)();
+	bool (OPENVR_FNTABLE_CALLTYPE *ShouldAppRenderWithLowResources)();
+	void (OPENVR_FNTABLE_CALLTYPE *ForceInterleavedReprojectionOn)(bool bOverride);
+	void (OPENVR_FNTABLE_CALLTYPE *ForceReconnectProcess)();
+	void (OPENVR_FNTABLE_CALLTYPE *SuspendRendering)(bool bSuspend);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureD3D11)(EVREye eEye, void * pD3D11DeviceOrResource, void ** ppD3D11ShaderResourceView);
+	void (OPENVR_FNTABLE_CALLTYPE *ReleaseMirrorTextureD3D11)(void * pD3D11ShaderResourceView);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetMirrorTextureGL)(EVREye eEye, glUInt_t * pglTextureId, glSharedTextureHandle_t * pglSharedTextureHandle);
+	bool (OPENVR_FNTABLE_CALLTYPE *ReleaseSharedGLTexture)(glUInt_t glTextureId, glSharedTextureHandle_t glSharedTextureHandle);
+	void (OPENVR_FNTABLE_CALLTYPE *LockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	void (OPENVR_FNTABLE_CALLTYPE *UnlockGLSharedTextureForAccess)(glSharedTextureHandle_t glSharedTextureHandle);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetVulkanInstanceExtensionsRequired)(char * pchValue, uint32_t unBufferSize);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetVulkanDeviceExtensionsRequired)(struct VkPhysicalDevice_T * pPhysicalDevice, char * pchValue, uint32_t unBufferSize);
+	void (OPENVR_FNTABLE_CALLTYPE *SetExplicitTimingMode)(EVRCompositorTimingMode eTimingMode);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *SubmitExplicitTimingData)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsMotionSmoothingEnabled)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsMotionSmoothingSupported)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsCurrentSceneFocusAppLoading)();
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *SetStageOverride_Async)(char * pchRenderModelPath, struct HmdMatrix34_t * pTransform, struct Compositor_StageRenderSettings * pRenderSettings, uint32_t nSizeOfRenderSettings);
+	void (OPENVR_FNTABLE_CALLTYPE *ClearStageOverride)();
+	bool (OPENVR_FNTABLE_CALLTYPE *GetCompositorBenchmarkResults)(struct Compositor_BenchmarkResults * pBenchmarkResults, uint32_t nSizeOfBenchmarkResults);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetLastPosePredictionIDs)(uint32_t * pRenderPosePredictionID, uint32_t * pGamePosePredictionID);
+	EVRCompositorError (OPENVR_FNTABLE_CALLTYPE *GetPosesForFrame)(uint32_t unPosePredictionID, struct TrackedDevicePose_t * pPoseArray, uint32_t unPoseArrayCount);
+};
+
+struct VR_IVROverlay_FnTable
+{
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *FindOverlay)(char * pchOverlayKey, VROverlayHandle_t * pOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *CreateOverlay)(char * pchOverlayKey, char * pchOverlayName, VROverlayHandle_t * pOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *DestroyOverlay)(VROverlayHandle_t ulOverlayHandle);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetOverlayKey)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchValue, uint32_t unBufferSize, EVROverlayError * pError);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayName)(VROverlayHandle_t ulOverlayHandle, char * pchName);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayImageData)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unBufferSize, uint32_t * punWidth, uint32_t * punHeight);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetOverlayErrorNameFromEnum)(EVROverlayError error);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle, uint32_t unPID);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetOverlayRenderingPid)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool bEnabled);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayFlag)(VROverlayHandle_t ulOverlayHandle, VROverlayFlags eOverlayFlag, bool * pbEnabled);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayFlags)(VROverlayHandle_t ulOverlayHandle, uint32_t * pFlags);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float fRed, float fGreen, float fBlue);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayColor)(VROverlayHandle_t ulOverlayHandle, float * pfRed, float * pfGreen, float * pfBlue);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float fAlpha);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayAlpha)(VROverlayHandle_t ulOverlayHandle, float * pfAlpha);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float fTexelAspect);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTexelAspect)(VROverlayHandle_t ulOverlayHandle, float * pfTexelAspect);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t unSortOrder);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlaySortOrder)(VROverlayHandle_t ulOverlayHandle, uint32_t * punSortOrder);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float fWidthInMeters);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayWidthInMeters)(VROverlayHandle_t ulOverlayHandle, float * pfWidthInMeters);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float fCurvature);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayCurvature)(VROverlayHandle_t ulOverlayHandle, float * pfCurvature);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayPreCurvePitch)(VROverlayHandle_t ulOverlayHandle, float fRadians);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayPreCurvePitch)(VROverlayHandle_t ulOverlayHandle, float * pfRadians);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace eTextureColorSpace);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureColorSpace)(VROverlayHandle_t ulOverlayHandle, EColorSpace * peTextureColorSpace);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t * pOverlayTextureBounds);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureBounds)(VROverlayHandle_t ulOverlayHandle, struct VRTextureBounds_t * pOverlayTextureBounds);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformType)(VROverlayHandle_t ulOverlayHandle, VROverlayTransformType * peTransformType);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformAbsolute)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin * peTrackingOrigin, struct HmdMatrix34_t * pmatTrackingOriginToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unTrackedDevice, struct HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceRelative)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punTrackedDevice, struct HmdMatrix34_t * pmatTrackedDeviceToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t unDeviceIndex, char * pchComponentName);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformTrackedDeviceComponent)(VROverlayHandle_t ulOverlayHandle, TrackedDeviceIndex_t * punDeviceIndex, char * pchComponentName, uint32_t unComponentNameSize);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t * ulOverlayHandleParent, struct HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformOverlayRelative)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulOverlayHandleParent, struct HmdMatrix34_t * pmatParentOverlayToOverlayTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformCursor)(VROverlayHandle_t ulCursorOverlayHandle, struct HmdVector2_t * pvHotspot);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTransformCursor)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t * pvHotspot);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTransformProjection)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t * pmatTrackingOriginToOverlayTransform, struct VROverlayProjection_t * pProjection, EVREye eEye);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ShowOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *HideOverlay)(VROverlayHandle_t ulOverlayHandle);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsOverlayVisible)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetTransformForOverlayCoordinates)(VROverlayHandle_t ulOverlayHandle, ETrackingUniverseOrigin eTrackingOrigin, struct HmdVector2_t coordinatesInOverlay, struct HmdMatrix34_t * pmatTransform);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *WaitFrameSync)(uint32_t nTimeoutMs);
+	bool (OPENVR_FNTABLE_CALLTYPE *PollNextOverlayEvent)(VROverlayHandle_t ulOverlayHandle, struct VREvent_t * pEvent, uint32_t uncbVREvent);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod * peInputMethod);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayInputMethod)(VROverlayHandle_t ulOverlayHandle, VROverlayInputMethod eInputMethod);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t * pvecMouseScale);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayMouseScale)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t * pvecMouseScale);
+	bool (OPENVR_FNTABLE_CALLTYPE *ComputeOverlayIntersection)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionParams_t * pParams, struct VROverlayIntersectionResults_t * pResults);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsHoverTargetOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayIntersectionMask)(VROverlayHandle_t ulOverlayHandle, struct VROverlayIntersectionMaskPrimitive_t * pMaskPrimitives, uint32_t unNumMaskPrimitives, uint32_t unPrimitiveSize);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *TriggerLaserMouseHapticVibration)(VROverlayHandle_t ulOverlayHandle, float fDurationSeconds, float fFrequency, float fAmplitude);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayCursor)(VROverlayHandle_t ulOverlayHandle, VROverlayHandle_t ulCursorHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle, struct HmdVector2_t * pvCursor);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ClearOverlayCursorPositionOverride)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, struct Texture_t * pTexture);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ClearOverlayTexture)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayRaw)(VROverlayHandle_t ulOverlayHandle, void * pvBuffer, uint32_t unWidth, uint32_t unHeight, uint32_t unBytesPerPixel);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetOverlayFromFile)(VROverlayHandle_t ulOverlayHandle, char * pchFilePath);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTexture)(VROverlayHandle_t ulOverlayHandle, void ** pNativeTextureHandle, void * pNativeTextureRef, uint32_t * pWidth, uint32_t * pHeight, uint32_t * pNativeFormat, ETextureType * pAPIType, EColorSpace * pColorSpace, struct VRTextureBounds_t * pTextureBounds);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ReleaseNativeOverlayHandle)(VROverlayHandle_t ulOverlayHandle, void * pNativeTextureHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetOverlayTextureSize)(VROverlayHandle_t ulOverlayHandle, uint32_t * pWidth, uint32_t * pHeight);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *CreateDashboardOverlay)(char * pchOverlayKey, char * pchOverlayFriendlyName, VROverlayHandle_t * pMainHandle, VROverlayHandle_t * pThumbnailHandle);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsDashboardVisible)();
+	bool (OPENVR_FNTABLE_CALLTYPE *IsActiveDashboardOverlay)(VROverlayHandle_t ulOverlayHandle);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *SetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t unProcessId);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *GetDashboardOverlaySceneProcess)(VROverlayHandle_t ulOverlayHandle, uint32_t * punProcessId);
+	void (OPENVR_FNTABLE_CALLTYPE *ShowDashboard)(char * pchOverlayToShow);
+	TrackedDeviceIndex_t (OPENVR_FNTABLE_CALLTYPE *GetPrimaryDashboardDevice)();
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ShowKeyboard)(EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, char * pchDescription, uint32_t unCharMax, char * pchExistingText, uint64_t uUserValue);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ShowKeyboardForOverlay)(VROverlayHandle_t ulOverlayHandle, EGamepadTextInputMode eInputMode, EGamepadTextInputLineMode eLineInputMode, uint32_t unFlags, char * pchDescription, uint32_t unCharMax, char * pchExistingText, uint64_t uUserValue);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetKeyboardText)(char * pchText, uint32_t cchText);
+	void (OPENVR_FNTABLE_CALLTYPE *HideKeyboard)();
+	void (OPENVR_FNTABLE_CALLTYPE *SetKeyboardTransformAbsolute)(ETrackingUniverseOrigin eTrackingOrigin, struct HmdMatrix34_t * pmatTrackingOriginToKeyboardTransform);
+	void (OPENVR_FNTABLE_CALLTYPE *SetKeyboardPositionForOverlay)(VROverlayHandle_t ulOverlayHandle, struct HmdRect2_t avoidRect);
+	VRMessageOverlayResponse (OPENVR_FNTABLE_CALLTYPE *ShowMessageOverlay)(char * pchText, char * pchCaption, char * pchButton0Text, char * pchButton1Text, char * pchButton2Text, char * pchButton3Text);
+	void (OPENVR_FNTABLE_CALLTYPE *CloseMessageOverlay)();
+};
+
+struct VR_IVROverlayView_FnTable
+{
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *AcquireOverlayView)(VROverlayHandle_t ulOverlayHandle, struct VRNativeDevice_t * pNativeDevice, struct VROverlayView_t * pOverlayView, uint32_t unOverlayViewSize);
+	EVROverlayError (OPENVR_FNTABLE_CALLTYPE *ReleaseOverlayView)(struct VROverlayView_t * pOverlayView);
+	void (OPENVR_FNTABLE_CALLTYPE *PostOverlayEvent)(VROverlayHandle_t ulOverlayHandle, struct VREvent_t * pvrEvent);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsViewingPermitted)(VROverlayHandle_t ulOverlayHandle);
+};
+
+struct VR_IVRHeadsetView_FnTable
+{
+	void (OPENVR_FNTABLE_CALLTYPE *SetHeadsetViewSize)(uint32_t nWidth, uint32_t nHeight);
+	void (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewSize)(uint32_t * pnWidth, uint32_t * pnHeight);
+	void (OPENVR_FNTABLE_CALLTYPE *SetHeadsetViewMode)(HeadsetViewMode_t eHeadsetViewMode);
+	HeadsetViewMode_t (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewMode)();
+	void (OPENVR_FNTABLE_CALLTYPE *SetHeadsetViewCropped)(bool bCropped);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewCropped)();
+	float (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewAspectRatio)();
+	void (OPENVR_FNTABLE_CALLTYPE *SetHeadsetViewBlendRange)(float flStartPct, float flEndPct);
+	void (OPENVR_FNTABLE_CALLTYPE *GetHeadsetViewBlendRange)(float * pStartPct, float * pEndPct);
+};
+
+struct VR_IVRRenderModels_FnTable
+{
+	EVRRenderModelError (OPENVR_FNTABLE_CALLTYPE *LoadRenderModel_Async)(char * pchRenderModelName, struct RenderModel_t ** ppRenderModel);
+	void (OPENVR_FNTABLE_CALLTYPE *FreeRenderModel)(struct RenderModel_t * pRenderModel);
+	EVRRenderModelError (OPENVR_FNTABLE_CALLTYPE *LoadTexture_Async)(TextureID_t textureId, struct RenderModel_TextureMap_t ** ppTexture);
+	void (OPENVR_FNTABLE_CALLTYPE *FreeTexture)(struct RenderModel_TextureMap_t * pTexture);
+	EVRRenderModelError (OPENVR_FNTABLE_CALLTYPE *LoadTextureD3D11_Async)(TextureID_t textureId, void * pD3D11Device, void ** ppD3D11Texture2D);
+	EVRRenderModelError (OPENVR_FNTABLE_CALLTYPE *LoadIntoTextureD3D11_Async)(TextureID_t textureId, void * pDstTexture);
+	void (OPENVR_FNTABLE_CALLTYPE *FreeTextureD3D11)(void * pD3D11Texture2D);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetRenderModelName)(uint32_t unRenderModelIndex, char * pchRenderModelName, uint32_t unRenderModelNameLen);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetRenderModelCount)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetComponentCount)(char * pchRenderModelName);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetComponentName)(char * pchRenderModelName, uint32_t unComponentIndex, char * pchComponentName, uint32_t unComponentNameLen);
+	uint64_t (OPENVR_FNTABLE_CALLTYPE *GetComponentButtonMask)(char * pchRenderModelName, char * pchComponentName);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetComponentRenderModelName)(char * pchRenderModelName, char * pchComponentName, char * pchComponentRenderModelName, uint32_t unComponentRenderModelNameLen);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetComponentStateForDevicePath)(char * pchRenderModelName, char * pchComponentName, VRInputValueHandle_t devicePath, RenderModel_ControllerMode_State_t * pState, RenderModel_ComponentState_t * pComponentState);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetComponentState)(char * pchRenderModelName, char * pchComponentName, VRControllerState_t * pControllerState, struct RenderModel_ControllerMode_State_t * pState, struct RenderModel_ComponentState_t * pComponentState);
+	bool (OPENVR_FNTABLE_CALLTYPE *RenderModelHasComponent)(char * pchRenderModelName, char * pchComponentName);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetRenderModelThumbnailURL)(char * pchRenderModelName, char * pchThumbnailURL, uint32_t unThumbnailURLLen, EVRRenderModelError * peError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetRenderModelOriginalPath)(char * pchRenderModelName, char * pchOriginalPath, uint32_t unOriginalPathLen, EVRRenderModelError * peError);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetRenderModelErrorNameFromEnum)(EVRRenderModelError error);
+};
+
+struct VR_IVRNotifications_FnTable
+{
+	EVRNotificationError (OPENVR_FNTABLE_CALLTYPE *CreateNotification)(VROverlayHandle_t ulOverlayHandle, uint64_t ulUserValue, EVRNotificationType type, char * pchText, EVRNotificationStyle style, struct NotificationBitmap_t * pImage, VRNotificationId * pNotificationId);
+	EVRNotificationError (OPENVR_FNTABLE_CALLTYPE *RemoveNotification)(VRNotificationId notificationId);
+};
+
+struct VR_IVRSettings_FnTable
+{
+	char * (OPENVR_FNTABLE_CALLTYPE *GetSettingsErrorNameFromEnum)(EVRSettingsError eError);
+	void (OPENVR_FNTABLE_CALLTYPE *SetBool)(char * pchSection, char * pchSettingsKey, bool bValue, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *SetInt32)(char * pchSection, char * pchSettingsKey, int32_t nValue, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *SetFloat)(char * pchSection, char * pchSettingsKey, float flValue, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *SetString)(char * pchSection, char * pchSettingsKey, char * pchValue, EVRSettingsError * peError);
+	bool (OPENVR_FNTABLE_CALLTYPE *GetBool)(char * pchSection, char * pchSettingsKey, EVRSettingsError * peError);
+	int32_t (OPENVR_FNTABLE_CALLTYPE *GetInt32)(char * pchSection, char * pchSettingsKey, EVRSettingsError * peError);
+	float (OPENVR_FNTABLE_CALLTYPE *GetFloat)(char * pchSection, char * pchSettingsKey, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *GetString)(char * pchSection, char * pchSettingsKey, char * pchValue, uint32_t unValueLen, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *RemoveSection)(char * pchSection, EVRSettingsError * peError);
+	void (OPENVR_FNTABLE_CALLTYPE *RemoveKeyInSection)(char * pchSection, char * pchSettingsKey, EVRSettingsError * peError);
+};
+
+struct VR_IVRScreenshots_FnTable
+{
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *RequestScreenshot)(ScreenshotHandle_t * pOutScreenshotHandle, EVRScreenshotType type, char * pchPreviewFilename, char * pchVRFilename);
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *HookScreenshot)(EVRScreenshotType * pSupportedTypes, int numTypes);
+	EVRScreenshotType (OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyType)(ScreenshotHandle_t screenshotHandle, EVRScreenshotError * pError);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetScreenshotPropertyFilename)(ScreenshotHandle_t screenshotHandle, EVRScreenshotPropertyFilenames filenameType, char * pchFilename, uint32_t cchFilename, EVRScreenshotError * pError);
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *UpdateScreenshotProgress)(ScreenshotHandle_t screenshotHandle, float flProgress);
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *TakeStereoScreenshot)(ScreenshotHandle_t * pOutScreenshotHandle, char * pchPreviewFilename, char * pchVRFilename);
+	EVRScreenshotError (OPENVR_FNTABLE_CALLTYPE *SubmitScreenshot)(ScreenshotHandle_t screenshotHandle, EVRScreenshotType type, char * pchSourcePreviewFilename, char * pchSourceVRFilename);
+};
+
+struct VR_IVRResources_FnTable
+{
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *LoadSharedResource)(char * pchResourceName, char * pchBuffer, uint32_t unBufferLen);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetResourceFullPath)(char * pchResourceName, char * pchResourceTypeDirectory, char * pchPathBuffer, uint32_t unBufferLen);
+};
+
+struct VR_IVRDriverManager_FnTable
+{
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetDriverCount)();
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *GetDriverName)(DriverId_t nDriver, char * pchValue, uint32_t unBufferSize);
+	DriverHandle_t (OPENVR_FNTABLE_CALLTYPE *GetDriverHandle)(char * pchDriverName);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsEnabled)(DriverId_t nDriver);
+};
+
+struct VR_IVRInput_FnTable
+{
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *SetActionManifestPath)(char * pchActionManifestPath);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetActionSetHandle)(char * pchActionSetName, VRActionSetHandle_t * pHandle);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetActionHandle)(char * pchActionName, VRActionHandle_t * pHandle);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetInputSourceHandle)(char * pchInputSourcePath, VRInputValueHandle_t * pHandle);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *UpdateActionState)(struct VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetDigitalActionData)(VRActionHandle_t action, struct InputDigitalActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetAnalogActionData)(VRActionHandle_t action, struct InputAnalogActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetPoseActionDataRelativeToNow)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, float fPredictedSecondsFromNow, struct InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetPoseActionDataForNextFrame)(VRActionHandle_t action, ETrackingUniverseOrigin eOrigin, struct InputPoseActionData_t * pActionData, uint32_t unActionDataSize, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalActionData)(VRActionHandle_t action, struct InputSkeletalActionData_t * pActionData, uint32_t unActionDataSize);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetDominantHand)(ETrackedControllerRole * peDominantHand);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *SetDominantHand)(ETrackedControllerRole eDominantHand);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetBoneCount)(VRActionHandle_t action, uint32_t * pBoneCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetBoneHierarchy)(VRActionHandle_t action, BoneIndex_t * pParentIndices, uint32_t unIndexArayCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetBoneName)(VRActionHandle_t action, BoneIndex_t nBoneIndex, char * pchBoneName, uint32_t unNameBufferSize);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalReferenceTransforms)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalReferencePose eReferencePose, struct VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalTrackingLevel)(VRActionHandle_t action, EVRSkeletalTrackingLevel * pSkeletalTrackingLevel);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalBoneData)(VRActionHandle_t action, EVRSkeletalTransformSpace eTransformSpace, EVRSkeletalMotionRange eMotionRange, struct VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalSummaryData)(VRActionHandle_t action, EVRSummaryType eSummaryType, struct VRSkeletalSummaryData_t * pSkeletalSummaryData);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetSkeletalBoneDataCompressed)(VRActionHandle_t action, EVRSkeletalMotionRange eMotionRange, void * pvCompressedData, uint32_t unCompressedSize, uint32_t * punRequiredCompressedSize);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *DecompressSkeletalBoneData)(void * pvCompressedBuffer, uint32_t unCompressedBufferSize, EVRSkeletalTransformSpace eTransformSpace, struct VRBoneTransform_t * pTransformArray, uint32_t unTransformArrayCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *TriggerHapticVibrationAction)(VRActionHandle_t action, float fStartSecondsFromNow, float fDurationSeconds, float fFrequency, float fAmplitude, VRInputValueHandle_t ulRestrictToDevice);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t digitalActionHandle, VRInputValueHandle_t * originsOut, uint32_t originOutCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetOriginLocalizedName)(VRInputValueHandle_t origin, char * pchNameArray, uint32_t unNameArraySize, int32_t unStringSectionsToInclude);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetOriginTrackedDeviceInfo)(VRInputValueHandle_t origin, struct InputOriginInfo_t * pOriginInfo, uint32_t unOriginInfoSize);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetActionBindingInfo)(VRActionHandle_t action, struct InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, uint32_t * punReturnedBindingInfoCount);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *ShowActionOrigins)(VRActionSetHandle_t actionSetHandle, VRActionHandle_t ulActionHandle);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *ShowBindingsForActionSet)(struct VRActiveActionSet_t * pSets, uint32_t unSizeOfVRSelectedActionSet_t, uint32_t unSetCount, VRInputValueHandle_t originToHighlight);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetComponentStateForBinding)(char * pchRenderModelName, char * pchComponentName, struct InputBindingInfo_t * pOriginInfo, uint32_t unBindingInfoSize, uint32_t unBindingInfoCount, RenderModel_ComponentState_t * pComponentState);
+	bool (OPENVR_FNTABLE_CALLTYPE *IsUsingLegacyInput)();
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *OpenBindingUI)(char * pchAppKey, VRActionSetHandle_t ulActionSetHandle, VRInputValueHandle_t ulDeviceHandle, bool bShowOnDesktop);
+	EVRInputError (OPENVR_FNTABLE_CALLTYPE *GetBindingVariant)(VRInputValueHandle_t ulDevicePath, char * pchVariantArray, uint32_t unVariantArraySize);
+};
+
+struct VR_IVRIOBuffer_FnTable
+{
+	EIOBufferError (OPENVR_FNTABLE_CALLTYPE *Open)(char * pchPath, EIOBufferMode mode, uint32_t unElementSize, uint32_t unElements, IOBufferHandle_t * pulBuffer);
+	EIOBufferError (OPENVR_FNTABLE_CALLTYPE *Close)(IOBufferHandle_t ulBuffer);
+	EIOBufferError (OPENVR_FNTABLE_CALLTYPE *Read)(IOBufferHandle_t ulBuffer, void * pDst, uint32_t unBytes, uint32_t * punRead);
+	EIOBufferError (OPENVR_FNTABLE_CALLTYPE *Write)(IOBufferHandle_t ulBuffer, void * pSrc, uint32_t unBytes);
+	PropertyContainerHandle_t (OPENVR_FNTABLE_CALLTYPE *PropertyContainer)(IOBufferHandle_t ulBuffer);
+	bool (OPENVR_FNTABLE_CALLTYPE *HasReaders)(IOBufferHandle_t ulBuffer);
+};
+
+struct VR_IVRSpatialAnchors_FnTable
+{
+	EVRSpatialAnchorError (OPENVR_FNTABLE_CALLTYPE *CreateSpatialAnchorFromDescriptor)(char * pchDescriptor, SpatialAnchorHandle_t * pHandleOut);
+	EVRSpatialAnchorError (OPENVR_FNTABLE_CALLTYPE *CreateSpatialAnchorFromPose)(TrackedDeviceIndex_t unDeviceIndex, ETrackingUniverseOrigin eOrigin, struct SpatialAnchorPose_t * pPose, SpatialAnchorHandle_t * pHandleOut);
+	EVRSpatialAnchorError (OPENVR_FNTABLE_CALLTYPE *GetSpatialAnchorPose)(SpatialAnchorHandle_t unHandle, ETrackingUniverseOrigin eOrigin, struct SpatialAnchorPose_t * pPoseOut);
+	EVRSpatialAnchorError (OPENVR_FNTABLE_CALLTYPE *GetSpatialAnchorDescriptor)(SpatialAnchorHandle_t unHandle, char * pchDescriptorOut, uint32_t * punDescriptorBufferLenInOut);
+};
+
+struct VR_IVRDebug_FnTable
+{
+	EVRDebugError (OPENVR_FNTABLE_CALLTYPE *EmitVrProfilerEvent)(char * pchMessage);
+	EVRDebugError (OPENVR_FNTABLE_CALLTYPE *BeginVrProfilerEvent)(VrProfilerEventHandle_t * pHandleOut);
+	EVRDebugError (OPENVR_FNTABLE_CALLTYPE *FinishVrProfilerEvent)(VrProfilerEventHandle_t hHandle, char * pchMessage);
+	uint32_t (OPENVR_FNTABLE_CALLTYPE *DriverDebugRequest)(TrackedDeviceIndex_t unDeviceIndex, char * pchRequest, char * pchResponseBuffer, uint32_t unResponseBufferSize);
+};
+
+struct VR_IVRProperties_FnTable
+{
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *ReadPropertyBatch)(PropertyContainerHandle_t ulContainerHandle, struct PropertyRead_t * pBatch, uint32_t unBatchEntryCount);
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *WritePropertyBatch)(PropertyContainerHandle_t ulContainerHandle, struct PropertyWrite_t * pBatch, uint32_t unBatchEntryCount);
+	char * (OPENVR_FNTABLE_CALLTYPE *GetPropErrorNameFromEnum)(ETrackedPropertyError error);
+	PropertyContainerHandle_t (OPENVR_FNTABLE_CALLTYPE *TrackedDeviceToPropertyContainer)(TrackedDeviceIndex_t nDevice);
+};
+
+struct VR_IVRPaths_FnTable
+{
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *ReadPathBatch)(PropertyContainerHandle_t ulRootHandle, struct PathRead_t * pBatch, uint32_t unBatchEntryCount);
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *WritePathBatch)(PropertyContainerHandle_t ulRootHandle, struct PathWrite_t * pBatch, uint32_t unBatchEntryCount);
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *StringToHandle)(PathHandle_t * pHandle, char * pchPath);
+	ETrackedPropertyError (OPENVR_FNTABLE_CALLTYPE *HandleToString)(PathHandle_t pHandle, char * pchBuffer, uint32_t unBufferSize, uint32_t * punBufferSizeUsed);
+};
+
+struct VR_IVRBlockQueue_FnTable
+{
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *Create)(PropertyContainerHandle_t * pulQueueHandle, char * pchPath, uint32_t unBlockDataSize, uint32_t unBlockHeaderSize, uint32_t unBlockCount, uint32_t unFlags);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *Connect)(PropertyContainerHandle_t * pulQueueHandle, char * pchPath);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *Destroy)(PropertyContainerHandle_t ulQueueHandle);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *AcquireWriteOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t * pulBlockHandle, void ** ppvBuffer);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *ReleaseWriteOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t ulBlockHandle);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *WaitAndAcquireReadOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t * pulBlockHandle, void ** ppvBuffer, EBlockQueueReadType eReadType, uint32_t unTimeoutMs);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *AcquireReadOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t * pulBlockHandle, void ** ppvBuffer, EBlockQueueReadType eReadType);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *ReleaseReadOnlyBlock)(PropertyContainerHandle_t ulQueueHandle, PropertyContainerHandle_t ulBlockHandle);
+	EBlockQueueError (OPENVR_FNTABLE_CALLTYPE *QueueHasReader)(PropertyContainerHandle_t ulQueueHandle, bool * pbHasReaders);
+};
+
+
+#if 0
+// Global entry points
+S_API intptr_t VR_InitInternal( EVRInitError *peError, EVRApplicationType eType );
+S_API void VR_ShutdownInternal();
+S_API bool VR_IsHmdPresent();
+S_API intptr_t VR_GetGenericInterface( const char *pchInterfaceVersion, EVRInitError *peError );
+S_API bool VR_IsRuntimeInstalled();
+S_API const char * VR_GetVRInitErrorAsSymbol( EVRInitError error );
+S_API const char * VR_GetVRInitErrorAsEnglishDescription( EVRInitError error );
+#endif
+
+#endif // __OPENVR_API_FLAT_H__
+
+